File: /usr/src/linux/fs/hpfs/namei.c
1 /*
2 * linux/fs/hpfs/namei.c
3 *
4 * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
5 *
6 * adding & removing files & directories
7 */
8
9 #include <linux/string.h>
10 #include "hpfs_fn.h"
11
12 int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
13 {
14 const char *name = dentry->d_name.name;
15 unsigned len = dentry->d_name.len;
16 struct quad_buffer_head qbh0;
17 struct buffer_head *bh;
18 struct hpfs_dirent *de;
19 struct fnode *fnode;
20 struct dnode *dnode;
21 struct inode *result;
22 fnode_secno fno;
23 dnode_secno dno;
24 int r;
25 struct hpfs_dirent dee;
26 int err;
27 if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
28 if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
29 if (!(dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1))) goto bail1;
30 memset(&dee, 0, sizeof dee);
31 dee.directory = 1;
32 if (!(mode & 0222)) dee.read_only = 1;
33 /*dee.archive = 0;*/
34 dee.hidden = name[0] == '.';
35 dee.fnode = fno;
36 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
37 hpfs_lock_inode(dir);
38 r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
39 if (r == 1) goto bail2;
40 if (r == -1) {
41 brelse(bh);
42 hpfs_brelse4(&qbh0);
43 hpfs_free_sectors(dir->i_sb, fno, 1);
44 hpfs_free_dnode(dir->i_sb, dno);
45 hpfs_unlock_inode(dir);
46 return -EEXIST;
47 }
48 fnode->len = len;
49 memcpy(fnode->name, name, len > 15 ? 15 : len);
50 fnode->up = dir->i_ino;
51 fnode->dirflag = 1;
52 fnode->btree.n_free_nodes = 7;
53 fnode->btree.n_used_nodes = 1;
54 fnode->btree.first_free = 0x14;
55 fnode->u.external[0].disk_secno = dno;
56 fnode->u.external[0].file_secno = -1;
57 dnode->root_dnode = 1;
58 dnode->up = fno;
59 de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
60 de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
61 if (!(mode & 0222)) de->read_only = 1;
62 de->first = de->directory = 1;
63 /*de->hidden = de->system = 0;*/
64 de->fnode = fno;
65 mark_buffer_dirty(bh);
66 brelse(bh);
67 hpfs_mark_4buffers_dirty(&qbh0);
68 hpfs_brelse4(&qbh0);
69 dir->i_nlink++;
70 hpfs_lock_iget(dir->i_sb, 1);
71 if ((result = iget(dir->i_sb, fno))) {
72 result->i_hpfs_parent_dir = dir->i_ino;
73 result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
74 result->i_hpfs_ea_size = 0;
75 if (dee.read_only) result->i_mode &= ~0222;
76 if (result->i_uid != current->fsuid ||
77 result->i_gid != current->fsgid ||
78 result->i_mode != (mode | S_IFDIR)) {
79 result->i_uid = current->fsuid;
80 result->i_gid = current->fsgid;
81 result->i_mode = mode | S_IFDIR;
82 hpfs_write_inode_nolock(result);
83 }
84 d_instantiate(dentry, result);
85 }
86 hpfs_unlock_iget(dir->i_sb);
87 hpfs_unlock_inode(dir);
88 return 0;
89 bail2:
90 hpfs_brelse4(&qbh0);
91 hpfs_free_dnode(dir->i_sb, dno);
92 hpfs_unlock_inode(dir);
93 bail1:
94 brelse(bh);
95 hpfs_free_sectors(dir->i_sb, fno, 1);
96 bail:
97 return -ENOSPC;
98 }
99
100 int hpfs_create(struct inode *dir, struct dentry *dentry, int mode)
101 {
102 const char *name = dentry->d_name.name;
103 unsigned len = dentry->d_name.len;
104 struct inode *result = NULL;
105 struct buffer_head *bh;
106 struct fnode *fnode;
107 fnode_secno fno;
108 int r;
109 struct hpfs_dirent dee;
110 int err;
111 if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
112 if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
113 memset(&dee, 0, sizeof dee);
114 if (!(mode & 0222)) dee.read_only = 1;
115 dee.archive = 1;
116 dee.hidden = name[0] == '.';
117 dee.fnode = fno;
118 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
119 hpfs_lock_inode(dir);
120 r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
121 if (r == 1) goto bail1;
122 if (r == -1) {
123 brelse(bh);
124 hpfs_free_sectors(dir->i_sb, fno, 1);
125 hpfs_unlock_inode(dir);
126 return -EEXIST;
127 }
128 fnode->len = len;
129 memcpy(fnode->name, name, len > 15 ? 15 : len);
130 fnode->up = dir->i_ino;
131 mark_buffer_dirty(bh);
132 brelse(bh);
133 hpfs_lock_iget(dir->i_sb, 2);
134 if ((result = iget(dir->i_sb, fno))) {
135 hpfs_decide_conv(result, (char *)name, len);
136 result->i_hpfs_parent_dir = dir->i_ino;
137 result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
138 result->i_hpfs_ea_size = 0;
139 if (dee.read_only) result->i_mode &= ~0222;
140 if (result->i_blocks == -1) result->i_blocks = 1;
141 if (result->i_size == -1) {
142 result->i_size = 0;
143 result->i_data.a_ops = &hpfs_aops;
144 result->u.hpfs_i.mmu_private = 0;
145 }
146 if (result->i_uid != current->fsuid ||
147 result->i_gid != current->fsgid ||
148 result->i_mode != (mode | S_IFREG)) {
149 result->i_uid = current->fsuid;
150 result->i_gid = current->fsgid;
151 result->i_mode = mode | S_IFREG;
152 hpfs_write_inode_nolock(result);
153 }
154 d_instantiate(dentry, result);
155 }
156 hpfs_unlock_iget(dir->i_sb);
157 hpfs_unlock_inode(dir);
158 return 0;
159 bail1:
160 brelse(bh);
161 hpfs_free_sectors(dir->i_sb, fno, 1);
162 hpfs_unlock_inode(dir);
163 bail:
164 return -ENOSPC;
165 }
166
167 int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
168 {
169 const char *name = dentry->d_name.name;
170 unsigned len = dentry->d_name.len;
171 struct buffer_head *bh;
172 struct fnode *fnode;
173 fnode_secno fno;
174 int r;
175 struct hpfs_dirent dee;
176 struct inode *result = NULL;
177 int err;
178 if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
179 if (dir->i_sb->s_hpfs_eas < 2) return -EPERM;
180 if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
181 memset(&dee, 0, sizeof dee);
182 if (!(mode & 0222)) dee.read_only = 1;
183 dee.archive = 1;
184 dee.hidden = name[0] == '.';
185 dee.fnode = fno;
186 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
187 hpfs_lock_inode(dir);
188 r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
189 if (r == 1) goto bail1;
190 if (r == -1) {
191 brelse(bh);
192 hpfs_free_sectors(dir->i_sb, fno, 1);
193 hpfs_unlock_inode(dir);
194 return -EEXIST;
195 }
196 fnode->len = len;
197 memcpy(fnode->name, name, len > 15 ? 15 : len);
198 fnode->up = dir->i_ino;
199 mark_buffer_dirty(bh);
200 hpfs_lock_iget(dir->i_sb, 2);
201 if ((result = iget(dir->i_sb, fno))) {
202 result->i_hpfs_parent_dir = dir->i_ino;
203 result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
204 result->i_hpfs_ea_size = 0;
205 /*if (result->i_blocks == -1) result->i_blocks = 1;
206 if (result->i_size == -1) result->i_size = 0;*/
207 result->i_uid = current->fsuid;
208 result->i_gid = current->fsgid;
209 result->i_nlink = 1;
210 result->i_size = 0;
211 result->i_blocks = 1;
212 init_special_inode(result, mode, rdev);
213 hpfs_write_inode_nolock(result);
214 d_instantiate(dentry, result);
215 }
216 hpfs_unlock_iget(dir->i_sb);
217 hpfs_unlock_inode(dir);
218 brelse(bh);
219 return 0;
220 bail1:
221 brelse(bh);
222 hpfs_free_sectors(dir->i_sb, fno, 1);
223 hpfs_unlock_inode(dir);
224 bail:
225 return -ENOSPC;
226 }
227
228 extern struct address_space_operations hpfs_symlink_aops;
229
230 int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
231 {
232 const char *name = dentry->d_name.name;
233 unsigned len = dentry->d_name.len;
234 struct buffer_head *bh;
235 struct fnode *fnode;
236 fnode_secno fno;
237 int r;
238 struct hpfs_dirent dee;
239 struct inode *result;
240 int err;
241 if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
242 if (dir->i_sb->s_hpfs_eas < 2) return -EPERM;
243 if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
244 memset(&dee, 0, sizeof dee);
245 dee.archive = 1;
246 dee.hidden = name[0] == '.';
247 dee.fnode = fno;
248 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
249 hpfs_lock_inode(dir);
250 r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
251 if (r == 1) goto bail1;
252 if (r == -1) {
253 brelse(bh);
254 hpfs_free_sectors(dir->i_sb, fno, 1);
255 hpfs_unlock_inode(dir);
256 return -EEXIST;
257 }
258 fnode->len = len;
259 memcpy(fnode->name, name, len > 15 ? 15 : len);
260 fnode->up = dir->i_ino;
261 mark_buffer_dirty(bh);
262 brelse(bh);
263 hpfs_lock_iget(dir->i_sb, 2);
264 if ((result = iget(dir->i_sb, fno))) {
265 result->i_hpfs_parent_dir = dir->i_ino;
266 result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
267 result->i_hpfs_ea_size = 0;
268 /*if (result->i_blocks == -1) result->i_blocks = 1;
269 if (result->i_size == -1) result->i_size = 0;*/
270 result->i_mode = S_IFLNK | 0777;
271 result->i_uid = current->fsuid;
272 result->i_gid = current->fsgid;
273 result->i_blocks = 1;
274 result->i_size = strlen(symlink);
275 result->i_op = &page_symlink_inode_operations;
276 result->i_data.a_ops = &hpfs_symlink_aops;
277 if ((fnode = hpfs_map_fnode(dir->i_sb, fno, &bh))) {
278 hpfs_set_ea(result, fnode, "SYMLINK", (char *)symlink, strlen(symlink));
279 mark_buffer_dirty(bh);
280 brelse(bh);
281 }
282 hpfs_write_inode_nolock(result);
283 d_instantiate(dentry, result);
284 }
285 hpfs_unlock_iget(dir->i_sb);
286 hpfs_unlock_inode(dir);
287 return 0;
288 bail1:
289 brelse(bh);
290 hpfs_free_sectors(dir->i_sb, fno, 1);
291 hpfs_unlock_inode(dir);
292 bail:
293 return -ENOSPC;
294 }
295
296 int hpfs_unlink(struct inode *dir, struct dentry *dentry)
297 {
298 const char *name = dentry->d_name.name;
299 unsigned len = dentry->d_name.len;
300 struct quad_buffer_head qbh;
301 struct hpfs_dirent *de;
302 struct inode *inode = dentry->d_inode;
303 dnode_secno dno;
304 fnode_secno fno;
305 int r;
306 int rep = 0;
307 hpfs_adjust_length((char *)name, &len);
308 again:
309 hpfs_lock_2inodes(dir, inode);
310 if (!(de = map_dirent(dir, dir->i_hpfs_dno, (char *)name, len, &dno, &qbh))) {
311 hpfs_unlock_2inodes(dir, inode);
312 return -ENOENT;
313 }
314 if (de->first) {
315 hpfs_brelse4(&qbh);
316 hpfs_unlock_2inodes(dir, inode);
317 return -EPERM;
318 }
319 if (de->directory) {
320 hpfs_brelse4(&qbh);
321 hpfs_unlock_2inodes(dir, inode);
322 return -EISDIR;
323 }
324 fno = de->fnode;
325 if ((r = hpfs_remove_dirent(dir, dno, de, &qbh, 1)) == 1) hpfs_error(dir->i_sb, "there was error when removing dirent");
326 if (r != 2) {
327 inode->i_nlink--;
328 hpfs_unlock_2inodes(dir, inode);
329 } else { /* no space for deleting, try to truncate file */
330 struct iattr newattrs;
331 int err;
332 hpfs_unlock_2inodes(dir, inode);
333 if (rep)
334 goto ret;
335 d_drop(dentry);
336 if (atomic_read(&dentry->d_count) > 1 ||
337 permission(inode, MAY_WRITE) ||
338 get_write_access(inode)) {
339 d_rehash(dentry);
340 goto ret;
341 }
342 /*printk("HPFS: truncating file before delete.\n");*/
343 down(&inode->i_sem);
344 newattrs.ia_size = 0;
345 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
346 err = notify_change(dentry, &newattrs);
347 up(&inode->i_sem);
348 put_write_access(inode);
349 if (err)
350 goto ret;
351 rep = 1;
352 goto again;
353 }
354 ret:
355 return r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
356 }
357
358 int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
359 {
360 const char *name = dentry->d_name.name;
361 unsigned len = dentry->d_name.len;
362 struct quad_buffer_head qbh;
363 struct hpfs_dirent *de;
364 struct inode *inode = dentry->d_inode;
365 dnode_secno dno;
366 fnode_secno fno;
367 int n_items = 0;
368 int r;
369 hpfs_adjust_length((char *)name, &len);
370 hpfs_lock_2inodes(dir, inode);
371 if (!(de = map_dirent(dir, dir->i_hpfs_dno, (char *)name, len, &dno, &qbh))) {
372 hpfs_unlock_2inodes(dir, inode);
373 return -ENOENT;
374 }
375 if (de->first) {
376 hpfs_brelse4(&qbh);
377 hpfs_unlock_2inodes(dir, inode);
378 return -EPERM;
379 }
380 if (!de->directory) {
381 hpfs_brelse4(&qbh);
382 hpfs_unlock_2inodes(dir, inode);
383 return -ENOTDIR;
384 }
385 hpfs_count_dnodes(dir->i_sb, inode->i_hpfs_dno, NULL, NULL, &n_items);
386 if (n_items) {
387 hpfs_brelse4(&qbh);
388 hpfs_unlock_2inodes(dir, inode);
389 return -ENOTEMPTY;
390 }
391 fno = de->fnode;
392 if ((r = hpfs_remove_dirent(dir, dno, de, &qbh, 1)) == 1)
393 hpfs_error(dir->i_sb, "there was error when removing dirent");
394 if (r != 2) {
395 dir->i_nlink--;
396 inode->i_nlink = 0;
397 hpfs_unlock_2inodes(dir, inode);
398 } else hpfs_unlock_2inodes(dir, inode);
399 return r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
400 }
401
402 int hpfs_symlink_readpage(struct file *file, struct page *page)
403 {
404 char *link = kmap(page);
405 struct inode *i = page->mapping->host;
406 struct fnode *fnode;
407 struct buffer_head *bh;
408 int err;
409
410 err = -EIO;
411 lock_kernel();
412 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
413 goto fail;
414 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
415 brelse(bh);
416 if (err)
417 goto fail;
418 unlock_kernel();
419 SetPageUptodate(page);
420 kunmap(page);
421 UnlockPage(page);
422 return 0;
423
424 fail:
425 unlock_kernel();
426 SetPageError(page);
427 kunmap(page);
428 UnlockPage(page);
429 return err;
430 }
431
432 int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
433 struct inode *new_dir, struct dentry *new_dentry)
434 {
435 char *old_name = (char *)old_dentry->d_name.name;
436 int old_len = old_dentry->d_name.len;
437 char *new_name = (char *)new_dentry->d_name.name;
438 int new_len = new_dentry->d_name.len;
439 struct inode *i = old_dentry->d_inode;
440 struct inode *new_inode = new_dentry->d_inode;
441 struct quad_buffer_head qbh, qbh1;
442 struct hpfs_dirent *dep, *nde;
443 struct hpfs_dirent de;
444 dnode_secno dno;
445 int r;
446 struct buffer_head *bh;
447 struct fnode *fnode;
448 int err;
449 if ((err = hpfs_chk_name((char *)new_name, &new_len))) return err;
450 err = 0;
451 hpfs_adjust_length((char *)old_name, &old_len);
452
453 hpfs_lock_3inodes(old_dir, new_dir, i);
454
455 /* Erm? Moving over the empty non-busy directory is perfectly legal */
456 if (new_inode && S_ISDIR(new_inode->i_mode)) {
457 err = -EINVAL;
458 goto end1;
459 }
460
461 if (!(dep = map_dirent(old_dir, old_dir->i_hpfs_dno, (char *)old_name, old_len, &dno, &qbh))) {
462 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
463 err = -ENOENT;
464 goto end1;
465 }
466 copy_de(&de, dep);
467 de.hidden = new_name[0] == '.';
468
469 if (new_inode) {
470 int r;
471 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
472 if ((nde = map_dirent(new_dir, new_dir->i_hpfs_dno, (char *)new_name, new_len, NULL, &qbh1))) {
473 new_inode->i_nlink = 0;
474 copy_de(nde, &de);
475 memcpy(nde->name, new_name, new_len);
476 hpfs_mark_4buffers_dirty(&qbh1);
477 hpfs_brelse4(&qbh1);
478 goto end;
479 }
480 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
481 err = -EFSERROR;
482 goto end1;
483 }
484 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
485 goto end1;
486 }
487
488 if (new_dir == old_dir) hpfs_brelse4(&qbh);
489
490 hpfs_lock_creation(i->i_sb);
491 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
492 hpfs_unlock_creation(i->i_sb);
493 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
494 err = r == 1 ? -ENOSPC : -EFSERROR;
495 if (new_dir != old_dir) hpfs_brelse4(&qbh);
496 goto end1;
497 }
498
499 if (new_dir == old_dir)
500 if (!(dep = map_dirent(old_dir, old_dir->i_hpfs_dno, (char *)old_name, old_len, &dno, &qbh))) {
501 hpfs_unlock_creation(i->i_sb);
502 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
503 err = -ENOENT;
504 goto end1;
505 }
506
507 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
508 hpfs_unlock_creation(i->i_sb);
509 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
510 err = r == 2 ? -ENOSPC : -EFSERROR;
511 goto end1;
512 }
513 hpfs_unlock_creation(i->i_sb);
514
515 end:
516 i->i_hpfs_parent_dir = new_dir->i_ino;
517 if (S_ISDIR(i->i_mode)) {
518 new_dir->i_nlink++;
519 old_dir->i_nlink--;
520 }
521 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
522 fnode->up = new_dir->i_ino;
523 fnode->len = new_len;
524 memcpy(fnode->name, new_name, new_len>15?15:new_len);
525 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
526 mark_buffer_dirty(bh);
527 brelse(bh);
528 }
529 i->i_hpfs_conv = i->i_sb->s_hpfs_conv;
530 hpfs_decide_conv(i, (char *)new_name, new_len);
531 end1:
532 hpfs_unlock_3inodes(old_dir, new_dir, i);
533 return err;
534 }
535