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