Lines Matching defs:dir
300 static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
301 static unsigned dx_node_limit(struct inode *dir);
303 struct inode *dir,
307 static int dx_make_map(struct inode *dir, struct buffer_head *bh,
316 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
320 static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
324 struct inode *dir, struct inode *inode);
498 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
527 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
605 static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
607 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
610 if (ext4_has_metadata_csum(dir->i_sb))
615 static inline unsigned dx_node_limit(struct inode *dir)
617 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
619 if (ext4_has_metadata_csum(dir->i_sb))
647 static struct stats dx_show_leaf(struct inode *dir,
672 if (IS_ENCRYPTED(dir))
673 res = fscrypt_get_encryption_info(dir);
678 if (!fscrypt_has_encryption_key(dir)) {
680 ext4fs_dirhash(dir, de->name,
698 res = fscrypt_fname_disk_to_usr(dir,
712 ext4fs_dirhash(dir, de->name,
723 ext4fs_dirhash(dir, de->name, de->name_len, &h);
737 struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
740 unsigned blocksize = dir->i_sb->s_blocksize;
752 bh = ext4_bread(NULL,dir, block, 0);
756 dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
757 dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
782 dx_probe(struct ext4_filename *fname, struct inode *dir,
795 frame->bh = ext4_read_dirblock(dir, 0, INDEX);
803 ext4_warning_inode(dir, "Unrecognised inode hash code %u",
811 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
812 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
814 ext4fs_dirhash(dir, fname_name(fname), fname_len(fname), hinfo);
818 ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
824 if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
825 ext4_warning(dir->i_sb,
827 "supported value", dir->i_ino,
828 ext4_dir_htree_level(dir->i_sb));
829 if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
830 ext4_warning(dir->i_sb, "Enable large directory "
839 if (dx_get_limit(entries) != dx_root_limit(dir,
841 ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
843 dx_root_limit(dir, root->info.info_length));
853 ext4_warning_inode(dir,
895 ext4_warning_inode(dir,
905 frame->bh = ext4_read_dirblock(dir, block, INDEX);
914 if (dx_get_limit(entries) != dx_node_limit(dir)) {
915 ext4_warning_inode(dir,
917 dx_get_limit(entries), dx_node_limit(dir));
928 ext4_warning_inode(dir,
970 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
1016 bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
1034 struct inode *dir, ext4_lblk_t block,
1045 bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1051 dir->i_sb->s_blocksize -
1054 if (IS_ENCRYPTED(dir)) {
1055 err = fscrypt_get_encryption_info(dir);
1068 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
1069 if (ext4_check_dir_entry(dir, NULL, de, bh,
1071 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
1076 ext4fs_dirhash(dir, de->name, de->name_len, hinfo);
1083 if (!IS_ENCRYPTED(dir)) {
1095 err = fscrypt_fname_disk_to_usr(dir, hinfo->hash,
1134 struct inode *dir;
1143 dir = file_inode(dir_file);
1144 if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1145 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1148 EXT4_SB(dir->i_sb)->s_hash_unsigned;
1149 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1150 if (ext4_has_inline_data(dir)) {
1152 count = ext4_inlinedir_to_tree(dir_file, dir, 0,
1161 count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1168 frame = dx_probe(NULL, dir, &hinfo, frames);
1185 de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1202 ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1210 ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1236 struct inode *dir,
1241 return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
1253 static int dx_make_map(struct inode *dir, struct buffer_head *bh,
1262 int blocksize = EXT4_BLOCK_SIZE(dir->i_sb);
1264 if (ext4_has_metadata_csum(dir->i_sb))
1268 if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen,
1272 ext4fs_dirhash(dir, de->name, de->name_len, &h);
1364 void ext4_fname_setup_ci_filename(struct inode *dir, const struct qstr *iname,
1369 if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding) {
1378 len = utf8_casefold(dir->i_sb->s_encoding,
1433 struct inode *dir, struct ext4_filename *fname,
1446 ext4_match(dir, fname, de)) {
1449 if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf,
1457 dir->i_sb->s_blocksize);
1466 static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1469 struct super_block *sb = dir->i_sb;
1471 if (!is_dx(dir))
1493 static struct buffer_head *__ext4_find_entry(struct inode *dir,
1511 sb = dir->i_sb;
1516 if (ext4_has_inline_data(dir)) {
1518 ret = ext4_find_inline_entry(dir, fname, res_dir,
1536 if (is_dx(dir)) {
1537 ret = ext4_dx_find_entry(dir, fname, res_dir);
1549 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1554 start = EXT4_I(dir)->i_dir_start_lookup;
1572 retval = ext4_bread_batch(dir, block, ra_max,
1584 EXT4_ERROR_INODE_ERR(dir, EIO,
1592 !is_dx_internal_node(dir, block,
1594 !ext4_dirblock_csum_verify(dir, bh)) {
1595 EXT4_ERROR_INODE_ERR(dir, EFSBADCRC,
1603 i = search_dirblock(bh, dir, fname,
1606 EXT4_I(dir)->i_dir_start_lookup = block;
1624 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1637 static struct buffer_head *ext4_find_entry(struct inode *dir,
1646 err = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1652 bh = __ext4_find_entry(dir, &fname, res_dir, inlined);
1658 static struct buffer_head *ext4_lookup_entry(struct inode *dir,
1666 err = ext4_fname_prepare_lookup(dir, dentry, &fname);
1672 bh = __ext4_find_entry(dir, &fname, res_dir, NULL);
1678 static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
1682 struct super_block * sb = dir->i_sb;
1691 frame = dx_probe(fname, dir, NULL, frames);
1696 bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1700 retval = search_dirblock(bh, dir, fname,
1712 retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1715 ext4_warning_inode(dir,
1731 static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1740 bh = ext4_lookup_entry(dir, dentry, &de);
1747 if (!ext4_valid_inum(dir->i_sb, ino)) {
1748 EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1751 if (unlikely(ino == dir->i_ino)) {
1752 EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
1756 inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL);
1758 EXT4_ERROR_INODE(dir,
1763 if (!IS_ERR(inode) && IS_ENCRYPTED(dir) &&
1765 !fscrypt_has_permitted_context(dir, inode)) {
1768 dir->i_ino, inode->i_ino);
1775 if (!inode && IS_CASEFOLDED(dir)) {
1844 * Compact each dir entry in the range to the minimal rec_len.
1869 * Split a full leaf block to make room for a new dir entry.
1873 static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1877 unsigned blocksize = dir->i_sb->s_blocksize;
1890 if (ext4_has_metadata_csum(dir->i_sb))
1893 bh2 = ext4_append(handle, dir, &newblock);
1914 count = dx_make_map(dir, *bh, hinfo, map);
1964 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
1966 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
1975 err = ext4_handle_dirty_dirblock(handle, dir, bh2);
1978 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
1989 ext4_std_error(dir->i_sb, err);
1993 int ext4_find_dest_de(struct inode *dir, struct inode *inode,
2008 if (ext4_check_dir_entry(dir, NULL, de, bh,
2011 if (ext4_match(dir, fname, de))
2060 struct inode *dir,
2064 unsigned int blocksize = dir->i_sb->s_blocksize;
2072 err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
2080 ext4_std_error(dir->i_sb, err);
2098 dir->i_mtime = dir->i_ctime = current_time(dir);
2099 ext4_update_dx_flag(dir);
2100 inode_inc_iversion(dir);
2101 err2 = ext4_mark_inode_dirty(handle, dir);
2103 err = ext4_handle_dirty_dirblock(handle, dir, bh);
2105 ext4_std_error(dir->i_sb, err);
2109 static bool ext4_check_dx_root(struct inode *dir, struct dx_root *root)
2114 unsigned int blocksize = dir->i_sb->s_blocksize;
2115 char *blockend = (char *)root + dir->i_sb->s_blocksize;
2150 EXT4_ERROR_INODE(dir, "Corrupt dir, %s, running e2fsck is recommended",
2160 struct inode *dir,
2179 blocksize = dir->i_sb->s_blocksize;
2180 dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2184 ext4_std_error(dir->i_sb, retval);
2190 if (!ext4_check_dx_root(dir, root)) {
2202 bh2 = ext4_append(handle, dir, &block);
2207 ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2215 if (ext4_check_dir_entry(dir, NULL, de, bh2, data2, len,
2236 root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
2240 dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2245 fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2246 fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2247 ext4fs_dirhash(dir, fname_name(fname), fname_len(fname), &fname->hinfo);
2255 retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2258 retval = ext4_handle_dirty_dirblock(handle, dir, bh2);
2262 de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2268 retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2276 ext4_mark_inode_dirty(handle, dir);
2295 struct inode *dir = d_inode(dentry->d_parent);
2309 sb = dir->i_sb;
2318 if (sb_has_strict_encoding(sb) && IS_CASEFOLDED(dir) &&
2323 retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2327 if (ext4_has_inline_data(dir)) {
2328 retval = ext4_try_add_inline_entry(handle, &fname, dir, inode);
2337 if (is_dx(dir)) {
2338 retval = ext4_dx_add_entry(handle, &fname, dir, inode);
2343 EXT4_ERROR_INODE(dir,
2348 ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2350 retval = ext4_mark_inode_dirty(handle, dir);
2354 blocks = dir->i_size >> sb->s_blocksize_bits;
2356 bh = ext4_read_dirblock(dir, block, DIRENT);
2358 bh = ext4_bread(handle, dir, block,
2367 retval = add_dirent_to_buf(handle, &fname, dir, inode,
2374 retval = make_indexed_dir(handle, &fname, dir,
2381 bh = ext4_append(handle, dir, &block);
2395 retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2408 struct inode *dir, struct inode *inode)
2413 struct super_block *sb = dir->i_sb;
2420 frame = dx_probe(fname, dir, NULL, frames);
2425 bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE);
2437 err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2469 dir->i_ino, levels);
2479 bh2 = ext4_append(handle, dir, &newblock);
2509 dx_set_limit(entries2, dx_node_limit(dir));
2521 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2525 err = ext4_handle_dirty_dx_node(handle, dir,
2529 err = ext4_handle_dirty_dx_node(handle, dir,
2537 dx_set_limit(entries2, dx_node_limit(dir));
2547 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2550 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2556 de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2561 err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2565 ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */
2581 int ext4_generic_delete_entry(struct inode *dir,
2589 unsigned int blocksize = dir->i_sb->s_blocksize;
2596 if (ext4_check_dir_entry(dir, NULL, de, bh,
2621 inode_inc_iversion(dir);
2632 struct inode *dir,
2638 if (ext4_has_inline_data(dir)) {
2640 err = ext4_delete_inline_entry(handle, dir, de_del, bh,
2646 if (ext4_has_metadata_csum(dir->i_sb))
2654 err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data,
2655 dir->i_sb->s_blocksize, csum_size);
2660 err = ext4_handle_dirty_dirblock(handle, dir, bh);
2667 ext4_std_error(dir->i_sb, err);
2710 struct inode *dir = d_inode(dentry->d_parent);
2715 if (IS_DIRSYNC(dir))
2735 static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
2742 err = dquot_initialize(dir);
2746 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2749 inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
2765 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2770 static int ext4_mknod(struct inode *dir, struct dentry *dentry,
2777 err = dquot_initialize(dir);
2781 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2784 inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
2799 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2804 static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
2810 err = dquot_initialize(dir);
2815 inode = ext4_new_inode_start_handle(dir, mode,
2818 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
2835 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2872 int ext4_init_new_dir(handle_t *handle, struct inode *dir,
2878 unsigned int blocksize = dir->i_sb->s_blocksize;
2882 if (ext4_has_metadata_csum(dir->i_sb))
2886 err = ext4_try_create_inline_dir(handle, dir, inode);
2898 ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
2913 static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
2919 if (EXT4_DIR_LINK_MAX(dir))
2922 err = dquot_initialize(dir);
2926 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2929 inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
2939 err = ext4_init_new_dir(handle, dir, inode);
2957 ext4_inc_count(dir);
2959 ext4_update_dx_flag(dir);
2960 err = ext4_mark_inode_dirty(handle, dir);
2965 if (IS_DIRSYNC(dir))
2972 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3230 static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
3238 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3243 retval = dquot_initialize(dir);
3251 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3267 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3268 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3275 if (IS_DIRSYNC(dir))
3278 retval = ext4_delete_entry(handle, dir, de, bh);
3293 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
3297 ext4_dec_count(dir);
3298 ext4_update_dx_flag(dir);
3300 retval = ext4_mark_inode_dirty(handle, dir);
3309 if (IS_CASEFOLDED(dir))
3320 int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
3334 bh = ext4_find_entry(dir, d_name, &de, NULL);
3353 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3354 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3360 if (IS_DIRSYNC(dir))
3364 retval = ext4_delete_entry(handle, dir, de, bh);
3367 dir->i_ctime = dir->i_mtime = current_time(dir);
3368 ext4_update_dx_flag(dir);
3369 retval = ext4_mark_inode_dirty(handle, dir);
3393 static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3397 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3400 trace_ext4_unlink_enter(dir, dentry);
3405 retval = dquot_initialize(dir);
3412 retval = __ext4_unlink(dir, &dentry->d_name, d_inode(dentry), dentry);
3420 if (IS_CASEFOLDED(dir))
3429 static int ext4_symlink(struct inode *dir,
3438 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3441 err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
3446 err = dquot_initialize(dir);
3457 credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
3466 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3470 inode = ext4_new_inode_start_handle(dir, S_IFLNK|S_IRWXUGO,
3513 * Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS
3516 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3517 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3559 int __ext4_link(struct inode *dir, struct inode *inode, struct dentry *dentry)
3564 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3565 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3570 if (IS_DIRSYNC(dir))
3592 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3598 struct inode *dir, struct dentry *dentry)
3606 err = fscrypt_prepare_link(old_dentry, dir, dentry);
3610 if ((ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT)) &&
3611 (!projid_eq(EXT4_I(dir)->i_projid,
3615 err = dquot_initialize(dir);
3618 return __ext4_link(dir, inode, dentry);
3624 * if it is a normal dir.
3675 struct inode *dir;
3701 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3727 ext4_std_error(ent->dir->i_sb, retval);
3743 if (ext4_has_feature_filetype(ent->dir->i_sb))
3745 inode_inc_iversion(ent->dir);
3746 ent->dir->i_ctime = ent->dir->i_mtime =
3747 current_time(ent->dir);
3748 retval = ext4_mark_inode_dirty(handle, ent->dir);
3751 retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh);
3753 ext4_std_error(ent->dir->i_sb, retval2);
3767 * old->de could have moved from under us during make indexed dir,
3771 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3778 ext4_std_error(old.dir->i_sb, retval);
3786 static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
3793 bh = ext4_find_entry(dir, d_name, &de, NULL);
3797 retval = ext4_delete_entry(handle, dir, de, bh);
3818 retval = ext4_find_delete_entry(handle, ent->dir,
3821 retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3823 retval = ext4_find_delete_entry(handle, ent->dir,
3829 ext4_warning_inode(ent->dir,
3831 ent->dir->i_nlink, retval);
3839 ext4_dec_count(ent->dir);
3841 ext4_inc_count(ent->dir);
3842 ext4_mark_inode_dirty(handle, ent->dir);
3857 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3860 wh = ext4_new_inode_start_handle(ent->dir, S_IFCHR | WHITEOUT_MODE,
3869 ext4_should_retry_alloc(ent->dir->i_sb, &retries))
3893 .dir = old_dir,
3898 .dir = new_dir,
3919 retval = dquot_initialize(old.dir);
3925 retval = dquot_initialize(new.dir);
3937 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3952 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3965 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3968 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3971 handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3985 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3995 if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
4003 * If we're renaming a file within an inline_data dir and adding or
4009 force_reread = (new.dir->i_ino == old.dir->i_ino &&
4010 ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
4037 force_reread = !ext4_test_inode_flag(new.dir,
4060 old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
4061 ext4_update_dx_flag(old.dir);
4063 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4067 ext4_dec_count(old.dir);
4074 ext4_inc_count(new.dir);
4075 ext4_update_dx_flag(new.dir);
4076 retval = ext4_mark_inode_dirty(handle, new.dir);
4081 retval = ext4_mark_inode_dirty(handle, old.dir);
4138 .dir = old_dir,
4143 .dir = new_dir,
4159 retval = dquot_initialize(old.dir);
4162 retval = dquot_initialize(new.dir);
4166 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
4180 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
4192 handle = ext4_journal_start(old.dir, EXT4_HT_DIR,
4193 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
4201 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
4221 if (old.dir != new.dir && old.is_dir != new.is_dir) {
4225 if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
4226 (new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
4255 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4260 retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);