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 static 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
))
245 flags
= sb
->u
.ufs_sb
.s_flags
;
246 swab
= sb
->u
.ufs_sb
.s_swab
;
247 uspi
= sb
->u
.ufs_sb
.s_uspi
;
251 bh
= ufs_bread (dir
, 0, 0, err
);
254 rec_len
= UFS_DIR_REC_LEN(namelen
);
256 de
= (struct ufs_dir_entry
*) bh
->b_data
;
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
);
267 bh
= ufs_bread (dir
, offset
>> sb
->s_blocksize_bits
, 1, err
);
271 if (dir
->i_size
<= offset
) {
272 if (dir
->i_size
== 0) {
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
);
283 de
= (struct ufs_dir_entry
*) bh
->b_data
;
286 if (!ufs_check_dir_entry ("ufs_add_entry", dir
, de
, bh
, offset
)) {
291 if (ufs_match (namelen
, name
, de
, flags
, swab
)) {
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
)));
307 de
->d_ino
= SWAB32(0);
308 ufs_set_de_namlen(de
, namelen
);
309 memcpy (de
->d_name
, name
, namelen
+ 1);
311 * XXX shouldn't update any times until successful
312 * completion of syscall, but too many callers depend
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.
321 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
322 mark_inode_dirty(dir
);
323 dir
->i_version
= ++event
;
324 mark_buffer_dirty(bh
);
331 offset
+= SWAB16(de
->d_reclen
);
332 de
= (struct ufs_dir_entry
*) ((char *) de
+ SWAB16(de
->d_reclen
));
335 UFSD(("EXIT (FAILED)\n"))
340 * ufs_delete_entry deletes a directory entry by merging it with the
343 static int ufs_delete_entry (struct inode
* inode
, struct ufs_dir_entry
* dir
,
344 struct buffer_head
* bh
)
347 struct super_block
* sb
;
348 struct ufs_dir_entry
* de
, * pde
;
350 unsigned flags
, swab
;
355 flags
= sb
->u
.ufs_sb
.s_flags
;
356 swab
= sb
->u
.ufs_sb
.s_swab
;
359 de
= (struct ufs_dir_entry
*) bh
->b_data
;
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
))
364 while (i
< bh
->b_size
) {
365 if (!ufs_check_dir_entry ("ufs_delete_entry", inode
, de
, bh
, i
))
370 SWAB16(SWAB16(pde
->d_reclen
) +
371 SWAB16(dir
->d_reclen
));
372 dir
->d_ino
= SWAB32(0);
376 i
+= SWAB16(de
->d_reclen
);
377 if (i
== UFS_SECTOR_SIZE
) pde
= NULL
;
379 de
= (struct ufs_dir_entry
*)
380 ((char *) de
+ SWAB16(de
->d_reclen
));
381 if (i
== UFS_SECTOR_SIZE
&& SWAB16(de
->d_reclen
) == 0)
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.
393 * If the create succeeds, we fill in the inode information
394 * with d_instantiate().
396 static int ufs_create (struct inode
* dir
, struct dentry
* dentry
, int mode
)
398 struct super_block
* sb
;
399 struct inode
* inode
;
400 struct buffer_head
* bh
;
401 struct ufs_dir_entry
* de
;
403 unsigned flags
, swab
;
406 swab
= sb
->u
.ufs_sb
.s_swab
;
407 flags
= sb
->u
.ufs_sb
.s_flags
;
409 * N.B. Several error exits in ufs_new_inode don't set err.
413 inode
= ufs_new_inode (dir
, mode
, &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
);
424 mark_inode_dirty(inode
);
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
);
433 ll_rw_block (WRITE
, 1, &bh
);
437 d_instantiate(dentry
, inode
);
444 static int ufs_mknod (struct inode
* dir
, struct dentry
*dentry
, int mode
, int rdev
)
446 struct super_block
* sb
;
447 struct inode
* inode
;
448 struct buffer_head
* bh
;
449 struct ufs_dir_entry
* de
;
451 unsigned flags
, swab
;
454 flags
= sb
->u
.ufs_sb
.s_flags
;
455 swab
= sb
->u
.ufs_sb
.s_swab
;
457 inode
= ufs_new_inode (dir
, mode
, &err
);
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
);
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
);
472 ll_rw_block (WRITE
, 1, &bh
);
475 d_instantiate(dentry
, inode
);
483 mark_inode_dirty(inode
);
488 static int ufs_mkdir(struct inode
* dir
, struct dentry
* dentry
, int mode
)
490 struct super_block
* sb
;
491 struct inode
* inode
;
492 struct buffer_head
* bh
, * dir_block
;
493 struct ufs_dir_entry
* de
;
495 unsigned flags
, swab
;
498 flags
= sb
->u
.ufs_sb
.s_flags
;
499 swab
= sb
->u
.ufs_sb
.s_swab
;
502 if (dir
->i_nlink
>= UFS_LINK_MAX
)
505 inode
= ufs_new_inode (dir
, S_IFDIR
, &err
);
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
);
514 inode
->i_nlink
--; /* is this nlink == 0? */
515 mark_inode_dirty(inode
);
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
, "..");
533 mark_buffer_dirty(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
);
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
);
547 ll_rw_block (WRITE
, 1, &bh
);
551 mark_inode_dirty(dir
);
552 d_instantiate(dentry
, inode
);
560 mark_inode_dirty(inode
);
566 * routine to check that the specified directory is empty (for rmdir)
568 static int ufs_empty_dir (struct inode
* inode
)
570 struct super_block
* sb
;
571 unsigned long offset
;
572 struct buffer_head
* bh
;
573 struct ufs_dir_entry
* de
, * de1
;
578 swab
= sb
->u
.ufs_sb
.s_swab
;
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",
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 `..'",
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
)) {
601 bh
= ufs_bread (inode
, offset
>> sb
->s_blocksize_bits
, 1, &err
);
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
;
609 de
= (struct ufs_dir_entry
*) bh
->b_data
;
611 if (!ufs_check_dir_entry ("empty_dir", inode
, de
, bh
, offset
)) {
615 if (SWAB32(de
->d_ino
)) {
619 offset
+= SWAB16(de
->d_reclen
);
620 de
= (struct ufs_dir_entry
*) ((char *) de
+ SWAB16(de
->d_reclen
));
626 static int ufs_rmdir (struct inode
* dir
, struct dentry
*dentry
)
628 struct super_block
*sb
;
630 struct inode
* inode
;
631 struct buffer_head
* bh
;
632 struct ufs_dir_entry
* de
;
636 swab
= sb
->u
.ufs_sb
.s_swab
;
641 bh
= ufs_find_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
);
645 inode
= dentry
->d_inode
;
649 if (SWAB32(de
->d_ino
) != inode
->i_ino
)
653 if (!ufs_empty_dir (inode
))
656 retval
= ufs_delete_entry (dir
, de
, bh
);
657 dir
->i_version
= ++event
;
660 mark_buffer_dirty(bh
);
662 ll_rw_block (WRITE
, 1, &bh
);
665 if (inode
->i_nlink
!= 2)
666 ufs_warning (inode
->i_sb
, "ufs_rmdir",
667 "empty directory has nlink!=2 (%d)",
669 inode
->i_version
= ++event
;
672 mark_inode_dirty(inode
);
674 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
675 mark_inode_dirty(dir
);
684 static int ufs_unlink(struct inode
* dir
, struct dentry
*dentry
)
686 struct super_block
* sb
;
688 struct inode
* inode
;
689 struct buffer_head
* bh
;
690 struct ufs_dir_entry
* de
;
691 unsigned flags
, swab
;
694 flags
= sb
->u
.ufs_sb
.s_flags
;
695 swab
= sb
->u
.ufs_sb
.s_swab
;
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
))
704 inode
= dentry
->d_inode
;
708 if (SWAB32(de
->d_ino
) != inode
->i_ino
)
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
);
717 retval
= ufs_delete_entry (dir
, de
, bh
);
720 dir
->i_version
= ++event
;
721 mark_buffer_dirty(bh
);
723 ll_rw_block (WRITE
, 1, &bh
);
726 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
727 mark_inode_dirty(dir
);
729 mark_inode_dirty(inode
);
730 inode
->i_ctime
= dir
->i_ctime
;
740 * Create symbolic link. We use only slow symlinks at this time.
742 static int ufs_symlink (struct inode
* dir
, struct dentry
* dentry
,
743 const char * symname
)
745 struct super_block
* sb
= dir
->i_sb
;
746 struct ufs_dir_entry
* de
;
747 struct inode
* inode
;
748 struct buffer_head
* bh
= NULL
;
751 unsigned swab
= sb
->u
.ufs_sb
.s_swab
;
757 l
= strlen(symname
)+1;
758 if (l
> sb
->s_blocksize
)
763 if (!(inode
= ufs_new_inode (dir
, S_IFLNK
, &err
))) {
766 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
768 if (l
> sb
->u
.ufs_sb
.s_uspi
->s_maxsymlinklen
) {
770 inode
->i_op
= &page_symlink_inode_operations
;
771 inode
->i_mapping
->a_ops
= &ufs_aops
;
772 err
= block_symlink(inode
, symname
, l
);
777 inode
->i_op
= &ufs_fast_symlink_inode_operations
;
778 memcpy((char*)&inode
->u
.ufs_i
.i_u1
.i_data
,symname
,l
);
781 mark_inode_dirty(inode
);
783 bh
= ufs_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
, &err
);
786 de
->d_ino
= SWAB32(inode
->i_ino
);
787 dir
->i_version
= ++event
;
788 mark_buffer_dirty(bh
);
790 ll_rw_block (WRITE
, 1, &bh
);
794 d_instantiate(dentry
, inode
);
801 mark_inode_dirty(inode
);
806 static int ufs_link (struct dentry
* old_dentry
, struct inode
* dir
,
807 struct dentry
*dentry
)
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
;
814 unsigned swab
= sb
->u
.ufs_sb
.s_swab
;
816 if (S_ISDIR(inode
->i_mode
))
819 if (inode
->i_nlink
>= UFS_LINK_MAX
)
822 bh
= ufs_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
, &err
);
826 de
->d_ino
= SWAB32(inode
->i_ino
);
827 dir
->i_version
= ++event
;
828 mark_buffer_dirty(bh
);
830 ll_rw_block (WRITE
, 1, &bh
);
835 inode
->i_ctime
= CURRENT_TIME
;
836 mark_inode_dirty(inode
);
837 atomic_inc(&inode
->i_count
);
838 d_instantiate(dentry
, inode
);
843 #define PARENT_INO(buffer) \
844 ((struct ufs_dir_entry *) ((char *) buffer + \
845 SWAB16(((struct ufs_dir_entry *) buffer)->d_reclen)))->d_ino
847 * Anybody can rename anything with this: the permission checks are left to the
848 * higher-level routines.
850 static int ufs_rename (struct inode
* old_dir
, struct dentry
* old_dentry
,
851 struct inode
* new_dir
, struct dentry
* new_dentry
)
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
;
858 unsigned flags
, swab
;
861 flags
= sb
->u
.ufs_sb
.s_flags
;
862 swab
= sb
->u
.ufs_sb
.s_swab
;
866 old_inode
= new_inode
= NULL
;
867 old_bh
= new_bh
= dir_bh
= NULL
;
870 old_bh
= ufs_find_entry (old_dir
, old_dentry
->d_name
.name
, old_dentry
->d_name
.len
, &old_de
);
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 ;-<
878 old_inode
= old_dentry
->d_inode
;
879 if (!old_bh
|| SWAB32(old_de
->d_ino
) != old_inode
->i_ino
)
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
);
889 DQUOT_INIT(new_inode
);
892 if (S_ISDIR(old_inode
->i_mode
)) {
895 if (!ufs_empty_dir (new_inode
))
900 dir_bh
= ufs_bread (old_inode
, 0, 0, &retval
);
903 if (SWAB32(PARENT_INO(dir_bh
->b_data
)) != old_dir
->i_ino
)
906 if (!new_inode
&& new_dir
->i_nlink
>= UFS_LINK_MAX
)
911 new_bh
= ufs_add_entry (new_dir
, new_dentry
->d_name
.name
, new_dentry
->d_name
.len
, &new_de
,
915 new_dir
->i_version
= ++event
;
920 new_de
->d_ino
= SWAB32(old_inode
->i_ino
);
921 ufs_delete_entry (old_dir
, old_de
, old_bh
);
923 old_dir
->i_version
= ++event
;
925 new_inode
->i_nlink
--;
926 new_inode
->i_ctime
= CURRENT_TIME
;
927 mark_inode_dirty(new_inode
);
929 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
930 mark_inode_dirty(old_dir
);
932 PARENT_INO(dir_bh
->b_data
) = SWAB32(new_dir
->i_ino
);
933 mark_buffer_dirty(dir_bh
);
935 mark_inode_dirty(old_dir
);
937 new_inode
->i_nlink
--;
938 mark_inode_dirty(new_inode
);
941 mark_inode_dirty(new_dir
);
944 mark_buffer_dirty(old_bh
);
945 if (IS_SYNC(old_dir
)) {
946 ll_rw_block (WRITE
, 1, &old_bh
);
947 wait_on_buffer (old_bh
);
950 mark_buffer_dirty(new_bh
);
951 if (IS_SYNC(new_dir
)) {
952 ll_rw_block (WRITE
, 1, &new_bh
);
953 wait_on_buffer (new_bh
);
967 struct inode_operations ufs_dir_inode_operations
= {
972 symlink
: ufs_symlink
,