5 * Daniel Pirkl <daniel.pirkl@email.cz>
6 * Charles University, Faculty of Mathematics and Physics
10 * linux/fs/ext2/namei.c
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)
19 * linux/fs/minix/namei.c
21 * Copyright (C) 1991, 1992 Linus Torvalds
23 * Big-endian to little-endian byte-swapping/bitmaps by
24 * David S. Miller (davem@caip.rutgers.edu), 1995
27 #include <asm/uaccess.h>
29 #include <linux/errno.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>
42 #undef UFS_NAMEI_DEBUG
44 #ifdef UFS_NAMEI_DEBUG
45 #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
51 * define how far ahead to read directories while searching them.
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))
59 * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
61 * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
63 static inline int ufs_match (int len
, const char * const name
,
64 struct ufs_dir_entry
* de
, unsigned flags
, unsigned swab
)
66 if (len
!= ufs_get_de_namlen(de
))
70 return !memcmp(name
, de
->d_name
, len
);
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.
81 static struct buffer_head
* ufs_find_entry (struct inode
* dir
,
82 const char * const name
, int namelen
, struct ufs_dir_entry
** res_dir
)
84 struct super_block
* sb
;
85 struct buffer_head
* bh_use
[NAMEI_RA_SIZE
];
86 struct buffer_head
* bh_read
[NAMEI_RA_SIZE
];
88 int block
, toread
, i
, err
;
91 UFSD(("ENTER, dir_ino %lu, name %s, namlen %u\n", dir
->i_ino
, name
, namelen
))
96 flags
= sb
->u
.ufs_sb
.s_flags
;
97 swab
= sb
->u
.ufs_sb
.s_swab
;
99 if (namelen
> UFS_MAXNAMLEN
)
102 memset (bh_use
, 0, sizeof (bh_use
));
104 for (block
= 0; block
< NAMEI_RA_SIZE
; ++block
) {
105 struct buffer_head
* bh
;
107 if ((block
<< sb
->s_blocksize_bits
) >= dir
->i_size
)
109 bh
= ufs_getfrag (dir
, block
, 0, &err
);
111 if (bh
&& !buffer_uptodate(bh
))
112 bh_read
[toread
++] = bh
;
115 for (block
= 0, offset
= 0; offset
< dir
->i_size
; block
++) {
116 struct buffer_head
* bh
;
117 struct ufs_dir_entry
* de
;
120 if ((block
% NAMEI_RA_BLOCKS
) == 0 && toread
) {
121 ll_rw_block (READ
, toread
, bh_read
);
124 bh
= bh_use
[block
% NAMEI_RA_SIZE
];
126 ufs_error (sb
, "ufs_find_entry",
127 "directory #%lu contains a hole at offset %lu",
129 offset
+= sb
->s_blocksize
;
133 if (!buffer_uptodate(bh
)) {
135 * read error: all bets are off
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 */
147 if ((char *) de
+ namelen
<= dlimit
&&
148 ufs_match (namelen
, name
, de
, flags
, swab
)) {
150 just to be sure, do a full check */
151 if (!ufs_check_dir_entry("ufs_find_entry",
152 dir
, de
, bh
, offset
))
154 for (i
= 0; i
< NAMEI_RA_SIZE
; ++i
) {
161 /* prevent looping on a bad block */
162 de_len
= SWAB16(de
->d_reclen
);
166 de
= (struct ufs_dir_entry
*) ((char *) de
+ de_len
);
170 if (((block
+ NAMEI_RA_SIZE
) << sb
->s_blocksize_bits
) >=
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
;
181 for (i
= 0; i
< NAMEI_RA_SIZE
; ++i
) brelse (bh_use
[i
]);
186 struct dentry
*ufs_lookup(struct inode
* dir
, struct dentry
*dentry
)
188 struct super_block
* sb
;
189 struct inode
* inode
;
190 struct ufs_dir_entry
* de
;
191 struct buffer_head
* bh
;
197 swab
= sb
->u
.ufs_sb
.s_swab
;
199 if (dentry
->d_name
.len
> UFS_MAXNAMLEN
)
200 return ERR_PTR(-ENAMETOOLONG
);
202 bh
= ufs_find_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
);
205 unsigned long ino
= SWAB32(de
->d_ino
);
207 inode
= iget(sb
, ino
);
209 return ERR_PTR(-EACCES
);
211 d_add(dentry
, inode
);
219 * adds a file entry to the specified directory, using the same
220 * semantics as ufs_find_entry(). It returns NULL if it failed.
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.
226 static struct buffer_head
* ufs_add_entry (struct inode
* dir
,
227 const char * name
, int namelen
, struct ufs_dir_entry
** res_dir
,
230 struct super_block
* sb
;
231 struct ufs_sb_private_info
* uspi
;
232 unsigned long offset
;
234 unsigned short rec_len
;
235 struct buffer_head
* bh
;
236 struct ufs_dir_entry
* de
, * de1
;
237 unsigned flags
, swab
;
239 UFSD(("ENTER, name %s, namelen %u\n", name
, namelen
))
243 if (!dir
|| !dir
->i_nlink
)
247 flags
= sb
->u
.ufs_sb
.s_flags
;
248 swab
= sb
->u
.ufs_sb
.s_swab
;
249 uspi
= sb
->u
.ufs_sb
.s_uspi
;
254 * Is this a busy deleted directory? Can't create new files if so
256 if (dir
->i_size
== 0)
261 bh
= ufs_bread (dir
, 0, 0, err
);
264 rec_len
= UFS_DIR_REC_LEN(namelen
);
266 de
= (struct ufs_dir_entry
*) bh
->b_data
;
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
);
277 bh
= ufs_bread (dir
, offset
>> sb
->s_blocksize_bits
, 1, err
);
281 if (dir
->i_size
<= offset
) {
282 if (dir
->i_size
== 0) {
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
);
293 de
= (struct ufs_dir_entry
*) bh
->b_data
;
296 if (!ufs_check_dir_entry ("ufs_add_entry", dir
, de
, bh
, offset
)) {
301 if (ufs_match (namelen
, name
, de
, flags
, swab
)) {
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
)));
317 de
->d_ino
= SWAB32(0);
318 ufs_set_de_namlen(de
, namelen
);
319 memcpy (de
->d_name
, name
, namelen
+ 1);
321 * XXX shouldn't update any times until successful
322 * completion of syscall, but too many callers depend
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.
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);
341 offset
+= SWAB16(de
->d_reclen
);
342 de
= (struct ufs_dir_entry
*) ((char *) de
+ SWAB16(de
->d_reclen
));
345 UFSD(("EXIT (FAILED)\n"))
350 * ufs_delete_entry deletes a directory entry by merging it with the
353 static int ufs_delete_entry (struct inode
* inode
, struct ufs_dir_entry
* dir
,
354 struct buffer_head
* bh
)
357 struct super_block
* sb
;
358 struct ufs_dir_entry
* de
, * pde
;
360 unsigned flags
, swab
;
365 flags
= sb
->u
.ufs_sb
.s_flags
;
366 swab
= sb
->u
.ufs_sb
.s_swab
;
369 de
= (struct ufs_dir_entry
*) bh
->b_data
;
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
))
374 while (i
< bh
->b_size
) {
375 if (!ufs_check_dir_entry ("ufs_delete_entry", inode
, de
, bh
, i
))
380 SWAB16(SWAB16(pde
->d_reclen
) +
381 SWAB16(dir
->d_reclen
));
382 dir
->d_ino
= SWAB32(0);
386 i
+= SWAB16(de
->d_reclen
);
387 if (i
== UFS_SECTOR_SIZE
) pde
= NULL
;
389 de
= (struct ufs_dir_entry
*)
390 ((char *) de
+ SWAB16(de
->d_reclen
));
391 if (i
== UFS_SECTOR_SIZE
&& SWAB16(de
->d_reclen
) == 0)
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.
403 * If the create succeeds, we fill in the inode information
404 * with d_instantiate().
406 int ufs_create (struct inode
* dir
, struct dentry
* dentry
, int mode
)
408 struct super_block
* sb
;
409 struct inode
* inode
;
410 struct buffer_head
* bh
;
411 struct ufs_dir_entry
* de
;
413 unsigned flags
, swab
;
416 swab
= sb
->u
.ufs_sb
.s_swab
;
417 flags
= sb
->u
.ufs_sb
.s_flags
;
419 * N.B. Several error exits in ufs_new_inode don't set err.
423 inode
= ufs_new_inode (dir
, mode
, &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
);
432 mark_inode_dirty(inode
);
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);
441 ll_rw_block (WRITE
, 1, &bh
);
445 d_instantiate(dentry
, inode
);
452 int ufs_mknod (struct inode
* dir
, struct dentry
*dentry
, int mode
, int rdev
)
454 struct super_block
* sb
;
455 struct inode
* inode
;
456 struct buffer_head
* bh
;
457 struct ufs_dir_entry
* de
;
459 unsigned flags
, swab
;
462 flags
= sb
->u
.ufs_sb
.s_flags
;
463 swab
= sb
->u
.ufs_sb
.s_swab
;
465 inode
= ufs_new_inode (dir
, mode
, &err
);
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
);
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);
480 ll_rw_block (WRITE
, 1, &bh
);
483 d_instantiate(dentry
, inode
);
491 mark_inode_dirty(inode
);
496 int ufs_mkdir(struct inode
* dir
, struct dentry
* dentry
, int mode
)
498 struct super_block
* sb
;
499 struct inode
* inode
;
500 struct buffer_head
* bh
, * dir_block
;
501 struct ufs_dir_entry
* de
;
503 unsigned flags
, swab
;
506 flags
= sb
->u
.ufs_sb
.s_flags
;
507 swab
= sb
->u
.ufs_sb
.s_swab
;
510 if (dir
->i_nlink
>= UFS_LINK_MAX
)
513 inode
= ufs_new_inode (dir
, S_IFDIR
, &err
);
517 inode
->i_op
= &ufs_dir_inode_operations
;
518 inode
->i_size
= UFS_SECTOR_SIZE
;
519 dir_block
= ufs_bread (inode
, 0, 1, &err
);
521 inode
->i_nlink
--; /* is this nlink == 0? */
522 mark_inode_dirty(inode
);
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
, "..");
540 mark_buffer_dirty(dir_block
, 1);
542 inode
->i_mode
= S_IFDIR
| mode
;
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
);
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);
554 ll_rw_block (WRITE
, 1, &bh
);
558 mark_inode_dirty(dir
);
559 d_instantiate(dentry
, inode
);
567 mark_inode_dirty(inode
);
573 * routine to check that the specified directory is empty (for rmdir)
575 static int ufs_empty_dir (struct inode
* inode
)
577 struct super_block
* sb
;
578 unsigned long offset
;
579 struct buffer_head
* bh
;
580 struct ufs_dir_entry
* de
, * de1
;
585 swab
= sb
->u
.ufs_sb
.s_swab
;
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",
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 `..'",
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
)) {
608 bh
= ufs_bread (inode
, offset
>> sb
->s_blocksize_bits
, 1, &err
);
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
;
616 de
= (struct ufs_dir_entry
*) bh
->b_data
;
618 if (!ufs_check_dir_entry ("empty_dir", inode
, de
, bh
, offset
)) {
622 if (SWAB32(de
->d_ino
)) {
626 offset
+= SWAB16(de
->d_reclen
);
627 de
= (struct ufs_dir_entry
*) ((char *) de
+ SWAB16(de
->d_reclen
));
633 int ufs_rmdir (struct inode
* dir
, struct dentry
*dentry
)
635 struct super_block
*sb
;
637 struct inode
* inode
;
638 struct buffer_head
* bh
;
639 struct ufs_dir_entry
* de
;
643 swab
= sb
->u
.ufs_sb
.s_swab
;
648 bh
= ufs_find_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
);
652 inode
= dentry
->d_inode
;
656 if (SWAB32(de
->d_ino
) != inode
->i_ino
)
660 if (!ufs_empty_dir (inode
))
663 retval
= ufs_delete_entry (dir
, de
, bh
);
664 dir
->i_version
= ++event
;
667 mark_buffer_dirty(bh
, 1);
669 ll_rw_block (WRITE
, 1, &bh
);
672 if (inode
->i_nlink
!= 2)
673 ufs_warning (inode
->i_sb
, "ufs_rmdir",
674 "empty directory has nlink!=2 (%d)",
676 inode
->i_version
= ++event
;
679 mark_inode_dirty(inode
);
681 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
682 mark_inode_dirty(dir
);
692 int ufs_unlink(struct inode
* dir
, struct dentry
*dentry
)
694 struct super_block
* sb
;
696 struct inode
* inode
;
697 struct buffer_head
* bh
;
698 struct ufs_dir_entry
* de
;
699 unsigned flags
, swab
;
702 flags
= sb
->u
.ufs_sb
.s_flags
;
703 swab
= sb
->u
.ufs_sb
.s_swab
;
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
))
712 inode
= dentry
->d_inode
;
716 if (SWAB32(de
->d_ino
) != inode
->i_ino
)
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
);
725 retval
= ufs_delete_entry (dir
, de
, bh
);
728 dir
->i_version
= ++event
;
729 mark_buffer_dirty(bh
, 1);
731 ll_rw_block (WRITE
, 1, &bh
);
734 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
735 mark_inode_dirty(dir
);
737 mark_inode_dirty(inode
);
738 inode
->i_ctime
= dir
->i_ctime
;
740 d_delete(dentry
); /* This also frees the inode */
749 * Create symbolic link. We use only slow symlinks at this time.
751 int ufs_symlink (struct inode
* dir
, struct dentry
* dentry
,
752 const char * symname
)
754 struct super_block
* sb
= dir
->i_sb
;
755 struct ufs_dir_entry
* de
;
756 struct inode
* inode
;
757 struct buffer_head
* bh
= NULL
;
760 unsigned swab
= sb
->u
.ufs_sb
.s_swab
;
766 l
= strlen(symname
)+1;
767 if (l
> sb
->s_blocksize
)
772 if (!(inode
= ufs_new_inode (dir
, S_IFLNK
, &err
))) {
775 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
777 if (l
> sb
->u
.ufs_sb
.s_uspi
->s_maxsymlinklen
) {
779 inode
->i_op
= &ufs_symlink_inode_operations
;
780 err
= block_symlink(inode
, symname
, l
);
785 inode
->i_op
= &ufs_fast_symlink_inode_operations
;
786 memcpy((char*)&inode
->u
.ufs_i
.i_u1
.i_data
,symname
,l
);
789 mark_inode_dirty(inode
);
791 bh
= ufs_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
, &err
);
794 de
->d_ino
= SWAB32(inode
->i_ino
);
795 dir
->i_version
= ++event
;
796 mark_buffer_dirty(bh
, 1);
798 ll_rw_block (WRITE
, 1, &bh
);
802 d_instantiate(dentry
, inode
);
809 mark_inode_dirty(inode
);
814 int ufs_link (struct dentry
* old_dentry
, struct inode
* dir
,
815 struct dentry
*dentry
)
817 struct inode
*inode
= old_dentry
->d_inode
;
818 struct super_block
* sb
= inode
->i_sb
;
819 struct ufs_dir_entry
* de
;
820 struct buffer_head
* bh
;
822 unsigned swab
= sb
->u
.ufs_sb
.s_swab
;
824 if (S_ISDIR(inode
->i_mode
))
827 if (inode
->i_nlink
>= UFS_LINK_MAX
)
830 bh
= ufs_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
, &err
);
834 de
->d_ino
= SWAB32(inode
->i_ino
);
835 dir
->i_version
= ++event
;
836 mark_buffer_dirty(bh
, 1);
838 ll_rw_block (WRITE
, 1, &bh
);
843 inode
->i_ctime
= CURRENT_TIME
;
844 mark_inode_dirty(inode
);
846 d_instantiate(dentry
, inode
);
851 #define PARENT_INO(buffer) \
852 ((struct ufs_dir_entry *) ((char *) buffer + \
853 SWAB16(((struct ufs_dir_entry *) buffer)->d_reclen)))->d_ino
855 * Anybody can rename anything with this: the permission checks are left to the
856 * higher-level routines.
858 int ufs_rename (struct inode
* old_dir
, struct dentry
* old_dentry
,
859 struct inode
* new_dir
, struct dentry
* new_dentry
)
861 struct super_block
* sb
;
862 struct inode
* old_inode
, * new_inode
;
863 struct buffer_head
* old_bh
, * new_bh
, * dir_bh
;
864 struct ufs_dir_entry
* old_de
, * new_de
;
866 unsigned flags
, swab
;
869 flags
= sb
->u
.ufs_sb
.s_flags
;
870 swab
= sb
->u
.ufs_sb
.s_swab
;
874 old_inode
= new_inode
= NULL
;
875 old_bh
= new_bh
= dir_bh
= NULL
;
878 old_bh
= ufs_find_entry (old_dir
, old_dentry
->d_name
.name
, old_dentry
->d_name
.len
, &old_de
);
880 * Check for inode number is _not_ due to possible IO errors.
881 * We might rmdir the source, keep it as pwd of some process
882 * and merrily kill the link to whatever was created under the
883 * same name. Goodbye sticky bit ;-<
886 old_inode
= old_dentry
->d_inode
;
887 if (!old_bh
|| SWAB32(old_de
->d_ino
) != old_inode
->i_ino
)
890 new_inode
= new_dentry
->d_inode
;
891 new_bh
= ufs_find_entry (new_dir
, new_dentry
->d_name
.name
, new_dentry
->d_name
.len
, &new_de
);
897 DQUOT_INIT(new_inode
);
900 if (S_ISDIR(old_inode
->i_mode
)) {
903 if (!ufs_empty_dir (new_inode
))
908 dir_bh
= ufs_bread (old_inode
, 0, 0, &retval
);
911 if (SWAB32(PARENT_INO(dir_bh
->b_data
)) != old_dir
->i_ino
)
914 if (!new_inode
&& new_dir
->i_nlink
>= UFS_LINK_MAX
)
919 new_bh
= ufs_add_entry (new_dir
, new_dentry
->d_name
.name
, new_dentry
->d_name
.len
, &new_de
,
923 new_dir
->i_version
= ++event
;
928 new_de
->d_ino
= SWAB32(old_inode
->i_ino
);
929 ufs_delete_entry (old_dir
, old_de
, old_bh
);
931 old_dir
->i_version
= ++event
;
933 new_inode
->i_nlink
--;
934 new_inode
->i_ctime
= CURRENT_TIME
;
935 mark_inode_dirty(new_inode
);
937 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
938 mark_inode_dirty(old_dir
);
940 PARENT_INO(dir_bh
->b_data
) = SWAB32(new_dir
->i_ino
);
941 mark_buffer_dirty(dir_bh
, 1);
943 mark_inode_dirty(old_dir
);
945 new_inode
->i_nlink
--;
946 mark_inode_dirty(new_inode
);
949 mark_inode_dirty(new_dir
);
952 mark_buffer_dirty(old_bh
, 1);
953 if (IS_SYNC(old_dir
)) {
954 ll_rw_block (WRITE
, 1, &old_bh
);
955 wait_on_buffer (old_bh
);
958 mark_buffer_dirty(new_bh
, 1);
959 if (IS_SYNC(new_dir
)) {
960 ll_rw_block (WRITE
, 1, &new_bh
);
961 wait_on_buffer (new_bh
);