2 * linux/fs/ext2/namei.c
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
11 * linux/fs/minix/namei.c
13 * Copyright (C) 1991, 1992 Linus Torvalds
15 * Big-endian to little-endian byte-swapping/bitmaps by
16 * David S. Miller (davem@caip.rutgers.edu), 1995
17 * Directory entry file type support and forward compatibility hooks
18 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
20 * Changes for use in OBDFS
21 * Copyright (c) 1999, Seagate Technology Inc.
25 #include <asm/uaccess.h>
27 #include <linux/errno.h>
29 #include <linux/ext2_fs.h>
30 #include <linux/fcntl.h>
31 #include <linux/sched.h>
32 #include <linux/stat.h>
33 #include <linux/string.h>
34 #include <linux/locks.h>
35 #include <linux/quotaops.h>
36 #include <linux/iobuf.h>
38 #include <linux/obd_support.h>
42 * define how far ahead to read directories while searching them.
44 #define NAMEI_RA_CHUNKS 2
45 #define NAMEI_RA_BLOCKS 4
46 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
47 #define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))
50 * NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
52 * `len <= EXT2_NAME_LEN' is guaranteed by caller.
53 * `de != NULL' is guaranteed by caller.
55 static inline int ext2_match (int len, const char * const name,
56 struct ext2_dir_entry_2 * de)
58 if (len != de->name_len)
62 return !memcmp(name, de->name, len);
68 * finds an entry in the specified directory with the wanted name. It
69 * returns the cache buffer in which the entry was found, and the entry
70 * itself (as a parameter - res_dir). It does NOT read the inode of the
71 * entry - you'll have to do that yourself if you want to.
73 struct page * obdfs_find_entry (struct inode * dir,
74 const char * const name, int namelen,
75 struct ext2_dir_entry_2 ** res_dir)
77 struct super_block * sb;
84 if (namelen > EXT2_NAME_LEN)
87 for (page = 0, offset = 0; offset < dir->i_size; page++) {
88 struct ext2_dir_entry_2 * de;
91 page = obdfs_getpage(dir, offset, 0, NOLOCK);
95 de = (struct ext2_dir_entry_2 *) page_address(page);
96 dlimit = (char *)page_address(page) + PAGE_SIZE;
97 while ((char *) de < dlimit) {
98 /* this code is executed quadratically often */
99 /* do minimal checking `by hand' */
102 if ((char *) de + namelen <= dlimit &&
103 ext2_match (namelen, name, de)) {
105 just to be sure, do a full check */
107 if (!ext2_check_dir_entry("ext2_find_entry",
108 dir, de, bh, offset))
114 /* prevent looping on a bad block */
115 de_len = le16_to_cpu(de->rec_len);
119 de = (struct ext2_dir_entry_2 *)
120 ((char *) de + de_len);
122 page_cache_release(page);
126 page_cache_release(page);
130 struct dentry *obdfs_lookup(struct inode * dir, struct dentry *dentry)
132 struct inode * inode;
133 struct ext2_dir_entry_2 * de;
136 if (dentry->d_name.len > EXT2_NAME_LEN)
137 return ERR_PTR(-ENAMETOOLONG);
139 page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
142 unsigned long ino = le32_to_cpu(de->inode);
143 page_cache_release(page);
144 inode = iget(dir->i_sb, ino);
147 return ERR_PTR(-EACCES);
149 d_add(dentry, inode);
157 * adds a file entry to the specified directory, using the same
158 * semantics as ext2_find_entry(). It returns NULL if it failed.
160 * NOTE!! The inode part of 'de' is left at 0 - which means you
161 * may not sleep between calling this and putting something into
162 * the entry, as someone else might have used it while you slept.
164 * returns a locked page
166 static struct page *obdfs_add_entry (struct inode * dir,
167 const char * name, int namelen,
168 struct ext2_dir_entry_2 ** res_dir,
171 unsigned long offset;
172 unsigned short rec_len;
174 struct ext2_dir_entry_2 * de, * de1;
175 struct super_block * sb;
179 if (!dir || !dir->i_nlink)
186 * Is this a busy deleted directory? Can't create new files if so
188 if (dir->i_size == 0)
193 page = obdfs_getpage(dir, 0, 0, LOCKED);
196 rec_len = EXT2_DIR_REC_LEN(namelen);
198 de = (struct ext2_dir_entry_2 *) page_address(page);
201 if ((char *)de >= PAGE_SIZE + (char *)page_address(page)) {
203 page_cache_release(page);
204 page = obdfs_getpage(dir, offset, 1, LOCKED);
207 if (dir->i_size <= offset) {
208 if (dir->i_size == 0) {
213 ext2_debug ("creating next block\n");
215 de = (struct ext2_dir_entry_2 *) page_address(page);
217 de->rec_len = le16_to_cpu(sb->s_blocksize);
218 dir->i_size = offset + PAGE_SIZE;
219 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
220 mark_inode_dirty(dir);
223 ext2_debug ("skipping to next block\n");
225 de = (struct ext2_dir_entry_2 *) page_address(page);
229 if (!ext2_check_dir_entry ("ext2_add_entry", dir, de, bh,
236 if (ext2_match (namelen, name, de)) {
239 page_cache_release(page);
242 if ((le32_to_cpu(de->inode) == 0 && le16_to_cpu(de->rec_len) >= rec_len) ||
243 (le16_to_cpu(de->rec_len) >= EXT2_DIR_REC_LEN(de->name_len) + rec_len)) {
244 offset += le16_to_cpu(de->rec_len);
245 if (le32_to_cpu(de->inode)) {
246 de1 = (struct ext2_dir_entry_2 *) ((char *) de +
247 EXT2_DIR_REC_LEN(de->name_len));
248 de1->rec_len = cpu_to_le16(le16_to_cpu(de->rec_len) -
249 EXT2_DIR_REC_LEN(de->name_len));
250 de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
254 de->name_len = namelen;
256 memcpy (de->name, name, namelen);
258 * XXX shouldn't update any times until successful
259 * completion of syscall, but too many callers depend
262 * XXX similarly, too many callers depend on
263 * ext2_new_inode() setting the times, but error
264 * recovery deletes the inode, so the worst that can
265 * happen is that the times are slightly out of date
266 * and/or different from the directory change time.
268 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
269 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
270 mark_inode_dirty(dir);
271 dir->i_version = ++event;
274 PDEBUG(page, "addentry");
277 offset += le16_to_cpu(de->rec_len);
278 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
282 page_cache_release(page);
283 PDEBUG(page, "addentry");
289 * ext2_delete_entry deletes a directory entry by merging it with the
292 static int obdfs_delete_entry (struct ext2_dir_entry_2 * dir,
295 struct ext2_dir_entry_2 * de, * pde;
300 de = (struct ext2_dir_entry_2 *) page_address(page);
301 while (i < PAGE_SIZE) {
303 if (!ext2_check_dir_entry ("ext2_delete_entry", NULL,
310 cpu_to_le16(le16_to_cpu(pde->rec_len) +
311 le16_to_cpu(dir->rec_len));
316 i += le16_to_cpu(de->rec_len);
318 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
324 static inline void ext2_set_de_type(struct super_block *sb,
325 struct ext2_dir_entry_2 *de,
327 if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_FILETYPE))
330 de->file_type = EXT2_FT_CHRDEV;
331 else if (S_ISBLK(mode))
332 de->file_type = EXT2_FT_BLKDEV;
333 else if (S_ISFIFO(mode))
334 de->file_type = EXT2_FT_FIFO;
335 else if (S_ISLNK(mode))
336 de->file_type = EXT2_FT_SYMLINK;
337 else if (S_ISREG(mode))
338 de->file_type = EXT2_FT_REG_FILE;
339 else if (S_ISDIR(mode))
340 de->file_type = EXT2_FT_DIR;
344 * By the time this is called, we already have created
345 * the directory cache entry for the new file, but it
346 * is so far negative - it has no inode.
348 * If the create succeeds, we fill in the inode information
349 * with d_instantiate().
351 int obdfs_create (struct inode * dir, struct dentry * dentry, int mode)
353 struct inode * inode;
355 struct ext2_dir_entry_2 * de;
357 struct obdfs_sb_info *sbi;
362 sbi = dir->i_sb->u.generic_sbp;
364 * N.B. Several error exits in ext2_new_inode don't set err.
366 ino = sbi->osi_ops->o_create(sbi->osi_obd, 0, &err);
369 inode = iget(dir->i_sb, ino);
373 inode->i_op = &obdfs_inode_ops;
374 inode->i_mode = mode;
375 mark_inode_dirty(inode);
376 page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
379 mark_inode_dirty(inode);
383 de->inode = cpu_to_le32(inode->i_ino);
384 ext2_set_de_type(dir->i_sb, de, S_IFREG);
385 dir->i_version = ++event;
386 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
387 dir->i_ino, page, 0);
391 ll_rw_block (WRITE, 1, &bh);
395 page_cache_release(page);
396 d_instantiate(dentry, inode);
400 int obdfs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
402 struct inode * inode;
404 struct ext2_dir_entry_2 * de;
406 struct obdfs_sb_info *sbi;
412 sbi = dir->i_sb->u.generic_sbp;
414 * N.B. Several error exits in ext2_new_inode don't set err.
416 ino = sbi->osi_ops->o_create(sbi->osi_obd, 0, &err);
419 inode = iget(dir->i_sb, ino);
423 inode->i_uid = current->fsuid;
424 init_special_inode(inode, mode, rdev);
425 page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
428 de->inode = cpu_to_le32(inode->i_ino);
429 dir->i_version = ++event;
430 ext2_set_de_type(dir->i_sb, de, inode->i_mode);
431 mark_inode_dirty(inode);
432 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
433 dir->i_ino, page, 0);
438 ll_rw_block (WRITE, 1, &bh);
442 d_instantiate(dentry, inode);
443 page_cache_release(page);
450 mark_inode_dirty(inode);
455 int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
457 struct inode * child;
458 struct page *page, *child_page;
459 struct ext2_dir_entry_2 * de;
460 struct obdfs_sb_info *sbi;
465 sbi = dir->i_sb->u.generic_sbp;
468 if (dir->i_nlink >= EXT2_LINK_MAX)
472 ino = iops(dir)->o_create(sbi->osi_obd, 0, &err);
475 child = iget(dir->i_sb, ino);
480 child->i_op = &obdfs_inode_ops;
481 child->i_size = PAGE_SIZE;
483 child_page = obdfs_getpage(child, 0, 1, LOCKED);
485 child->i_nlink--; /* is this nlink == 0? */
486 mark_inode_dirty(child);
490 child->i_blocks = PAGE_SIZE/child->i_sb->s_blocksize;
492 /* create . and .. */
493 de = (struct ext2_dir_entry_2 *) page_address(child_page);
494 de->inode = cpu_to_le32(child->i_ino);
496 de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
497 strcpy (de->name, ".");
498 ext2_set_de_type(dir->i_sb, de, S_IFDIR);
500 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
501 de->inode = cpu_to_le32(dir->i_ino);
502 de->rec_len = cpu_to_le16(child->i_sb->s_blocksize - EXT2_DIR_REC_LEN(1));
504 strcpy (de->name, "..");
505 ext2_set_de_type(dir->i_sb, de, S_IFDIR);
507 iops(dir)->o_brw(WRITE, sbi->osi_conn_info.conn_id, child->i_ino, child_page, 1);
508 UnlockPage(child_page);
509 page_cache_release(child_page);
512 child->i_mode = S_IFDIR | mode;
513 if (dir->i_mode & S_ISGID)
514 child->i_mode |= S_ISGID;
515 mark_inode_dirty(child);
517 /* now deal with the parent */
518 page = obdfs_add_entry(dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
523 de->inode = cpu_to_le32(child->i_ino);
524 ext2_set_de_type(dir->i_sb, de, S_IFDIR);
525 dir->i_version = ++event;
529 ll_rw_block (WRITE, 1, &bh);
534 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
535 mark_inode_dirty(dir);
536 iops(dir)->o_brw(WRITE, sbi->osi_conn_info.conn_id, dir->i_ino, page, 1);
538 page_cache_release(page);
539 d_instantiate(dentry, child);
547 mark_inode_dirty(child);
554 * routine to check that the specified directory is empty (for rmdir)
556 static int empty_dir (struct inode * inode)
558 unsigned long offset;
560 struct ext2_dir_entry_2 * de, * de1;
561 struct super_block * sb;
564 if (inode->i_size < EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) ||
565 !(page = obdfs_getpage (inode, 0, 0, NOLOCK))) {
566 ext2_warning (inode->i_sb, "empty_dir",
567 "bad directory (dir #%lu) - no data block",
571 de = (struct ext2_dir_entry_2 *) page_address(page);
572 de1 = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
573 if (le32_to_cpu(de->inode) != inode->i_ino || !le32_to_cpu(de1->inode) ||
574 strcmp (".", de->name) || strcmp ("..", de1->name)) {
575 ext2_warning (inode->i_sb, "empty_dir",
576 "bad directory (dir #%lu) - no `.' or `..'",
578 page_cache_release(page);
581 offset = le16_to_cpu(de->rec_len) + le16_to_cpu(de1->rec_len);
582 de = (struct ext2_dir_entry_2 *) ((char *) de1 + le16_to_cpu(de1->rec_len));
583 while (offset < inode->i_size ) {
584 if (!page || (void *) de >= (void *) (page_address(page) + PAGE_SIZE)) {
586 page_cache_release(page);
587 page = obdfs_getpage(inode, offset, 0, NOLOCK);
590 ext2_error (sb, "empty_dir",
591 "directory #%lu contains a hole at offset %lu",
592 inode->i_ino, offset);
594 offset += sb->s_blocksize;
597 de = (struct ext2_dir_entry_2 *) page_address(page);
600 if (!ext2_check_dir_entry ("empty_dir", inode, de, bh,
606 if (le32_to_cpu(de->inode)) {
607 page_cache_release(page);
610 offset += le16_to_cpu(de->rec_len);
611 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
613 page_cache_release(page);
617 int obdfs_rmdir (struct inode * dir, struct dentry *dentry)
620 struct inode * inode;
622 struct ext2_dir_entry_2 * de;
623 struct obdfs_sb_info *sbi;
626 sbi = dir->i_sb->u.generic_sbp;
629 page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
633 inode = dentry->d_inode;
637 if (le32_to_cpu(de->inode) != inode->i_ino)
641 if (!empty_dir (inode))
644 retval = obdfs_delete_entry (de, page);
645 dir->i_version = ++event;
648 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
649 dir->i_ino, page, 0);
653 ll_rw_block (WRITE, 1, &bh);
657 if (inode->i_nlink != 2)
658 ext2_warning (inode->i_sb, "ext2_rmdir",
659 "empty directory has nlink!=2 (%d)",
661 inode->i_version = ++event;
664 mark_inode_dirty(inode);
666 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
667 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
668 mark_inode_dirty(dir);
673 page_cache_release(page);
677 int obdfs_unlink(struct inode * dir, struct dentry *dentry)
680 struct inode * inode;
682 struct ext2_dir_entry_2 * de;
683 struct obdfs_sb_info *sbi;
686 sbi = dir->i_sb->u.generic_sbp;
689 page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
693 inode = dentry->d_inode;
697 if (le32_to_cpu(de->inode) != inode->i_ino)
700 if (!inode->i_nlink) {
701 ext2_warning (inode->i_sb, "ext2_unlink",
702 "Deleting nonexistent file (%lu), %d",
703 inode->i_ino, inode->i_nlink);
706 retval = obdfs_delete_entry (de, page);
709 dir->i_version = ++event;
710 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
711 dir->i_ino, page, 0);
715 ll_rw_block (WRITE, 1, &bh);
719 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
720 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
721 mark_inode_dirty(dir);
723 mark_inode_dirty(inode);
724 inode->i_ctime = dir->i_ctime;
726 d_delete(dentry); /* This also frees the inode */
730 page_cache_release(page);
734 int obdfs_symlink (struct inode * dir, struct dentry *dentry, const char * symname)
736 struct ext2_dir_entry_2 * de;
737 struct inode * inode;
738 struct page* page = NULL, * name_page = NULL;
740 int i, l, err = -EIO;
742 struct obdfs_sb_info *sbi;
747 sbi = dir->i_sb->u.generic_sbp;
749 * N.B. Several error exits in ext2_new_inode don't set err.
751 ino = sbi->osi_ops->o_create(sbi->osi_obd, 0, &err);
754 inode = iget(dir->i_sb, ino);
758 inode->i_mode = S_IFLNK | S_IRWXUGO;
759 inode->i_op = &obdfs_inode_ops;
760 for (l = 0; l < inode->i_sb->s_blocksize - 1 &&
763 if (l >= sizeof (inode->u.ext2_i.i_data)) {
765 ext2_debug ("l=%d, normal symlink\n", l);
767 name_page = obdfs_getpage(inode, 0, 1, LOCKED);
770 mark_inode_dirty(inode);
774 link = (char *)page_address(name_page);
776 link = (char *) inode->u.ext2_i.i_data;
778 ext2_debug ("l=%d, fast symlink\n", l);
782 while (i < inode->i_sb->s_blocksize - 1 && (c = *(symname++)))
786 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
787 inode->i_ino, name_page, 1);
788 PDEBUG(name_page, "symlink");
789 UnlockPage(name_page);
790 page_cache_release(name_page);
793 mark_inode_dirty(inode);
795 page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
798 de->inode = cpu_to_le32(inode->i_ino);
799 ext2_set_de_type(dir->i_sb, de, S_IFLNK);
800 dir->i_version = ++event;
801 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
802 dir->i_ino, page, 1);
806 ll_rw_block (WRITE, 1, &bh);
810 d_instantiate(dentry, inode);
817 mark_inode_dirty(inode);
822 int obdfs_link (struct dentry * old_dentry,
823 struct inode * dir, struct dentry *dentry)
825 struct inode *inode = old_dentry->d_inode;
826 struct ext2_dir_entry_2 * de;
829 struct obdfs_sb_info *sbi;
832 sbi = dir->i_sb->u.generic_sbp;
834 if (S_ISDIR(inode->i_mode))
837 if (inode->i_nlink >= EXT2_LINK_MAX)
840 page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
844 de->inode = cpu_to_le32(inode->i_ino);
845 ext2_set_de_type(dir->i_sb, de, inode->i_mode);
846 dir->i_version = ++event;
847 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
848 dir->i_ino, page, 0);
853 ll_rw_block (WRITE, 1, &bh);
857 page_cache_release(page);
859 inode->i_ctime = CURRENT_TIME;
860 mark_inode_dirty(inode);
862 d_instantiate(dentry, inode);
866 #define PARENT_INO(buffer) \
867 ((struct ext2_dir_entry_2 *) ((char *) buffer + \
868 le16_to_cpu(((struct ext2_dir_entry_2 *) buffer)->rec_len)))->inode
871 * Anybody can rename anything with this: the permission checks are left to the
872 * higher-level routines.
874 int obdfs_rename (struct inode * old_dir, struct dentry *old_dentry,
875 struct inode * new_dir,struct dentry *new_dentry)
877 struct inode * old_inode, * new_inode;
878 struct page * old_page, * new_page, * dir_page;
879 struct ext2_dir_entry_2 * old_de, * new_de;
881 struct obdfs_sb_info *sbi;
884 sbi = old_dir->i_sb->u.generic_sbp;
886 new_page = dir_page = NULL;
888 old_page = obdfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de);
890 * Check for inode number is _not_ due to possible IO errors.
891 * We might rmdir the source, keep it as pwd of some process
892 * and merrily kill the link to whatever was created under the
893 * same name. Goodbye sticky bit ;-<
895 old_inode = old_dentry->d_inode;
897 if (!old_page || le32_to_cpu(old_de->inode) != old_inode->i_ino)
900 new_inode = new_dentry->d_inode;
901 new_page = obdfs_find_entry (new_dir, new_dentry->d_name.name,
902 new_dentry->d_name.len, &new_de);
905 page_cache_release(new_page);
908 DQUOT_INIT(new_inode);
911 if (S_ISDIR(old_inode->i_mode)) {
914 if (!empty_dir (new_inode))
918 dir_page= obdfs_getpage (old_inode, 0, 0, LOCKED);
921 if (le32_to_cpu(PARENT_INO(page_address(dir_page))) != old_dir->i_ino)
924 if (!new_inode && new_dir!=old_dir &&
925 new_dir->i_nlink >= EXT2_LINK_MAX)
929 new_page = obdfs_add_entry (new_dir, new_dentry->d_name.name,
930 new_dentry->d_name.len, &new_de,
935 new_dir->i_version = ++event;
940 new_de->inode = le32_to_cpu(old_inode->i_ino);
941 if (EXT2_HAS_INCOMPAT_FEATURE(new_dir->i_sb,
942 EXT2_FEATURE_INCOMPAT_FILETYPE))
943 new_de->file_type = old_de->file_type;
945 obdfs_delete_entry (old_de, old_page);
947 old_dir->i_version = ++event;
949 new_inode->i_nlink--;
950 new_inode->i_ctime = CURRENT_TIME;
951 mark_inode_dirty(new_inode);
953 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
954 old_dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
955 mark_inode_dirty(old_dir);
957 PARENT_INO(page_address(dir_page)) = le32_to_cpu(new_dir->i_ino);
958 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
959 new_dir->i_ino, dir_page, 0);
961 mark_inode_dirty(old_dir);
963 new_inode->i_nlink--;
964 mark_inode_dirty(new_inode);
967 new_dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
968 mark_inode_dirty(new_dir);
971 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
972 old_inode->i_ino, old_page, 0);
974 if (IS_SYNC(old_dir)) {
975 ll_rw_block (WRITE, 1, &old_bh);
976 wait_on_buffer (old_bh);
979 sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
980 new_inode->i_ino, new_page, 0);
982 if (IS_SYNC(new_dir)) {
983 ll_rw_block (WRITE, 1, &new_bh);
984 wait_on_buffer (new_bh);
992 page_cache_release(old_page);
994 page_cache_release(new_page);
996 page_cache_release(dir_page);