Lines Matching defs:dir
301 static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
302 static unsigned dx_node_limit(struct inode *dir);
304 struct inode *dir,
308 static int dx_make_map(struct inode *dir, struct buffer_head *bh,
312 static struct ext4_dir_entry_2 *dx_move_dirents(struct inode *dir, char *from,
315 static struct ext4_dir_entry_2 *dx_pack_dirents(struct inode *dir, char *base,
319 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
323 static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
327 struct inode *dir, struct inode *inode);
501 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
530 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
608 static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
610 unsigned int entry_space = dir->i_sb->s_blocksize -
614 if (ext4_has_metadata_csum(dir->i_sb))
619 static inline unsigned dx_node_limit(struct inode *dir)
621 unsigned int entry_space = dir->i_sb->s_blocksize -
622 ext4_dir_rec_len(0, dir);
624 if (ext4_has_metadata_csum(dir->i_sb))
652 static struct stats dx_show_leaf(struct inode *dir,
677 if (!IS_ENCRYPTED(dir)) {
679 (void) ext4fs_dirhash(dir, de->name,
697 res = fscrypt_fname_disk_to_usr(dir,
711 if (IS_CASEFOLDED(dir))
714 (void) ext4fs_dirhash(dir,
726 (void) ext4fs_dirhash(dir, de->name,
732 space += ext4_dir_rec_len(de->name_len, dir);
741 struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
744 unsigned blocksize = dir->i_sb->s_blocksize;
756 bh = ext4_bread(NULL,dir, block, 0);
760 dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
761 dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
809 dx_probe(struct ext4_filename *fname, struct inode *dir,
822 frame->bh = ext4_read_dirblock(dir, 0, INDEX);
831 ext4_warning_inode(dir, "Unrecognised inode hash code %u",
835 if (ext4_hash_in_dirent(dir)) {
837 ext4_warning_inode(dir,
843 ext4_warning_inode(dir,
852 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
853 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
856 !(IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir))) {
857 int ret = ext4fs_dirhash(dir, fname_name(fname),
867 ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
873 if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
874 ext4_warning(dir->i_sb,
876 "supported value", dir->i_ino,
877 ext4_dir_htree_level(dir->i_sb));
878 if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
879 ext4_warning(dir->i_sb, "Enable large directory "
888 if (dx_get_limit(entries) != dx_root_limit(dir,
890 ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
892 dx_root_limit(dir, root->info.info_length));
902 ext4_warning_inode(dir,
931 ext4_warning_inode(dir,
941 frame->bh = ext4_read_dirblock(dir, block, INDEX);
950 if (dx_get_limit(entries) != dx_node_limit(dir)) {
951 ext4_warning_inode(dir,
953 dx_get_limit(entries), dx_node_limit(dir));
964 ext4_warning_inode(dir,
1006 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
1052 bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
1070 struct inode *dir, ext4_lblk_t block,
1078 int csum = ext4_has_metadata_csum(dir->i_sb);
1082 bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1089 dir->i_sb->s_blocksize -
1091 csum ? NULL : dir));
1093 if (IS_ENCRYPTED(dir)) {
1094 err = fscrypt_prepare_readdir(dir);
1107 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
1108 if (ext4_check_dir_entry(dir, NULL, de, bh,
1110 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
1115 if (ext4_hash_in_dirent(dir)) {
1124 err = ext4fs_dirhash(dir, de->name,
1137 if (!IS_ENCRYPTED(dir)) {
1149 err = fscrypt_fname_disk_to_usr(dir, hinfo->hash,
1188 struct inode *dir;
1197 dir = file_inode(dir_file);
1198 if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1199 if (ext4_hash_in_dirent(dir))
1203 EXT4_SB(dir->i_sb)->s_def_hash_version;
1206 EXT4_SB(dir->i_sb)->s_hash_unsigned;
1207 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1208 if (ext4_has_inline_data(dir)) {
1210 count = ext4_inlinedir_to_tree(dir_file, dir, 0,
1219 count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1226 frame = dx_probe(NULL, dir, &hinfo, frames);
1243 de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1260 ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1268 ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1294 struct inode *dir,
1299 return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
1311 static int dx_make_map(struct inode *dir, struct buffer_head *bh,
1320 int blocksize = EXT4_BLOCK_SIZE(dir->i_sb);
1322 if (ext4_has_metadata_csum(dir->i_sb))
1326 if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen,
1330 if (ext4_hash_in_dirent(dir))
1333 int err = ext4fs_dirhash(dir, de->name,
1445 int ext4_fname_setup_ci_filename(struct inode *dir, const struct qstr *iname,
1452 if (!IS_CASEFOLDED(dir) ||
1453 (IS_ENCRYPTED(dir) && !fscrypt_has_encryption_key(dir))) {
1462 len = utf8_casefold(dir->i_sb->s_encoding,
1470 if (!IS_ENCRYPTED(dir))
1476 return ext4fs_dirhash(dir, cf_name->name, cf_name->len, hinfo);
1478 return ext4fs_dirhash(dir, iname->name, iname->len, hinfo);
1531 struct inode *dir, struct ext4_filename *fname,
1544 ext4_match(dir, fname, de)) {
1547 if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf,
1555 dir->i_sb->s_blocksize);
1564 static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1567 struct super_block *sb = dir->i_sb;
1569 if (!is_dx(dir))
1591 static struct buffer_head *__ext4_find_entry(struct inode *dir,
1609 sb = dir->i_sb;
1614 if (ext4_has_inline_data(dir)) {
1616 ret = ext4_find_inline_entry(dir, fname, res_dir,
1634 if (is_dx(dir)) {
1635 ret = ext4_dx_find_entry(dir, fname, res_dir);
1647 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1652 start = EXT4_I(dir)->i_dir_start_lookup;
1670 retval = ext4_bread_batch(dir, block, ra_max,
1682 EXT4_ERROR_INODE_ERR(dir, EIO,
1690 !is_dx_internal_node(dir, block,
1692 !ext4_dirblock_csum_verify(dir, bh)) {
1693 EXT4_ERROR_INODE_ERR(dir, EFSBADCRC,
1701 i = search_dirblock(bh, dir, fname,
1704 EXT4_I(dir)->i_dir_start_lookup = block;
1722 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1735 static struct buffer_head *ext4_find_entry(struct inode *dir,
1744 err = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1750 bh = __ext4_find_entry(dir, &fname, res_dir, inlined);
1756 static struct buffer_head *ext4_lookup_entry(struct inode *dir,
1764 err = ext4_fname_prepare_lookup(dir, dentry, &fname);
1771 bh = __ext4_find_entry(dir, &fname, res_dir, NULL);
1777 static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
1781 struct super_block * sb = dir->i_sb;
1790 frame = dx_probe(fname, dir, NULL, frames);
1795 bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1799 retval = search_dirblock(bh, dir, fname,
1811 retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1814 ext4_warning_inode(dir,
1830 static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1839 bh = ext4_lookup_entry(dir, dentry, &de);
1846 if (!ext4_valid_inum(dir->i_sb, ino)) {
1847 EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1850 if (unlikely(ino == dir->i_ino)) {
1851 EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
1855 inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL);
1857 EXT4_ERROR_INODE(dir,
1862 if (!IS_ERR(inode) && IS_ENCRYPTED(dir) &&
1864 !fscrypt_has_permitted_context(dir, inode)) {
1867 dir->i_ino, inode->i_ino);
1874 if (!inode && IS_CASEFOLDED(dir)) {
1915 dx_move_dirents(struct inode *dir, char *from, char *to,
1924 rec_len = ext4_dir_rec_len(de->name_len, dir);
1944 * Compact each dir entry in the range to the minimal rec_len.
1947 static struct ext4_dir_entry_2 *dx_pack_dirents(struct inode *dir, char *base,
1957 rec_len = ext4_dir_rec_len(de->name_len, dir);
1970 * Split a full leaf block to make room for a new dir entry.
1974 static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1978 unsigned blocksize = dir->i_sb->s_blocksize;
1991 if (ext4_has_metadata_csum(dir->i_sb))
1994 bh2 = ext4_append(handle, dir, &newblock);
2002 err = ext4_journal_get_write_access(handle, dir->i_sb, *bh,
2008 err = ext4_journal_get_write_access(handle, dir->i_sb, frame->bh,
2017 count = dx_make_map(dir, *bh, hinfo, map);
2053 de2 = dx_move_dirents(dir, data1, data2, map + split, count - split,
2055 de = dx_pack_dirents(dir, data1, blocksize);
2067 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
2069 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
2078 err = ext4_handle_dirty_dirblock(handle, dir, bh2);
2081 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2092 ext4_std_error(dir->i_sb, err);
2096 int ext4_find_dest_de(struct inode *dir, struct inode *inode,
2103 unsigned short reclen = ext4_dir_rec_len(fname_len(fname), dir);
2111 if (ext4_check_dir_entry(dir, NULL, de, bh,
2114 if (ext4_match(dir, fname, de))
2116 nlen = ext4_dir_rec_len(de->name_len, dir);
2130 void ext4_insert_dentry(struct inode *dir,
2139 nlen = ext4_dir_rec_len(de->name_len, dir);
2153 if (ext4_hash_in_dirent(dir)) {
2171 struct inode *dir,
2175 unsigned int blocksize = dir->i_sb->s_blocksize;
2183 err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
2189 err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2192 ext4_std_error(dir->i_sb, err);
2197 ext4_insert_dentry(dir, inode, de, blocksize, fname);
2210 dir->i_mtime = inode_set_ctime_current(dir);
2211 ext4_update_dx_flag(dir);
2212 inode_inc_iversion(dir);
2213 err2 = ext4_mark_inode_dirty(handle, dir);
2215 err = ext4_handle_dirty_dirblock(handle, dir, bh);
2217 ext4_std_error(dir->i_sb, err);
2226 struct inode *dir,
2245 blocksize = dir->i_sb->s_blocksize;
2246 dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2248 retval = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2251 ext4_std_error(dir->i_sb, retval);
2262 EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
2269 bh2 = ext4_append(handle, dir, &block);
2274 ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2282 if (ext4_check_dir_entry(dir, NULL, de, bh2, data2, len,
2303 if (ext4_hash_in_dirent(dir))
2307 EXT4_SB(dir->i_sb)->s_def_hash_version;
2312 dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2317 fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2318 fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2321 if (!ext4_hash_in_dirent(dir)) {
2322 int err = ext4fs_dirhash(dir, fname_name(fname),
2336 retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2339 retval = ext4_handle_dirty_dirblock(handle, dir, bh2);
2343 de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2349 retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2357 ext4_mark_inode_dirty(handle, dir);
2376 struct inode *dir = d_inode(dentry->d_parent);
2390 sb = dir->i_sb;
2399 if (sb_has_strict_encoding(sb) && IS_CASEFOLDED(dir) &&
2404 retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2408 if (ext4_has_inline_data(dir)) {
2409 retval = ext4_try_add_inline_entry(handle, &fname, dir, inode);
2418 if (is_dx(dir)) {
2419 retval = ext4_dx_add_entry(handle, &fname, dir, inode);
2424 EXT4_ERROR_INODE(dir,
2429 ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2431 retval = ext4_mark_inode_dirty(handle, dir);
2435 blocks = dir->i_size >> sb->s_blocksize_bits;
2437 bh = ext4_read_dirblock(dir, block, DIRENT);
2439 bh = ext4_bread(handle, dir, block,
2448 retval = add_dirent_to_buf(handle, &fname, dir, inode,
2455 retval = make_indexed_dir(handle, &fname, dir,
2462 bh = ext4_append(handle, dir, &block);
2476 retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2489 struct inode *dir, struct inode *inode)
2494 struct super_block *sb = dir->i_sb;
2501 frame = dx_probe(fname, dir, NULL, frames);
2506 bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE);
2518 err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2550 dir->i_ino, levels);
2560 bh2 = ext4_append(handle, dir, &newblock);
2592 dx_set_limit(entries2, dx_node_limit(dir));
2604 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2608 err = ext4_handle_dirty_dx_node(handle, dir,
2612 err = ext4_handle_dirty_dx_node(handle, dir,
2620 dx_set_limit(entries2, dx_node_limit(dir));
2630 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2633 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2639 de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2644 err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2648 ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */
2664 int ext4_generic_delete_entry(struct inode *dir,
2672 unsigned int blocksize = dir->i_sb->s_blocksize;
2679 if (ext4_check_dir_entry(dir, NULL, de, bh,
2704 inode_inc_iversion(dir);
2715 struct inode *dir,
2721 if (ext4_has_inline_data(dir)) {
2723 err = ext4_delete_inline_entry(handle, dir, de_del, bh,
2729 if (ext4_has_metadata_csum(dir->i_sb))
2733 err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2738 err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data,
2739 dir->i_sb->s_blocksize, csum_size);
2744 err = ext4_handle_dirty_dirblock(handle, dir, bh);
2751 ext4_std_error(dir->i_sb, err);
2794 struct inode *dir = d_inode(dentry->d_parent);
2799 if (IS_DIRSYNC(dir))
2820 static int ext4_create(struct mnt_idmap *idmap, struct inode *dir,
2827 err = dquot_initialize(dir);
2831 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2834 inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2850 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2855 static int ext4_mknod(struct mnt_idmap *idmap, struct inode *dir,
2862 err = dquot_initialize(dir);
2866 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2869 inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2884 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2889 static int ext4_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
2896 err = dquot_initialize(dir);
2901 inode = ext4_new_inode_start_handle(idmap, dir, mode,
2904 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
2921 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2959 int ext4_init_new_dir(handle_t *handle, struct inode *dir,
2965 unsigned int blocksize = dir->i_sb->s_blocksize;
2969 if (ext4_has_metadata_csum(dir->i_sb))
2973 err = ext4_try_create_inline_dir(handle, dir, inode);
2985 ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
3000 static int ext4_mkdir(struct mnt_idmap *idmap, struct inode *dir,
3007 if (EXT4_DIR_LINK_MAX(dir))
3010 err = dquot_initialize(dir);
3014 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3017 inode = ext4_new_inode_start_handle(idmap, dir, S_IFDIR | mode,
3027 err = ext4_init_new_dir(handle, dir, inode);
3045 ext4_inc_count(dir);
3047 ext4_update_dx_flag(dir);
3048 err = ext4_mark_inode_dirty(handle, dir);
3053 if (IS_DIRSYNC(dir))
3060 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3142 static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
3150 if (unlikely(ext4_forced_shutdown(dir->i_sb)))
3155 retval = dquot_initialize(dir);
3163 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3179 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3180 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3187 if (IS_DIRSYNC(dir))
3190 retval = ext4_delete_entry(handle, dir, de, bh);
3205 dir->i_mtime = inode_set_ctime_current(dir);
3210 ext4_dec_count(dir);
3211 ext4_update_dx_flag(dir);
3213 retval = ext4_mark_inode_dirty(handle, dir);
3222 if (IS_CASEFOLDED(dir))
3233 int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
3247 bh = ext4_find_entry(dir, d_name, &de, NULL);
3266 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3267 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3273 if (IS_DIRSYNC(dir))
3277 retval = ext4_delete_entry(handle, dir, de, bh);
3280 dir->i_mtime = inode_set_ctime_current(dir);
3281 ext4_update_dx_flag(dir);
3282 retval = ext4_mark_inode_dirty(handle, dir);
3306 static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3310 if (unlikely(ext4_forced_shutdown(dir->i_sb)))
3313 trace_ext4_unlink_enter(dir, dentry);
3318 retval = dquot_initialize(dir);
3325 retval = __ext4_unlink(dir, &dentry->d_name, d_inode(dentry), dentry);
3333 if (IS_CASEFOLDED(dir))
3368 static int ext4_symlink(struct mnt_idmap *idmap, struct inode *dir,
3378 if (unlikely(ext4_forced_shutdown(dir->i_sb)))
3381 err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
3386 err = dquot_initialize(dir);
3396 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3399 inode = ext4_new_inode_start_handle(idmap, dir, S_IFLNK|S_IRWXUGO,
3452 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3459 int __ext4_link(struct inode *dir, struct inode *inode, struct dentry *dentry)
3464 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3465 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3470 if (IS_DIRSYNC(dir))
3492 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3498 struct inode *dir, struct dentry *dentry)
3506 err = fscrypt_prepare_link(old_dentry, dir, dentry);
3510 if ((ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT)) &&
3511 (!projid_eq(EXT4_I(dir)->i_projid,
3515 err = dquot_initialize(dir);
3518 return __ext4_link(dir, inode, dentry);
3524 * if it is a normal dir.
3578 struct inode *dir;
3604 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3607 return ext4_journal_get_write_access(handle, ent->dir->i_sb,
3631 ext4_std_error(ent->dir->i_sb, retval);
3643 retval = ext4_journal_get_write_access(handle, ent->dir->i_sb, ent->bh,
3648 if (ext4_has_feature_filetype(ent->dir->i_sb))
3650 inode_inc_iversion(ent->dir);
3651 ent->dir->i_mtime = inode_set_ctime_current(ent->dir);
3652 retval = ext4_mark_inode_dirty(handle, ent->dir);
3655 retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh);
3657 ext4_std_error(ent->dir->i_sb, retval2);
3671 * old->de could have moved from under us during make indexed dir,
3675 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3682 ext4_std_error(old.dir->i_sb, retval);
3690 static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
3697 bh = ext4_find_entry(dir, d_name, &de, NULL);
3701 retval = ext4_delete_entry(handle, dir, de, bh);
3722 retval = ext4_find_delete_entry(handle, ent->dir,
3725 retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3727 retval = ext4_find_delete_entry(handle, ent->dir,
3733 ext4_warning_inode(ent->dir,
3735 ent->dir->i_nlink, retval);
3743 ext4_dec_count(ent->dir);
3745 ext4_inc_count(ent->dir);
3746 ext4_mark_inode_dirty(handle, ent->dir);
3762 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3765 wh = ext4_new_inode_start_handle(idmap, ent->dir,
3775 ext4_should_retry_alloc(ent->dir->i_sb, &retries))
3799 .dir = old_dir,
3804 .dir = new_dir,
3825 retval = dquot_initialize(old.dir);
3831 retval = dquot_initialize(new.dir);
3843 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3858 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3871 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3874 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3877 handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3891 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3901 if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
3909 * If we're renaming a file within an inline_data dir and adding or
3915 force_reread = (new.dir->i_ino == old.dir->i_ino &&
3916 ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
3943 force_reread = !ext4_test_inode_flag(new.dir,
3966 old.dir->i_mtime = inode_set_ctime_current(old.dir);
3967 ext4_update_dx_flag(old.dir);
3969 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3973 ext4_dec_count(old.dir);
3980 ext4_inc_count(new.dir);
3981 ext4_update_dx_flag(new.dir);
3982 retval = ext4_mark_inode_dirty(handle, new.dir);
3987 retval = ext4_mark_inode_dirty(handle, old.dir);
4052 .dir = old_dir,
4057 .dir = new_dir,
4072 retval = dquot_initialize(old.dir);
4075 retval = dquot_initialize(new.dir);
4079 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
4093 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
4105 handle = ext4_journal_start(old.dir, EXT4_HT_DIR,
4106 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
4114 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
4134 if (old.dir != new.dir && old.is_dir != new.is_dir) {
4138 if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
4139 (new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
4167 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4172 retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);