?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.1pre2
[davej-history.git] / fs / ufs / namei.c
blob46c9f8e53b2291238eea971ee70ab3117b8f86f3
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
95 sb = dir->i_sb;
96 flags = sb->u.ufs_sb.s_flags;
97 swab = sb->u.ufs_sb.s_swab;
98
99 if (namelen > UFS_MAXNAMLEN)
100 return NULL;
101
102 memset (bh_use, 0, sizeof (bh_use));
103 toread = 0;
104 for (block = 0; block < NAMEI_RA_SIZE; ++block) {
105 struct buffer_head * bh;
106
107 if ((block << sb->s_blocksize_bits) >= dir->i_size)
108 break;
109 bh = ufs_getfrag (dir, block, 0, &err);
110 bh_use[block] = bh;
111 if (bh && !buffer_uptodate(bh))
112 bh_read[toread++] = bh;
113 }
114
115 for (block = 0, offset = 0; offset < dir->i_size; block++) {
116 struct buffer_head * bh;
117 struct ufs_dir_entry * de;
118 char * dlimit;
119
120 if ((block % NAMEI_RA_BLOCKS) == 0 && toread) {
121 ll_rw_block (READ, toread, bh_read);
122 toread = 0;
123 }
124 bh = bh_use[block % NAMEI_RA_SIZE];
125 if (!bh) {
126 ufs_error (sb, "ufs_find_entry",
127 "directory #%lu contains a hole at offset %lu",
128 dir->i_ino, offset);
129 offset += sb->s_blocksize;
130 continue;
131 }
132 wait_on_buffer (bh);
133 if (!buffer_uptodate(bh)) {
134 /*
135 * read error: all bets are off
136 */
137 break;
138 }
139
140 de = (struct ufs_dir_entry *) bh->b_data;
141 dlimit = bh->b_data + sb->s_blocksize;
142 while ((char *) de < dlimit && offset < dir->i_size) {
143 /* this code is executed quadratically often */
144 /* do minimal checking by hand */
145 int de_len;
146
147 if ((char *) de + namelen <= dlimit &&
148 ufs_match (namelen, name, de, flags, swab)) {
149 /* found a match -
150 just to be sure, do a full check */
151 if (!ufs_check_dir_entry("ufs_find_entry",
152 dir, de, bh, offset))
153 goto failed;
154 for (i = 0; i < NAMEI_RA_SIZE; ++i) {
155 if (bh_use[i] != bh)
156 brelse (bh_use[i]);
157 }
158 *res_dir = de;
159 return bh;
160 }
161 /* prevent looping on a bad block */
162 de_len = SWAB16(de->d_reclen);
163 if (de_len <= 0)
164 goto failed;
165 offset += de_len;
166 de = (struct ufs_dir_entry *) ((char *) de + de_len);
167 }
168
169 brelse (bh);
170 if (((block + NAMEI_RA_SIZE) << sb->s_blocksize_bits ) >=
171 dir->i_size)
172 bh = NULL;
173 else
174 bh = ufs_getfrag (dir, block + NAMEI_RA_SIZE, 0, &err);
175 bh_use[block % NAMEI_RA_SIZE] = bh;
176 if (bh && !buffer_uptodate(bh))
177 bh_read[toread++] = bh;
178 }
179
180 failed:
181 for (i = 0; i < NAMEI_RA_SIZE; ++i) brelse (bh_use[i]);
182 UFSD(("EXIT\n"))
183 return NULL;
184 }
185
186 struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry)
187 {
188 struct super_block * sb;
189 struct inode * inode;
190 struct ufs_dir_entry * de;
191 struct buffer_head * bh;
192 unsigned swab;
193
194 UFSD(("ENTER\n"))
195
196 sb = dir->i_sb;
197 swab = sb->u.ufs_sb.s_swab;
198
199 if (dentry->d_name.len > UFS_MAXNAMLEN)
200 return ERR_PTR(-ENAMETOOLONG);
201
202 bh = ufs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
203 inode = NULL;
204 if (bh) {
205 unsigned long ino = SWAB32(de->d_ino);
206 brelse (bh);
207 inode = iget(sb, ino);
208 if (!inode)
209 return ERR_PTR(-EACCES);
210 }
211 d_add(dentry, inode);
212 UFSD(("EXIT\n"))
213 return NULL;
214 }
215
216 /*
217 * ufs_add_entry()
218 *
219 * adds a file entry to the specified directory, using the same
220 * semantics as ufs_find_entry(). It returns NULL if it failed.
221 *
222 * NOTE!! The inode part of 'de' is left at 0 - which means you
223 * may not sleep between calling this and putting something into
224 * the entry, as someone else might have used it while you slept.
225 */
226 static struct buffer_head * ufs_add_entry (struct inode * dir,
227 const char * name, int namelen, struct ufs_dir_entry ** res_dir,
228 int *err )
229 {
230 struct super_block * sb;
231 struct ufs_sb_private_info * uspi;
232 unsigned long offset;
233 unsigned fragoff;
234 unsigned short rec_len;
235 struct buffer_head * bh;
236 struct ufs_dir_entry * de, * de1;
237 unsigned flags, swab;
238
239 UFSD(("ENTER, name %s, namelen %u\n", name, namelen))
240
241 *err = -EINVAL;
242 *res_dir = NULL;
243 if (!dir || !dir->i_nlink)
244 return NULL;
245
246 sb = dir->i_sb;
247 flags = sb->u.ufs_sb.s_flags;
248 swab = sb->u.ufs_sb.s_swab;
249 uspi = sb->u.ufs_sb.s_uspi;
250
251 if (!namelen)
252 return NULL;
253 /*
254 * Is this a busy deleted directory? Can't create new files if so
255 */
256 if (dir->i_size == 0)
257 {
258 *err = -ENOENT;
259 return NULL;
260 }
261 bh = ufs_bread (dir, 0, 0, err);
262 if (!bh)
263 return NULL;
264 rec_len = UFS_DIR_REC_LEN(namelen);
265 offset = 0;
266 de = (struct ufs_dir_entry *) bh->b_data;
267 *err = -ENOSPC;
268 while (1) {
269 if ((char *)de >= UFS_SECTOR_SIZE + bh->b_data) {
270 fragoff = offset & ~uspi->s_fmask;
271 if (fragoff != 0 && fragoff != UFS_SECTOR_SIZE)
272 ufs_error (sb, "ufs_add_entry", "internal error"
273 " fragoff %u", fragoff);
274 if (!fragoff) {
275 brelse (bh);
276 bh = NULL;
277 bh = ufs_bread (dir, offset >> sb->s_blocksize_bits, 1, err);
278 }
279 if (!bh)
280 return NULL;
281 if (dir->i_size <= offset) {
282 if (dir->i_size == 0) {
283 *err = -ENOENT;
284 return NULL;
285 }
286 de = (struct ufs_dir_entry *) (bh->b_data + fragoff);
287 de->d_ino = SWAB32(0);
288 de->d_reclen = SWAB16(UFS_SECTOR_SIZE);
289 ufs_set_de_namlen(de,0);
290 dir->i_size = offset + UFS_SECTOR_SIZE;
291 mark_inode_dirty(dir);
292 } else {
293 de = (struct ufs_dir_entry *) bh->b_data;
294 }
295 }
296 if (!ufs_check_dir_entry ("ufs_add_entry", dir, de, bh, offset)) {
297 *err = -ENOENT;
298 brelse (bh);
299 return NULL;
300 }
301 if (ufs_match (namelen, name, de, flags, swab)) {
302 *err = -EEXIST;
303 brelse (bh);
304 return NULL;
305 }
306 if ((SWAB32(de->d_ino) == 0 && SWAB16(de->d_reclen) >= rec_len) ||
307 (SWAB16(de->d_reclen) >= UFS_DIR_REC_LEN(ufs_get_de_namlen(de)) + rec_len)) {
308 offset += SWAB16(de->d_reclen);
309 if (SWAB32(de->d_ino)) {
310 de1 = (struct ufs_dir_entry *) ((char *) de +
311 UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
312 de1->d_reclen = SWAB16(SWAB16(de->d_reclen) -
313 UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
314 de->d_reclen = SWAB16(UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
315 de = de1;
316 }
317 de->d_ino = SWAB32(0);
318 ufs_set_de_namlen(de, namelen);
319 memcpy (de->d_name, name, namelen + 1);
320 /*
321 * XXX shouldn't update any times until successful
322 * completion of syscall, but too many callers depend
323 * on this.
324 *
325 * XXX similarly, too many callers depend on
326 * ufs_new_inode() setting the times, but error
327 * recovery deletes the inode, so the worst that can
328 * happen is that the times are slightly out of date
329 * and/or different from the directory change time.
330 */
331 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
332 mark_inode_dirty(dir);
333 dir->i_version = ++event;
334 mark_buffer_dirty(bh, 1);
335 *res_dir = de;
336 *err = 0;
337
338 UFSD(("EXIT\n"))
339 return bh;
340 }
341 offset += SWAB16(de->d_reclen);
342 de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
343 }
344 brelse (bh);
345 UFSD(("EXIT (FAILED)\n"))
346 return NULL;
347 }
348
349 /*
350 * ufs_delete_entry deletes a directory entry by merging it with the
351 * previous entry.
352 */
353 static int ufs_delete_entry (struct inode * inode, struct ufs_dir_entry * dir,
354 struct buffer_head * bh )
355
356 {
357 struct super_block * sb;
358 struct ufs_dir_entry * de, * pde;
359 unsigned i;
360 unsigned flags, swab;
361
362 UFSD(("ENTER\n"))
363
364 sb = inode->i_sb;
365 flags = sb->u.ufs_sb.s_flags;
366 swab = sb->u.ufs_sb.s_swab;
367 i = 0;
368 pde = NULL;
369 de = (struct ufs_dir_entry *) bh->b_data;
370
371 UFSD(("ino %u, reclen %u, namlen %u, name %s\n", SWAB32(de->d_ino),
372 SWAB16(de->d_reclen), ufs_get_de_namlen(de), de->d_name))
373
374 while (i < bh->b_size) {
375 if (!ufs_check_dir_entry ("ufs_delete_entry", inode, de, bh, i))
376 return -EIO;
377 if (de == dir) {
378 if (pde)
379 pde->d_reclen =
380 SWAB16(SWAB16(pde->d_reclen) +
381 SWAB16(dir->d_reclen));
382 dir->d_ino = SWAB32(0);
383 UFSD(("EXIT\n"))
384 return 0;
385 }
386 i += SWAB16(de->d_reclen);
387 if (i == UFS_SECTOR_SIZE) pde = NULL;
388 else pde = de;
389 de = (struct ufs_dir_entry *)
390 ((char *) de + SWAB16(de->d_reclen));
391 if (i == UFS_SECTOR_SIZE && SWAB16(de->d_reclen) == 0)
392 break;
393 }
394 UFSD(("EXIT\n"))
395 return -ENOENT;
396 }
397
398 /*
399 * By the time this is called, we already have created
400 * the directory cache entry for the new file, but it
401 * is so far negative - it has no inode.
402 *
403 * If the create succeeds, we fill in the inode information
404 * with d_instantiate().
405 */
406 int ufs_create (struct inode * dir, struct dentry * dentry, int mode)
407 {
408 struct super_block * sb;
409 struct inode * inode;
410 struct buffer_head * bh;
411 struct ufs_dir_entry * de;
412 int err = -EIO;
413 unsigned flags, swab;
414
415 sb = dir->i_sb;
416 swab = sb->u.ufs_sb.s_swab;
417 flags = sb->u.ufs_sb.s_flags;
418 /*
419 * N.B. Several error exits in ufs_new_inode don't set err.
420 */
421 UFSD(("ENTER\n"))
422
423 inode = ufs_new_inode (dir, mode, &err);
424 if (!inode)
425 return err;
426 inode->i_op = &ufs_file_inode_operations;
427 inode->i_mode = mode;
428 mark_inode_dirty(inode);
429 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
430 if (!bh) {
431 inode->i_nlink--;
432 mark_inode_dirty(inode);
433 iput (inode);
434 return err;
435 }
436 de->d_ino = SWAB32(inode->i_ino);
437 ufs_set_de_type (de, inode->i_mode);
438 dir->i_version = ++event;
439 mark_buffer_dirty(bh, 1);
440 if (IS_SYNC(dir)) {
441 ll_rw_block (WRITE, 1, &bh);
442 wait_on_buffer (bh);
443 }
444 brelse (bh);
445 d_instantiate(dentry, inode);
446
447 UFSD(("EXIT\n"))
448
449 return 0;
450 }
451
452 int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
453 {
454 struct super_block * sb;
455 struct inode * inode;
456 struct buffer_head * bh;
457 struct ufs_dir_entry * de;
458 int err = -EIO;
459 unsigned flags, swab;
460
461 sb = dir->i_sb;
462 flags = sb->u.ufs_sb.s_flags;
463 swab = sb->u.ufs_sb.s_swab;
464
465 inode = ufs_new_inode (dir, mode, &err);
466 if (!inode)
467 goto out;
468
469 inode->i_uid = current->fsuid;
470 init_special_inode(inode, mode, rdev);
471 mark_inode_dirty(inode);
472 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
473 if (!bh)
474 goto out_no_entry;
475 de->d_ino = SWAB32(inode->i_ino);
476 ufs_set_de_type (de, inode->i_mode);
477 dir->i_version = ++event;
478 mark_buffer_dirty(bh, 1);
479 if (IS_SYNC(dir)) {
480 ll_rw_block (WRITE, 1, &bh);
481 wait_on_buffer (bh);
482 }
483 d_instantiate(dentry, inode);
484 brelse(bh);
485 err = 0;
486 out:
487 return err;
488
489 out_no_entry:
490 inode->i_nlink--;
491 mark_inode_dirty(inode);
492 iput(inode);
493 goto out;
494 }
495
496 int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
497 {
498 struct super_block * sb;
499 struct inode * inode;
500 struct buffer_head * bh, * dir_block;
501 struct ufs_dir_entry * de;
502 int err;
503 unsigned flags, swab;
504
505 sb = dir->i_sb;
506 flags = sb->u.ufs_sb.s_flags;
507 swab = sb->u.ufs_sb.s_swab;
508
509 err = -EMLINK;
510 if (dir->i_nlink >= UFS_LINK_MAX)
511 goto out;
512 err = -EIO;
513 inode = ufs_new_inode (dir, S_IFDIR, &err);
514 if (!inode)
515 goto out;
516
517 inode->i_op = &ufs_dir_inode_operations;
518 inode->i_size = UFS_SECTOR_SIZE;
519 dir_block = ufs_bread (inode, 0, 1, &err);
520 if (!dir_block) {
521 inode->i_nlink--; /* is this nlink == 0? */
522 mark_inode_dirty(inode);
523 iput (inode);
524 return err;
525 }
526 inode->i_blocks = sb->s_blocksize / UFS_SECTOR_SIZE;
527 de = (struct ufs_dir_entry *) dir_block->b_data;
528 de->d_ino = SWAB32(inode->i_ino);
529 ufs_set_de_type (de, inode->i_mode);
530 ufs_set_de_namlen(de,1);
531 de->d_reclen = SWAB16(UFS_DIR_REC_LEN(1));
532 strcpy (de->d_name, ".");
533 de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
534 de->d_ino = SWAB32(dir->i_ino);
535 ufs_set_de_type (de, dir->i_mode);
536 de->d_reclen = SWAB16(UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
537 ufs_set_de_namlen(de,2);
538 strcpy (de->d_name, "..");
539 inode->i_nlink = 2;
540 mark_buffer_dirty(dir_block, 1);
541 brelse (dir_block);
542 inode->i_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask);
543 if (dir->i_mode & S_ISGID)
544 inode->i_mode |= S_ISGID;
545 mark_inode_dirty(inode);
546 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
547 if (!bh)
548 goto out_no_entry;
549 de->d_ino = SWAB32(inode->i_ino);
550 ufs_set_de_type (de, inode->i_mode);
551 dir->i_version = ++event;
552 mark_buffer_dirty(bh, 1);
553 if (IS_SYNC(dir)) {
554 ll_rw_block (WRITE, 1, &bh);
555 wait_on_buffer (bh);
556 }
557 dir->i_nlink++;
558 mark_inode_dirty(dir);
559 d_instantiate(dentry, inode);
560 brelse (bh);
561 err = 0;
562 out:
563 return err;
564
565 out_no_entry:
566 inode->i_nlink = 0;
567 mark_inode_dirty(inode);
568 iput (inode);
569 goto out;
570 }
571
572 /*
573 * routine to check that the specified directory is empty (for rmdir)
574 */
575 static int ufs_empty_dir (struct inode * inode)
576 {
577 struct super_block * sb;
578 unsigned long offset;
579 struct buffer_head * bh;
580 struct ufs_dir_entry * de, * de1;
581 int err;
582 unsigned swab;
583
584 sb = inode->i_sb;
585 swab = sb->u.ufs_sb.s_swab;
586
587 if (inode->i_size < UFS_DIR_REC_LEN(1) + UFS_DIR_REC_LEN(2) ||
588 !(bh = ufs_bread (inode, 0, 0, &err))) {
589 ufs_warning (inode->i_sb, "empty_dir",
590 "bad directory (dir #%lu) - no data block",
591 inode->i_ino);
592 return 1;
593 }
594 de = (struct ufs_dir_entry *) bh->b_data;
595 de1 = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
596 if (SWAB32(de->d_ino) != inode->i_ino || !SWAB32(de1->d_ino) ||
597 strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) {
598 ufs_warning (inode->i_sb, "empty_dir",
599 "bad directory (dir #%lu) - no `.' or `..'",
600 inode->i_ino);
601 return 1;
602 }
603 offset = SWAB16(de->d_reclen) + SWAB16(de1->d_reclen);
604 de = (struct ufs_dir_entry *) ((char *) de1 + SWAB16(de1->d_reclen));
605 while (offset < inode->i_size ) {
606 if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
607 brelse (bh);
608 bh = ufs_bread (inode, offset >> sb->s_blocksize_bits, 1, &err);
609 if (!bh) {
610 ufs_error (sb, "empty_dir",
611 "directory #%lu contains a hole at offset %lu",
612 inode->i_ino, offset);
613 offset += sb->s_blocksize;
614 continue;
615 }
616 de = (struct ufs_dir_entry *) bh->b_data;
617 }
618 if (!ufs_check_dir_entry ("empty_dir", inode, de, bh, offset)) {
619 brelse (bh);
620 return 1;
621 }
622 if (SWAB32(de->d_ino)) {
623 brelse (bh);
624 return 0;
625 }
626 offset += SWAB16(de->d_reclen);
627 de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
628 }
629 brelse (bh);
630 return 1;
631 }
632
633 int ufs_rmdir (struct inode * dir, struct dentry *dentry)
634 {
635 struct super_block *sb;
636 int retval;
637 struct inode * inode;
638 struct buffer_head * bh;
639 struct ufs_dir_entry * de;
640 unsigned swab;
641
642 sb = dir->i_sb;
643 swab = sb->u.ufs_sb.s_swab;
644
645 UFSD(("ENTER\n"))
646
647 retval = -ENOENT;
648 bh = ufs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
649 if (!bh)
650 goto end_rmdir;
651
652 inode = dentry->d_inode;
653 DQUOT_INIT(inode);
654
655 retval = -EIO;
656 if (SWAB32(de->d_ino) != inode->i_ino)
657 goto end_rmdir;
658
659 retval = -ENOTEMPTY;
660 if (!ufs_empty_dir (inode))
661 goto end_rmdir;
662
663 retval = ufs_delete_entry (dir, de, bh);
664 dir->i_version = ++event;
665 if (retval)
666 goto end_rmdir;
667 mark_buffer_dirty(bh, 1);
668 if (IS_SYNC(dir)) {
669 ll_rw_block (WRITE, 1, &bh);
670 wait_on_buffer (bh);
671 }
672 if (inode->i_nlink != 2)
673 ufs_warning (inode->i_sb, "ufs_rmdir",
674 "empty directory has nlink!=2 (%d)",
675 inode->i_nlink);
676 inode->i_version = ++event;
677 inode->i_nlink = 0;
678 inode->i_size = 0;
679 mark_inode_dirty(inode);
680 dir->i_nlink--;
681 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
682 mark_inode_dirty(dir);
683 d_delete(dentry);
684
685 end_rmdir:
686 brelse (bh);
687 UFSD(("EXIT\n"))
688
689 return retval;
690 }
691
692 int ufs_unlink(struct inode * dir, struct dentry *dentry)
693 {
694 struct super_block * sb;
695 int retval;
696 struct inode * inode;
697 struct buffer_head * bh;
698 struct ufs_dir_entry * de;
699 unsigned flags, swab;
700
701 sb = dir->i_sb;
702 flags = sb->u.ufs_sb.s_flags;
703 swab = sb->u.ufs_sb.s_swab;
704
705 retval = -ENOENT;
706 bh = ufs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
707 UFSD(("de: ino %u, reclen %u, namelen %u, name %s\n", SWAB32(de->d_ino),
708 SWAB16(de->d_reclen), ufs_get_de_namlen(de), de->d_name))
709 if (!bh)
710 goto end_unlink;
711
712 inode = dentry->d_inode;
713 DQUOT_INIT(inode);
714
715 retval = -EIO;
716 if (SWAB32(de->d_ino) != inode->i_ino)
717 goto end_unlink;
718
719 if (!inode->i_nlink) {
720 ufs_warning (inode->i_sb, "ufs_unlink",
721 "Deleting nonexistent file (%lu), %d",
722 inode->i_ino, inode->i_nlink);
723 inode->i_nlink = 1;
724 }
725 retval = ufs_delete_entry (dir, de, bh);
726 if (retval)
727 goto end_unlink;
728 dir->i_version = ++event;
729 mark_buffer_dirty(bh, 1);
730 if (IS_SYNC(dir)) {
731 ll_rw_block (WRITE, 1, &bh);
732 wait_on_buffer (bh);
733 }
734 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
735 mark_inode_dirty(dir);
736 inode->i_nlink--;
737 mark_inode_dirty(inode);
738 inode->i_ctime = dir->i_ctime;
739 retval = 0;
740 d_delete(dentry); /* This also frees the inode */
741
742 end_unlink:
743 brelse (bh);
744 return retval;
745 }
746
747
748 /*
749 * Create symbolic link. We use only slow symlinks at this time.
750 */
751 int ufs_symlink (struct inode * dir, struct dentry * dentry,
752 const char * symname)
753 {
754 struct super_block * sb;
755 struct ufs_dir_entry * de;
756 struct inode * inode;
757 struct buffer_head * bh, * name_block;
758 char * link;
759 unsigned i, l;
760 int err;
761 char c;
762 unsigned swab;
763
764 UFSD(("ENTER\n"))
765
766 sb = dir->i_sb;
767 swab = sb->u.ufs_sb.s_swab;
768 bh = name_block = NULL;
769 err = -EIO;
770
771 if (!(inode = ufs_new_inode (dir, S_IFLNK, &err))) {
772 return err;
773 }
774 inode->i_mode = S_IFLNK | S_IRWXUGO;
775 inode->i_op = &ufs_symlink_inode_operations;
776 for (l = 0; l < sb->s_blocksize - 1 && symname [l]; l++);
777
778 /***if (l >= sizeof (inode->u.ufs_i.i_data)) {***/
779 if (1) {
780 /* slow symlink */
781 name_block = ufs_bread (inode, 0, 1, &err);
782 if (!name_block) {
783 inode->i_nlink--;
784 mark_inode_dirty(inode);
785 iput (inode);
786 return err;
787 }
788 link = name_block->b_data;
789
790 } else {
791 /* fast symlink */
792 link = (char *) inode->u.ufs_i.i_u1.i_data;
793 }
794 i = 0;
795 while (i < sb->s_blocksize - 1 && (c = *(symname++)))
796 link[i++] = c;
797 link[i] = 0;
798 if (name_block) {
799 mark_buffer_dirty(name_block, 1);
800 brelse (name_block);
801 }
802 inode->i_size = i;
803 mark_inode_dirty(inode);
804
805 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
806 if (!bh)
807 goto out_no_entry;
808 de->d_ino = SWAB32(inode->i_ino);
809 dir->i_version = ++event;
810 mark_buffer_dirty(bh, 1);
811 if (IS_SYNC(dir)) {
812 ll_rw_block (WRITE, 1, &bh);
813 wait_on_buffer (bh);
814 }
815 brelse (bh);
816 d_instantiate(dentry, inode);
817 err = 0;
818 out:
819 return err;
820
821 out_no_entry:
822 inode->i_nlink--;
823 mark_inode_dirty(inode);
824 iput (inode);
825 goto out;
826 }
827
828 int ufs_link (struct dentry * old_dentry, struct inode * dir,
829 struct dentry *dentry)
830 {
831 struct super_block * sb;
832 struct inode *inode = old_dentry->d_inode;
833 struct ufs_dir_entry * de;
834 struct buffer_head * bh;
835 int err;
836 unsigned swab;
837
838 inode = old_dentry->d_inode;
839 sb = inode->i_sb;
840 swab = sb->u.ufs_sb.s_swab;
841
842 if (S_ISDIR(inode->i_mode))
843 return -EPERM;
844
845 if (inode->i_nlink >= UFS_LINK_MAX)
846 return -EMLINK;
847
848 bh = ufs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
849 if (!bh)
850 return err;
851
852 de->d_ino = SWAB32(inode->i_ino);
853 dir->i_version = ++event;
854 mark_buffer_dirty(bh, 1);
855 if (IS_SYNC(dir)) {
856 ll_rw_block (WRITE, 1, &bh);
857 wait_on_buffer (bh);
858 }
859 brelse (bh);
860 inode->i_nlink++;
861 inode->i_ctime = CURRENT_TIME;
862 mark_inode_dirty(inode);
863 inode->i_count++;
864 d_instantiate(dentry, inode);
865 return 0;
866 }
867
868
869 #define PARENT_INO(buffer) \
870 ((struct ufs_dir_entry *) ((char *) buffer + \
871 SWAB16(((struct ufs_dir_entry *) buffer)->d_reclen)))->d_ino
872 /*
873 * Anybody can rename anything with this: the permission checks are left to the
874 * higher-level routines.
875 */
876 int ufs_rename (struct inode * old_dir, struct dentry * old_dentry,
877 struct inode * new_dir, struct dentry * new_dentry )
878 {
879 struct super_block * sb;
880 struct inode * old_inode, * new_inode;
881 struct buffer_head * old_bh, * new_bh, * dir_bh;
882 struct ufs_dir_entry * old_de, * new_de;
883 int retval;
884 unsigned flags, swab;
885
886 sb = old_dir->i_sb;
887 flags = sb->u.ufs_sb.s_flags;
888 swab = sb->u.ufs_sb.s_swab;
889
890 UFSD(("ENTER\n"))
891
892 old_inode = new_inode = NULL;
893 old_bh = new_bh = dir_bh = NULL;
894 new_de = NULL;
895
896 old_bh = ufs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de);
897 /*
898 * Check for inode number is _not_ due to possible IO errors.
899 * We might rmdir the source, keep it as pwd of some process
900 * and merrily kill the link to whatever was created under the
901 * same name. Goodbye sticky bit ;-<
902 */
903 retval = -ENOENT;
904 old_inode = old_dentry->d_inode;
905 if (!old_bh || SWAB32(old_de->d_ino) != old_inode->i_ino)
906 goto end_rename;
907
908 new_inode = new_dentry->d_inode;
909 new_bh = ufs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_de);
910 if (new_bh) {
911 if (!new_inode) {
912 brelse (new_bh);
913 new_bh = NULL;
914 } else {
915 DQUOT_INIT(new_inode);
916 }
917 }
918 if (S_ISDIR(old_inode->i_mode)) {
919 if (new_inode) {
920 retval = -ENOTEMPTY;
921 if (!ufs_empty_dir (new_inode))
922 goto end_rename;
923 }
924
925 retval = -EIO;
926 dir_bh = ufs_bread (old_inode, 0, 0, &retval);
927 if (!dir_bh)
928 goto end_rename;
929 if (SWAB32(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
930 goto end_rename;
931 retval = -EMLINK;
932 if (!new_inode && new_dir->i_nlink >= UFS_LINK_MAX)
933 goto end_rename;
934 }
935
936 if (!new_bh)
937 new_bh = ufs_add_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_de,
938 &retval);
939 if (!new_bh)
940 goto end_rename;
941 new_dir->i_version = ++event;
942
943 /*
944 * ok, that's it
945 */
946 new_de->d_ino = SWAB32(old_inode->i_ino);
947 ufs_delete_entry (old_dir, old_de, old_bh);
948
949 old_dir->i_version = ++event;
950 if (new_inode) {
951 new_inode->i_nlink--;
952 new_inode->i_ctime = CURRENT_TIME;
953 mark_inode_dirty(new_inode);
954 }
955 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
956 mark_inode_dirty(old_dir);
957 if (dir_bh) {
958 PARENT_INO(dir_bh->b_data) = SWAB32(new_dir->i_ino);
959 mark_buffer_dirty(dir_bh, 1);
960 old_dir->i_nlink--;
961 mark_inode_dirty(old_dir);
962 if (new_inode) {
963 new_inode->i_nlink--;
964 mark_inode_dirty(new_inode);
965 } else {
966 new_dir->i_nlink++;
967 mark_inode_dirty(new_dir);
968 }
969 }
970 mark_buffer_dirty(old_bh, 1);
971 if (IS_SYNC(old_dir)) {
972 ll_rw_block (WRITE, 1, &old_bh);
973 wait_on_buffer (old_bh);
974 }
975
976 mark_buffer_dirty(new_bh, 1);
977 if (IS_SYNC(new_dir)) {
978 ll_rw_block (WRITE, 1, &new_bh);
979 wait_on_buffer (new_bh);
980 }
981
982 retval = 0;
983 end_rename:
984 brelse (dir_bh);
985 brelse (old_bh);
986 brelse (new_bh);
987
988 UFSD(("EXIT\n"))
989
990 return retval;
991 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux