?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.2.0
[davej-history.git] / fs / ufs / namei.c
blobdc5dccf4ce34368780c31707ecc2532f193a4fc8
1 /*
2 * linux/fs/ufs/namei.c
3 *
4 * Copyright (C) 1998
5 * Daniel Pirkl <daniel.pirkl@email.cz>
6 * Charles University, Faculty of Mathematics and Physics
7 *
8 * from
9 *
10 * linux/fs/ext2/namei.c
11 *
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise Pascal
15 * Universite Pierre et Marie Curie (Paris VI)
16 *
17 * from
18 *
19 * linux/fs/minix/namei.c
20 *
21 * Copyright (C) 1991, 1992 Linus Torvalds
22 *
23 * Big-endian to little-endian byte-swapping/bitmaps by
24 * David S. Miller (davem@caip.rutgers.edu), 1995
25 */
26
27 #include <asm/uaccess.h>
28
29 #include <linux/errno.h>
30 #include <linux/fs.h>
31 #include <linux/ufs_fs.h>
32 #include <linux/fcntl.h>
33 #include <linux/sched.h>
34 #include <linux/stat.h>
35 #include <linux/string.h>
36 #include <linux/locks.h>
37 #include <linux/quotaops.h>
38
39 #include "swab.h"
40 #include "util.h"
41
42 #undef UFS_NAMEI_DEBUG
43
44 #ifdef UFS_NAMEI_DEBUG
45 #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
46 #else
47 #define UFSD(x)
48 #endif
49
50 /*
51 * define how far ahead to read directories while searching them.
52 */
53 #define NAMEI_RA_CHUNKS 2
54 #define NAMEI_RA_BLOCKS 4
55 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
56 #define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))
57
58 /*
59 * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
60 *
61 * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
62 */
63 static inline int ufs_match (int len, const char * const name,
64 struct ufs_dir_entry * de, unsigned flags, unsigned swab)
65 {
66 if (len != ufs_get_de_namlen(de))
67 return 0;
68 if (!de->d_ino)
69 return 0;
70 return !memcmp(name, de->d_name, len);
71 }
72
73 /*
74 * ufs_find_entry()
75 *
76 * finds an entry in the specified directory with the wanted name. It
77 * returns the cache buffer in which the entry was found, and the entry
78 * itself (as a parameter - res_dir). It does NOT read the inode of the
79 * entry - you'll have to do that yourself if you want to.
80 */
81 static struct buffer_head * ufs_find_entry (struct inode * dir,
82 const char * const name, int namelen, struct ufs_dir_entry ** res_dir)
83 {
84 struct super_block * sb;
85 struct buffer_head * bh_use[NAMEI_RA_SIZE];
86 struct buffer_head * bh_read[NAMEI_RA_SIZE];
87 unsigned long offset;
88 int block, toread, i, err;
89 unsigned flags, swab;
90
91 UFSD(("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen))
92
93 *res_dir = NULL;
94 if (!dir)
95 return NULL;
96
97 sb = dir->i_sb;
98 flags = sb->u.ufs_sb.s_flags;
99 swab = sb->u.ufs_sb.s_swab;
100
101 if (namelen > UFS_MAXNAMLEN)
102 return NULL;
103
104 memset (bh_use, 0, sizeof (bh_use));
105 toread = 0;
106 for (block = 0; block < NAMEI_RA_SIZE; ++block) {
107 struct buffer_head * bh;
108
109 if ((block << sb->s_blocksize_bits) >= dir->i_size)
110 break;
111 bh = ufs_getfrag (dir, block, 0, &err);
112 bh_use[block] = bh;
113 if (bh && !buffer_uptodate(bh))
114 bh_read[toread++] = bh;
115 }
116
117 for (block = 0, offset = 0; offset < dir->i_size; block++) {
118 struct buffer_head * bh;
119 struct ufs_dir_entry * de;
120 char * dlimit;
121
122 if ((block % NAMEI_RA_BLOCKS) == 0 && toread) {
123 ll_rw_block (READ, toread, bh_read);
124 toread = 0;
125 }
126 bh = bh_use[block % NAMEI_RA_SIZE];
127 if (!bh) {
128 ufs_error (sb, "ufs_find_entry",
129 "directory #%lu contains a hole at offset %lu",
130 dir->i_ino, offset);
131 offset += sb->s_blocksize;
132 continue;
133 }
134 wait_on_buffer (bh);
135 if (!buffer_uptodate(bh)) {
136 /*
137 * read error: all bets are off
138 */
139 break;
140 }
141
142 de = (struct ufs_dir_entry *) bh->b_data;
143 dlimit = bh->b_data + sb->s_blocksize;
144 while ((char *) de < dlimit && offset < dir->i_size) {
145 /* this code is executed quadratically often */
146 /* do minimal checking by hand */
147 int de_len;
148
149 if ((char *) de + namelen <= dlimit &&
150 ufs_match (namelen, name, de, flags, swab)) {
151 /* found a match -
152 just to be sure, do a full check */
153 if (!ufs_check_dir_entry("ufs_find_entry",
154 dir, de, bh, offset))
155 goto failed;
156 for (i = 0; i < NAMEI_RA_SIZE; ++i) {
157 if (bh_use[i] != bh)
158 brelse (bh_use[i]);
159 }
160 *res_dir = de;
161 return bh;
162 }
163 /* prevent looping on a bad block */
164 de_len = SWAB16(de->d_reclen);
165 if (de_len <= 0)
166 goto failed;
167 offset += de_len;
168 de = (struct ufs_dir_entry *) ((char *) de + de_len);
169 }
170
171 brelse (bh);
172 if (((block + NAMEI_RA_SIZE) << sb->s_blocksize_bits ) >=
173 dir->i_size)
174 bh = NULL;
175 else
176 bh = ufs_getfrag (dir, block + NAMEI_RA_SIZE, 0, &err);
177 bh_use[block % NAMEI_RA_SIZE] = bh;
178 if (bh && !buffer_uptodate(bh))
179 bh_read[toread++] = bh;
180 }
181
182 failed:
183 for (i = 0; i < NAMEI_RA_SIZE; ++i) brelse (bh_use[i]);
184 UFSD(("EXIT\n"))
185 return NULL;
186 }
187
188 int ufs_lookup(struct inode * dir, struct dentry *dentry)
189 {
190 struct super_block * sb;
191 struct inode * inode;
192 struct ufs_dir_entry * de;
193 struct buffer_head * bh;
194 unsigned swab;
195
196 UFSD(("ENTER\n"))
197
198 sb = dir->i_sb;
199 swab = sb->u.ufs_sb.s_swab;
200
201 if (dentry->d_name.len > UFS_MAXNAMLEN)
202 return -ENAMETOOLONG;
203
204 bh = ufs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
205 inode = NULL;
206 if (bh) {
207 unsigned long ino = SWAB32(de->d_ino);
208 brelse (bh);
209 inode = iget(sb, ino);
210 if (!inode)
211 return -EACCES;
212 }
213 d_add(dentry, inode);
214 UFSD(("EXIT\n"))
215 return 0;
216 }
217
218 /*
219 * ufs_add_entry()
220 *
221 * adds a file entry to the specified directory, using the same
222 * semantics as ufs_find_entry(). It returns NULL if it failed.
223 *
224 * NOTE!! The inode part of 'de' is left at 0 - which means you
225 * may not sleep between calling this and putting something into
226 * the entry, as someone else might have used it while you slept.
227 */
228 static struct buffer_head * ufs_add_entry (struct inode * dir,
229 const char * name, int namelen, struct ufs_dir_entry ** res_dir,
230 int *err )
231 {
232 struct super_block * sb;
233 struct ufs_sb_private_info * uspi;
234 unsigned long offset;
235 unsigned fragoff;
236 unsigned short rec_len;
237 struct buffer_head * bh;
238 struct ufs_dir_entry * de, * de1;
239 unsigned flags, swab;
240
241 UFSD(("ENTER, name %s, namelen %u\n", name, namelen))
242
243 *err = -EINVAL;
244 *res_dir = NULL;
245 if (!dir || !dir->i_nlink)
246 return NULL;
247
248 sb = dir->i_sb;
249 flags = sb->u.ufs_sb.s_flags;
250 swab = sb->u.ufs_sb.s_swab;
251 uspi = sb->u.ufs_sb.s_uspi;
252
253 if (namelen > UFS_MAXNAMLEN)
254 {
255 *err = -ENAMETOOLONG;
256 return NULL;
257 }
258
259 if (!namelen)
260 return NULL;
261 /*
262 * Is this a busy deleted directory? Can't create new files if so
263 */
264 if (dir->i_size == 0)
265 {
266 *err = -ENOENT;
267 return NULL;
268 }
269 bh = ufs_bread (dir, 0, 0, err);
270 if (!bh)
271 return NULL;
272 rec_len = UFS_DIR_REC_LEN(namelen);
273 offset = 0;
274 de = (struct ufs_dir_entry *) bh->b_data;
275 *err = -ENOSPC;
276 while (1) {
277 if ((char *)de >= UFS_SECTOR_SIZE + bh->b_data) {
278 fragoff = offset & ~uspi->s_fmask;
279 if (fragoff != 0 && fragoff != UFS_SECTOR_SIZE)
280 ufs_error (sb, "ufs_add_entry", "internal error"
281 " fragoff %u", fragoff);
282 if (!fragoff) {
283 brelse (bh);
284 bh = NULL;
285 bh = ufs_bread (dir, offset >> sb->s_blocksize_bits, 1, err);
286 }
287 if (!bh)
288 return NULL;
289 if (dir->i_size <= offset) {
290 if (dir->i_size == 0) {
291 *err = -ENOENT;
292 return NULL;
293 }
294 de = (struct ufs_dir_entry *) (bh->b_data + fragoff);
295 de->d_ino = SWAB32(0);
296 de->d_reclen = SWAB16(UFS_SECTOR_SIZE);
297 ufs_set_de_namlen(de,0);
298 dir->i_size = offset + UFS_SECTOR_SIZE;
299 mark_inode_dirty(dir);
300 } else {
301 de = (struct ufs_dir_entry *) bh->b_data;
302 }
303 }
304 if (!ufs_check_dir_entry ("ufs_add_entry", dir, de, bh, offset)) {
305 *err = -ENOENT;
306 brelse (bh);
307 return NULL;
308 }
309 if (ufs_match (namelen, name, de, flags, swab)) {
310 *err = -EEXIST;
311 brelse (bh);
312 return NULL;
313 }
314 if ((SWAB32(de->d_ino) == 0 && SWAB16(de->d_reclen) >= rec_len) ||
315 (SWAB16(de->d_reclen) >= UFS_DIR_REC_LEN(ufs_get_de_namlen(de)) + rec_len)) {
316 offset += SWAB16(de->d_reclen);
317 if (SWAB32(de->d_ino)) {
318 de1 = (struct ufs_dir_entry *) ((char *) de +
319 UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
320 de1->d_reclen = SWAB16(SWAB16(de->d_reclen) -
321 UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
322 de->d_reclen = SWAB16(UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
323 de = de1;
324 }
325 de->d_ino = SWAB32(0);
326 ufs_set_de_namlen(de, namelen);
327 memcpy (de->d_name, name, namelen + 1);
328 /*
329 * XXX shouldn't update any times until successful
330 * completion of syscall, but too many callers depend
331 * on this.
332 *
333 * XXX similarly, too many callers depend on
334 * ufs_new_inode() setting the times, but error
335 * recovery deletes the inode, so the worst that can
336 * happen is that the times are slightly out of date
337 * and/or different from the directory change time.
338 */
339 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
340 mark_inode_dirty(dir);
341 dir->i_version = ++event;
342 mark_buffer_dirty(bh, 1);
343 *res_dir = de;
344 *err = 0;
345
346 UFSD(("EXIT\n"))
347 return bh;
348 }
349 offset += SWAB16(de->d_reclen);
350 de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
351 }
352 brelse (bh);
353 UFSD(("EXIT (FAILED)\n"))
354 return NULL;
355 }
356
357 /*
358 * ufs_delete_entry deletes a directory entry by merging it with the
359 * previous entry.
360 */
361 static int ufs_delete_entry (struct inode * inode, struct ufs_dir_entry * dir,
362 struct buffer_head * bh )
363
364 {
365 struct super_block * sb;
366 struct ufs_dir_entry * de, * pde;
367 unsigned i;
368 unsigned flags, swab;
369
370 UFSD(("ENTER\n"))
371
372 sb = inode->i_sb;
373 flags = sb->u.ufs_sb.s_flags;
374 swab = sb->u.ufs_sb.s_swab;
375 i = 0;
376 pde = NULL;
377 de = (struct ufs_dir_entry *) bh->b_data;
378
379 UFSD(("ino %u, reclen %u, namlen %u, name %s\n", SWAB32(de->d_ino),
380 SWAB16(de->d_reclen), ufs_get_de_namlen(de), de->d_name))
381
382 while (i < bh->b_size) {
383 if (!ufs_check_dir_entry ("ufs_delete_entry", inode, de, bh, i))
384 return -EIO;
385 if (de == dir) {
386 if (pde)
387 pde->d_reclen =
388 SWAB16(SWAB16(pde->d_reclen) +
389 SWAB16(dir->d_reclen));
390 dir->d_ino = SWAB32(0);
391 UFSD(("EXIT\n"))
392 return 0;
393 }
394 i += SWAB16(de->d_reclen);
395 if (i == UFS_SECTOR_SIZE) pde = NULL;
396 else pde = de;
397 de = (struct ufs_dir_entry *)
398 ((char *) de + SWAB16(de->d_reclen));
399 if (i == UFS_SECTOR_SIZE && SWAB16(de->d_reclen) == 0)
400 break;
401 }
402 UFSD(("EXIT\n"))
403 return -ENOENT;
404 }
405
406 /*
407 * By the time this is called, we already have created
408 * the directory cache entry for the new file, but it
409 * is so far negative - it has no inode.
410 *
411 * If the create succeeds, we fill in the inode information
412 * with d_instantiate().
413 */
414 int ufs_create (struct inode * dir, struct dentry * dentry, int mode)
415 {
416 struct super_block * sb;
417 struct inode * inode;
418 struct buffer_head * bh;
419 struct ufs_dir_entry * de;
420 int err = -EIO;
421 unsigned flags, swab;
422
423 sb = dir->i_sb;
424 swab = sb->u.ufs_sb.s_swab;
425 flags = sb->u.ufs_sb.s_flags;
426 /*
427 * N.B. Several error exits in ufs_new_inode don't set err.
428 */
429 UFSD(("ENTER\n"))
430
431 inode = ufs_new_inode (dir, mode, &err);
432 if (!inode)
433 return err;
434 inode->i_op = &ufs_file_inode_operations;
435 inode->i_mode = mode;
436 mark_inode_dirty(inode);
437 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
438 if (!bh) {
439 inode->i_nlink--;
440 mark_inode_dirty(inode);
441 iput (inode);
442 return err;
443 }
444 de->d_ino = SWAB32(inode->i_ino);
445 ufs_set_de_type (de, inode->i_mode);
446 dir->i_version = ++event;
447 mark_buffer_dirty(bh, 1);
448 if (IS_SYNC(dir)) {
449 ll_rw_block (WRITE, 1, &bh);
450 wait_on_buffer (bh);
451 }
452 brelse (bh);
453 d_instantiate(dentry, inode);
454
455 UFSD(("EXIT\n"))
456
457 return 0;
458 }
459
460 int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
461 {
462 struct super_block * sb;
463 struct inode * inode;
464 struct buffer_head * bh;
465 struct ufs_dir_entry * de;
466 int err = -EIO;
467 unsigned flags, swab;
468
469 sb = dir->i_sb;
470 flags = sb->u.ufs_sb.s_flags;
471 swab = sb->u.ufs_sb.s_swab;
472
473 err = -ENAMETOOLONG;
474 if (dentry->d_name.len > UFS_MAXNAMLEN)
475 goto out;
476
477 inode = ufs_new_inode (dir, mode, &err);
478 if (!inode)
479 goto out;
480
481 inode->i_uid = current->fsuid;
482 inode->i_mode = mode;
483 inode->i_op = NULL;
484 if (S_ISREG(inode->i_mode))
485 inode->i_op = &ufs_file_inode_operations;
486 else if (S_ISCHR(inode->i_mode))
487 inode->i_op = &chrdev_inode_operations;
488 else if (S_ISBLK(inode->i_mode))
489 inode->i_op = &blkdev_inode_operations;
490 else if (S_ISFIFO(inode->i_mode))
491 init_fifo(inode);
492 if (S_ISBLK(mode) || S_ISCHR(mode))
493 inode->i_rdev = to_kdev_t(rdev);
494 mark_inode_dirty(inode);
495 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
496 if (!bh)
497 goto out_no_entry;
498 de->d_ino = SWAB32(inode->i_ino);
499 ufs_set_de_type (de, inode->i_mode);
500 dir->i_version = ++event;
501 mark_buffer_dirty(bh, 1);
502 if (IS_SYNC(dir)) {
503 ll_rw_block (WRITE, 1, &bh);
504 wait_on_buffer (bh);
505 }
506 d_instantiate(dentry, inode);
507 brelse(bh);
508 err = 0;
509 out:
510 return err;
511
512 out_no_entry:
513 inode->i_nlink--;
514 mark_inode_dirty(inode);
515 iput(inode);
516 goto out;
517 }
518
519 int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
520 {
521 struct super_block * sb;
522 struct inode * inode;
523 struct buffer_head * bh, * dir_block;
524 struct ufs_dir_entry * de;
525 int err;
526 unsigned flags, swab;
527
528 sb = dir->i_sb;
529 flags = sb->u.ufs_sb.s_flags;
530 swab = sb->u.ufs_sb.s_swab;
531
532 err = -ENAMETOOLONG;
533 if (dentry->d_name.len > UFS_MAXNAMLEN)
534 goto out;
535
536 err = -EMLINK;
537 if (dir->i_nlink >= UFS_LINK_MAX)
538 goto out;
539 err = -EIO;
540 inode = ufs_new_inode (dir, S_IFDIR, &err);
541 if (!inode)
542 goto out;
543
544 inode->i_op = &ufs_dir_inode_operations;
545 inode->i_size = UFS_SECTOR_SIZE;
546 dir_block = ufs_bread (inode, 0, 1, &err);
547 if (!dir_block) {
548 inode->i_nlink--; /* is this nlink == 0? */
549 mark_inode_dirty(inode);
550 iput (inode);
551 return err;
552 }
553 inode->i_blocks = sb->s_blocksize / UFS_SECTOR_SIZE;
554 de = (struct ufs_dir_entry *) dir_block->b_data;
555 de->d_ino = SWAB32(inode->i_ino);
556 ufs_set_de_type (de, inode->i_mode);
557 ufs_set_de_namlen(de,1);
558 de->d_reclen = SWAB16(UFS_DIR_REC_LEN(1));
559 strcpy (de->d_name, ".");
560 de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
561 de->d_ino = SWAB32(dir->i_ino);
562 ufs_set_de_type (de, dir->i_mode);
563 de->d_reclen = SWAB16(UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
564 ufs_set_de_namlen(de,2);
565 strcpy (de->d_name, "..");
566 inode->i_nlink = 2;
567 mark_buffer_dirty(dir_block, 1);
568 brelse (dir_block);
569 inode->i_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask);
570 if (dir->i_mode & S_ISGID)
571 inode->i_mode |= S_ISGID;
572 mark_inode_dirty(inode);
573 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
574 if (!bh)
575 goto out_no_entry;
576 de->d_ino = SWAB32(inode->i_ino);
577 ufs_set_de_type (de, inode->i_mode);
578 dir->i_version = ++event;
579 mark_buffer_dirty(bh, 1);
580 if (IS_SYNC(dir)) {
581 ll_rw_block (WRITE, 1, &bh);
582 wait_on_buffer (bh);
583 }
584 dir->i_nlink++;
585 mark_inode_dirty(dir);
586 d_instantiate(dentry, inode);
587 brelse (bh);
588 err = 0;
589 out:
590 return err;
591
592 out_no_entry:
593 inode->i_nlink = 0;
594 mark_inode_dirty(inode);
595 iput (inode);
596 goto out;
597 }
598
599 /*
600 * routine to check that the specified directory is empty (for rmdir)
601 */
602 static int ufs_empty_dir (struct inode * inode)
603 {
604 struct super_block * sb;
605 unsigned long offset;
606 struct buffer_head * bh;
607 struct ufs_dir_entry * de, * de1;
608 int err;
609 unsigned swab;
610
611 sb = inode->i_sb;
612 swab = sb->u.ufs_sb.s_swab;
613
614 if (inode->i_size < UFS_DIR_REC_LEN(1) + UFS_DIR_REC_LEN(2) ||
615 !(bh = ufs_bread (inode, 0, 0, &err))) {
616 ufs_warning (inode->i_sb, "empty_dir",
617 "bad directory (dir #%lu) - no data block",
618 inode->i_ino);
619 return 1;
620 }
621 de = (struct ufs_dir_entry *) bh->b_data;
622 de1 = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
623 if (SWAB32(de->d_ino) != inode->i_ino || !SWAB32(de1->d_ino) ||
624 strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) {
625 ufs_warning (inode->i_sb, "empty_dir",
626 "bad directory (dir #%lu) - no `.' or `..'",
627 inode->i_ino);
628 return 1;
629 }
630 offset = SWAB16(de->d_reclen) + SWAB16(de1->d_reclen);
631 de = (struct ufs_dir_entry *) ((char *) de1 + SWAB16(de1->d_reclen));
632 while (offset < inode->i_size ) {
633 if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
634 brelse (bh);
635 bh = ufs_bread (inode, offset >> sb->s_blocksize_bits, 1, &err);
636 if (!bh) {
637 ufs_error (sb, "empty_dir",
638 "directory #%lu contains a hole at offset %lu",
639 inode->i_ino, offset);
640 offset += sb->s_blocksize;
641 continue;
642 }
643 de = (struct ufs_dir_entry *) bh->b_data;
644 }
645 if (!ufs_check_dir_entry ("empty_dir", inode, de, bh, offset)) {
646 brelse (bh);
647 return 1;
648 }
649 if (SWAB32(de->d_ino)) {
650 brelse (bh);
651 return 0;
652 }
653 offset += SWAB16(de->d_reclen);
654 de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
655 }
656 brelse (bh);
657 return 1;
658 }
659
660 int ufs_rmdir (struct inode * dir, struct dentry *dentry)
661 {
662 struct super_block *sb;
663 int retval;
664 struct inode * inode;
665 struct buffer_head * bh;
666 struct ufs_dir_entry * de;
667 unsigned swab;
668
669 sb = dir->i_sb;
670 swab = sb->u.ufs_sb.s_swab;
671
672 UFSD(("ENTER\n"))
673
674 retval = -ENAMETOOLONG;
675 if (dentry->d_name.len > UFS_MAXNAMLEN)
676 goto out;
677
678 retval = -ENOENT;
679 bh = ufs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
680 if (!bh)
681 goto end_rmdir;
682
683 inode = dentry->d_inode;
684 DQUOT_INIT(inode);
685
686 retval = -EIO;
687 if (SWAB32(de->d_ino) != inode->i_ino)
688 goto end_rmdir;
689
690 if (!ufs_empty_dir (inode))
691 retval = -ENOTEMPTY;
692 else if (SWAB32(de->d_ino) != inode->i_ino)
693 retval = -ENOENT;
694 else {
695 retval = ufs_delete_entry (dir, de, bh);
696 dir->i_version = ++event;
697 }
698 if (retval)
699 goto end_rmdir;
700 mark_buffer_dirty(bh, 1);
701 if (IS_SYNC(dir)) {
702 ll_rw_block (WRITE, 1, &bh);
703 wait_on_buffer (bh);
704 }
705 if (inode->i_nlink != 2)
706 ufs_warning (inode->i_sb, "ufs_rmdir",
707 "empty directory has nlink!=2 (%d)",
708 inode->i_nlink);
709 inode->i_version = ++event;
710 inode->i_nlink = 0;
711 inode->i_size = 0;
712 mark_inode_dirty(inode);
713 dir->i_nlink--;
714 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
715 mark_inode_dirty(dir);
716 d_delete(dentry);
717
718 end_rmdir:
719 brelse (bh);
720 out:
721 UFSD(("EXIT\n"))
722
723 return retval;
724 }
725
726 int ufs_unlink(struct inode * dir, struct dentry *dentry)
727 {
728 struct super_block * sb;
729 int retval;
730 struct inode * inode;
731 struct buffer_head * bh;
732 struct ufs_dir_entry * de;
733 unsigned flags, swab;
734
735 sb = dir->i_sb;
736 flags = sb->u.ufs_sb.s_flags;
737 swab = sb->u.ufs_sb.s_swab;
738
739 retval = -ENAMETOOLONG;
740 if (dentry->d_name.len > UFS_MAXNAMLEN)
741 goto out;
742
743 retval = -ENOENT;
744 bh = ufs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
745 UFSD(("de: ino %u, reclen %u, namelen %u, name %s\n", SWAB32(de->d_ino),
746 SWAB16(de->d_reclen), ufs_get_de_namlen(de), de->d_name))
747 if (!bh)
748 goto end_unlink;
749
750 inode = dentry->d_inode;
751 DQUOT_INIT(inode);
752
753 retval = -EIO;
754 if (SWAB32(de->d_ino) != inode->i_ino)
755 goto end_unlink;
756
757 if (!inode->i_nlink) {
758 ufs_warning (inode->i_sb, "ufs_unlink",
759 "Deleting nonexistent file (%lu), %d",
760 inode->i_ino, inode->i_nlink);
761 inode->i_nlink = 1;
762 }
763 retval = ufs_delete_entry (dir, de, bh);
764 if (retval)
765 goto end_unlink;
766 dir->i_version = ++event;
767 mark_buffer_dirty(bh, 1);
768 if (IS_SYNC(dir)) {
769 ll_rw_block (WRITE, 1, &bh);
770 wait_on_buffer (bh);
771 }
772 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
773 mark_inode_dirty(dir);
774 inode->i_nlink--;
775 mark_inode_dirty(inode);
776 inode->i_ctime = dir->i_ctime;
777 retval = 0;
778 d_delete(dentry); /* This also frees the inode */
779
780 end_unlink:
781 brelse (bh);
782 out:
783 return retval;
784 }
785
786
787 /*
788 * Create symbolic link. We use only slow symlinks at this time.
789 */
790 int ufs_symlink (struct inode * dir, struct dentry * dentry,
791 const char * symname)
792 {
793 struct super_block * sb;
794 struct ufs_dir_entry * de;
795 struct inode * inode;
796 struct buffer_head * bh, * name_block;
797 char * link;
798 unsigned i, l;
799 int err;
800 char c;
801 unsigned swab;
802
803 UFSD(("ENTER\n"))
804
805 sb = dir->i_sb;
806 swab = sb->u.ufs_sb.s_swab;
807 bh = name_block = NULL;
808 err = -EIO;
809
810 if (!(inode = ufs_new_inode (dir, S_IFLNK, &err))) {
811 return err;
812 }
813 inode->i_mode = S_IFLNK | S_IRWXUGO;
814 inode->i_op = &ufs_symlink_inode_operations;
815 for (l = 0; l < sb->s_blocksize - 1 && symname [l]; l++);
816
817 /***if (l >= sizeof (inode->u.ufs_i.i_data)) {***/
818 if (1) {
819 /* slow symlink */
820 name_block = ufs_bread (inode, 0, 1, &err);
821 if (!name_block) {
822 inode->i_nlink--;
823 mark_inode_dirty(inode);
824 iput (inode);
825 return err;
826 }
827 link = name_block->b_data;
828
829 } else {
830 /* fast symlink */
831 link = (char *) inode->u.ufs_i.i_u1.i_data;
832 }
833 i = 0;
834 while (i < sb->s_blocksize - 1 && (c = *(symname++)))
835 link[i++] = c;
836 link[i] = 0;
837 if (name_block) {
838 mark_buffer_dirty(name_block, 1);
839 brelse (name_block);
840 }
841 inode->i_size = i;
842 mark_inode_dirty(inode);
843
844 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
845 if (!bh)
846 goto out_no_entry;
847 de->d_ino = SWAB32(inode->i_ino);
848 dir->i_version = ++event;
849 mark_buffer_dirty(bh, 1);
850 if (IS_SYNC(dir)) {
851 ll_rw_block (WRITE, 1, &bh);
852 wait_on_buffer (bh);
853 }
854 brelse (bh);
855 d_instantiate(dentry, inode);
856 err = 0;
857 out:
858 return err;
859
860 out_no_entry:
861 inode->i_nlink--;
862 mark_inode_dirty(inode);
863 iput (inode);
864 goto out;
865 }
866
867 int ufs_link (struct dentry * old_dentry, struct inode * dir,
868 struct dentry *dentry)
869 {
870 struct super_block * sb;
871 struct inode *inode = old_dentry->d_inode;
872 struct ufs_dir_entry * de;
873 struct buffer_head * bh;
874 int err;
875 unsigned swab;
876
877 inode = old_dentry->d_inode;
878 sb = inode->i_sb;
879 swab = sb->u.ufs_sb.s_swab;
880
881 if (S_ISDIR(inode->i_mode))
882 return -EPERM;
883
884 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
885 return -EPERM;
886
887 if (inode->i_nlink >= UFS_LINK_MAX)
888 return -EMLINK;
889
890 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
891 if (!bh)
892 return err;
893
894 de->d_ino = SWAB32(inode->i_ino);
895 dir->i_version = ++event;
896 mark_buffer_dirty(bh, 1);
897 if (IS_SYNC(dir)) {
898 ll_rw_block (WRITE, 1, &bh);
899 wait_on_buffer (bh);
900 }
901 brelse (bh);
902 inode->i_nlink++;
903 inode->i_ctime = CURRENT_TIME;
904 mark_inode_dirty(inode);
905 inode->i_count++;
906 d_instantiate(dentry, inode);
907 return 0;
908 }
909
910
911 #define PARENT_INO(buffer) \
912 ((struct ufs_dir_entry *) ((char *) buffer + \
913 SWAB16(((struct ufs_dir_entry *) buffer)->d_reclen)))->d_ino
914 /*
915 * rename uses retrying to avoid race-conditions: at least they should be
916 * minimal.
917 * it tries to allocate all the blocks, then sanity-checks, and if the sanity-
918 * checks fail, it tries to restart itself again. Very practical - no changes
919 * are done until we know everything works ok.. and then all the changes can be
920 * done in one fell swoop when we have claimed all the buffers needed.
921 *
922 * Anybody can rename anything with this: the permission checks are left to the
923 * higher-level routines.
924 */
925 static int do_ufs_rename (struct inode * old_dir, struct dentry * old_dentry,
926 struct inode * new_dir, struct dentry * new_dentry )
927 {
928 struct super_block * sb;
929 struct inode * old_inode, * new_inode;
930 struct buffer_head * old_bh, * new_bh, * dir_bh;
931 struct ufs_dir_entry * old_de, * new_de;
932 int retval;
933 unsigned flags, swab;
934
935 sb = old_dir->i_sb;
936 flags = sb->u.ufs_sb.s_flags;
937 swab = sb->u.ufs_sb.s_swab;
938
939 UFSD(("ENTER\n"))
940
941 old_inode = new_inode = NULL;
942 old_bh = new_bh = dir_bh = NULL;
943 new_de = NULL;
944 retval = -ENAMETOOLONG;
945 if (old_dentry->d_name.len > UFS_MAXNAMLEN)
946 goto end_rename;
947
948 old_bh = ufs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de);
949 /*
950 * Check for inode number is _not_ due to possible IO errors.
951 * We might rmdir the source, keep it as pwd of some process
952 * and merrily kill the link to whatever was created under the
953 * same name. Goodbye sticky bit ;-<
954 */
955 retval = -ENOENT;
956 old_inode = old_dentry->d_inode;
957 if (!old_bh || SWAB32(old_de->d_ino) != old_inode->i_ino)
958 goto end_rename;
959
960 new_inode = new_dentry->d_inode;
961 new_bh = ufs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_de);
962 if (new_bh) {
963 if (!new_inode) {
964 brelse (new_bh);
965 new_bh = NULL;
966 } else {
967 DQUOT_INIT(new_inode);
968 }
969 }
970 retval = 0;
971 if (new_inode == old_inode)
972 goto end_rename;
973 if (S_ISDIR(old_inode->i_mode)) {
974 retval = -EINVAL;
975 if (is_subdir(new_dentry, old_dentry))
976 goto end_rename;
977 if (new_inode) {
978 /* Prune any children before testing for busy */
979 if (new_dentry->d_count > 1)
980 shrink_dcache_parent(new_dentry);
981 retval = -EBUSY;
982 if (new_dentry->d_count > 1)
983 goto end_rename;
984 retval = -ENOTEMPTY;
985 if (!ufs_empty_dir (new_inode))
986 goto end_rename;
987 }
988
989 dir_bh = ufs_bread (old_inode, 0, 0, &retval);
990 if (!dir_bh)
991 goto end_rename;
992 if (SWAB32(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
993 goto end_rename;
994 retval = -EMLINK;
995 if (!new_inode && new_dir->i_nlink >= UFS_LINK_MAX)
996 goto end_rename;
997 }
998
999 if (!new_bh)
1000 new_bh = ufs_add_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_de,
1001 &retval);
1002 if (!new_bh)
1003 goto end_rename;
1004 new_dir->i_version = ++event;
1005
1006 /*
1007 * ok, that's it
1008 */
1009 new_de->d_ino = SWAB32(old_inode->i_ino);
1010 ufs_delete_entry (old_dir, old_de, old_bh);
1011
1012 old_dir->i_version = ++event;
1013 if (new_inode) {
1014 new_inode->i_nlink--;
1015 new_inode->i_ctime = CURRENT_TIME;
1016 mark_inode_dirty(new_inode);
1017 }
1018 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1019 mark_inode_dirty(old_dir);
1020 if (dir_bh) {
1021 PARENT_INO(dir_bh->b_data) = SWAB32(new_dir->i_ino);
1022 mark_buffer_dirty(dir_bh, 1);
1023 old_dir->i_nlink--;
1024 mark_inode_dirty(old_dir);
1025 if (new_inode) {
1026 new_inode->i_nlink--;
1027 mark_inode_dirty(new_inode);
1028 } else {
1029 new_dir->i_nlink++;
1030 mark_inode_dirty(new_dir);
1031 }
1032 }
1033 mark_buffer_dirty(old_bh, 1);
1034 if (IS_SYNC(old_dir)) {
1035 ll_rw_block (WRITE, 1, &old_bh);
1036 wait_on_buffer (old_bh);
1037 }
1038
1039 mark_buffer_dirty(new_bh, 1);
1040 if (IS_SYNC(new_dir)) {
1041 ll_rw_block (WRITE, 1, &new_bh);
1042 wait_on_buffer (new_bh);
1043 }
1044
1045 /* Update the dcache */
1046 d_move(old_dentry, new_dentry);
1047 retval = 0;
1048 end_rename:
1049 brelse (dir_bh);
1050 brelse (old_bh);
1051 brelse (new_bh);
1052
1053 UFSD(("EXIT\n"))
1054
1055 return retval;
1056 }
1057
1058 /*
1059 * Ok, rename also locks out other renames, as they can change the parent of
1060 * a directory, and we don't want any races. Other races are checked for by
1061 * "do_rename()", which restarts if there are inconsistencies.
1062 *
1063 * Note that there is no race between different filesystems: it's only within
1064 * the same device that races occur: many renames can happen at once, as long
1065 * as they are on different partitions.
1066 *
1067 * In the second extended file system, we use a lock flag stored in the memory
1068 * super-block. This way, we really lock other renames only if they occur
1069 * on the same file system
1070 */
1071 int ufs_rename (struct inode * old_dir, struct dentry *old_dentry,
1072 struct inode * new_dir, struct dentry *new_dentry )
1073 {
1074 int result;
1075
1076 UFSD(("ENTER\n"))
1077
1078 while (old_dir->i_sb->u.ufs_sb.s_rename_lock)
1079 sleep_on (&old_dir->i_sb->u.ufs_sb.s_rename_wait);
1080 old_dir->i_sb->u.ufs_sb.s_rename_lock = 1;
1081 result = do_ufs_rename (old_dir, old_dentry, new_dir, new_dentry);
1082 old_dir->i_sb->u.ufs_sb.s_rename_lock = 0;
1083 wake_up (&old_dir->i_sb->u.ufs_sb.s_rename_wait);
1084
1085 UFSD(("EXIT\n"))
1086
1087 return result;
1088 }
1089
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux