Lines Matching +full:de +full:- +full:be
1 // SPDX-License-Identifier: GPL-2.0
7 * Laboratoire MASI - Institut Blaise Pascal
16 * Big-endian to little-endian byte-swapping/bitmaps by
19 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
61 if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb && in ext4_append()
62 ((inode->i_size >> 10) >= in ext4_append()
63 EXT4_SB(inode->i_sb)->s_max_dir_size_kb))) in ext4_append()
64 return ERR_PTR(-ENOSPC); in ext4_append()
66 *block = inode->i_size >> inode->i_sb->s_blocksize_bits; in ext4_append()
80 return ERR_PTR(-EFSCORRUPTED); in ext4_append()
86 inode->i_size += inode->i_sb->s_blocksize; in ext4_append()
87 EXT4_I(inode)->i_disksize = inode->i_size; in ext4_append()
92 err = ext4_journal_get_write_access(handle, inode->i_sb, bh, in ext4_append()
100 ext4_std_error(inode->i_sb, err); in ext4_append()
109 * block being read to be an index block, or a block containing
114 * the caller doesn't know what kind of directory block will be read,
115 * so no specific verification will be done.
134 if (block >= inode->i_size >> inode->i_blkbits) { in __ext4_read_dirblock()
137 block, inode->i_size); in __ext4_read_dirblock()
138 return ERR_PTR(-EFSCORRUPTED); in __ext4_read_dirblock()
141 if (ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_EIO)) in __ext4_read_dirblock()
142 bh = ERR_PTR(-EIO); in __ext4_read_dirblock()
146 __ext4_warning(inode->i_sb, func, line, in __ext4_read_dirblock()
149 inode->i_ino, (unsigned long)block, in __ext4_read_dirblock()
150 current->comm, PTR_ERR(bh)); in __ext4_read_dirblock()
158 return ERR_PTR(-EFSCORRUPTED); in __ext4_read_dirblock()
162 dirent = (struct ext4_dir_entry *) bh->b_data; in __ext4_read_dirblock()
167 else if (ext4_rec_len_from_disk(dirent->rec_len, in __ext4_read_dirblock()
168 inode->i_sb->s_blocksize) == in __ext4_read_dirblock()
169 inode->i_sb->s_blocksize) in __ext4_read_dirblock()
176 return ERR_PTR(-EFSCORRUPTED); in __ext4_read_dirblock()
178 if (!ext4_has_metadata_csum(inode->i_sb) || in __ext4_read_dirblock()
185 * caller is sure it should be an index block. in __ext4_read_dirblock()
189 !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC)) in __ext4_read_dirblock()
196 return ERR_PTR(-EFSBADCRC); in __ext4_read_dirblock()
201 !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC)) in __ext4_read_dirblock()
208 return ERR_PTR(-EFSBADCRC); in __ext4_read_dirblock()
242 * dirent the two low bits of the hash version will be zero. Therefore, the
243 * hash version mod 4 should never be 0. Sincerely, the paranoia department.
333 struct ext4_dir_entry_tail *t = EXT4_DIRENT_TAIL(bh->b_data, blocksize); in ext4_initialize_dirent_tail()
336 t->det_rec_len = ext4_rec_len_to_disk( in ext4_initialize_dirent_tail()
338 t->det_reserved_ft = EXT4_FT_DIR_CSUM; in ext4_initialize_dirent_tail()
346 int blocksize = EXT4_BLOCK_SIZE(inode->i_sb); in get_dirent_tail()
351 d = (struct ext4_dir_entry *)bh->b_data; in get_dirent_tail()
352 top = (struct ext4_dir_entry *)(bh->b_data + in get_dirent_tail()
353 (blocksize - sizeof(struct ext4_dir_entry_tail))); in get_dirent_tail()
354 while (d < top && ext4_rec_len_from_disk(d->rec_len, blocksize)) in get_dirent_tail()
356 ext4_rec_len_from_disk(d->rec_len, blocksize)); in get_dirent_tail()
363 t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb)); in get_dirent_tail()
366 if (t->det_reserved_zero1 || in get_dirent_tail()
367 (ext4_rec_len_from_disk(t->det_rec_len, blocksize) != in get_dirent_tail()
369 t->det_reserved_zero2 || in get_dirent_tail()
370 t->det_reserved_ft != EXT4_FT_DIR_CSUM) in get_dirent_tail()
378 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_dirblock_csum()
382 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size); in ext4_dirblock_csum()
393 "No space for directory leaf checksum. Please run e2fsck -D."); in __warn_no_space_for_csum()
400 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dirblock_csum_verify()
409 if (t->det_checksum != ext4_dirblock_csum(inode, bh->b_data, in ext4_dirblock_csum_verify()
410 (char *)t - bh->b_data)) in ext4_dirblock_csum_verify()
421 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dirblock_csum_set()
430 t->det_checksum = ext4_dirblock_csum(inode, bh->b_data, in ext4_dirblock_csum_set()
431 (char *)t - bh->b_data); in ext4_dirblock_csum_set()
449 int blocksize = EXT4_BLOCK_SIZE(inode->i_sb); in get_dx_countlimit()
450 unsigned int rlen = ext4_rec_len_from_disk(dirent->rec_len, blocksize); in get_dx_countlimit()
456 if (ext4_rec_len_from_disk(dp->rec_len, blocksize) != blocksize - 12) in get_dx_countlimit()
459 if (root->reserved_zero || in get_dx_countlimit()
460 root->info_length != sizeof(struct dx_root_info)) in get_dx_countlimit()
474 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_dx_csum()
482 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size); in ext4_dx_csum()
496 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dx_csum_verify()
501 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D."); in ext4_dx_csum_verify()
504 limit = le16_to_cpu(c->limit); in ext4_dx_csum_verify()
505 count = le16_to_cpu(c->count); in ext4_dx_csum_verify()
507 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { in ext4_dx_csum_verify()
513 if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset, in ext4_dx_csum_verify()
525 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dx_csum_set()
530 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D."); in ext4_dx_csum_set()
533 limit = le16_to_cpu(c->limit); in ext4_dx_csum_set()
534 count = le16_to_cpu(c->count); in ext4_dx_csum_set()
536 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { in ext4_dx_csum_set()
542 t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t); in ext4_dx_csum_set()
549 ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data); in ext4_handle_dirty_dx_node()
560 ext4_rec_len_from_disk(p->rec_len, blocksize)); in ext4_next_entry()
564 * Future: use high four bits of block for coalesce-on-delete flags
570 return le32_to_cpu(entry->block) & 0x0fffffff; in dx_get_block()
575 entry->block = cpu_to_le32(value); in dx_set_block()
580 return le32_to_cpu(entry->hash); in dx_get_hash()
585 entry->hash = cpu_to_le32(value); in dx_set_hash()
590 return le16_to_cpu(((struct dx_countlimit *) entries)->count); in dx_get_count()
595 return le16_to_cpu(((struct dx_countlimit *) entries)->limit); in dx_get_limit()
600 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value); in dx_set_count()
605 ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value); in dx_set_limit()
610 unsigned int entry_space = dir->i_sb->s_blocksize - in dx_root_limit()
611 ext4_dir_rec_len(1, NULL) - in dx_root_limit()
612 ext4_dir_rec_len(2, NULL) - infosize; in dx_root_limit()
614 if (ext4_has_metadata_csum(dir->i_sb)) in dx_root_limit()
615 entry_space -= sizeof(struct dx_tail); in dx_root_limit()
621 unsigned int entry_space = dir->i_sb->s_blocksize - in dx_node_limit()
624 if (ext4_has_metadata_csum(dir->i_sb)) in dx_node_limit()
625 entry_space -= sizeof(struct dx_tail); in dx_node_limit()
638 printk(KERN_CONT " %x->%lu", in dx_show_index()
654 struct ext4_dir_entry_2 *de, in dx_show_leaf() argument
658 char *base = (char *) de; in dx_show_leaf()
662 while ((char *) de < base + size) in dx_show_leaf()
664 if (de->inode) in dx_show_leaf()
675 name = de->name; in dx_show_leaf()
676 len = de->name_len; in dx_show_leaf()
679 (void) ext4fs_dirhash(dir, de->name, in dx_show_leaf()
680 de->name_len, &h); in dx_show_leaf()
683 (unsigned) ((char *) de in dx_show_leaf()
684 - base)); in dx_show_leaf()
695 "buffer--skipping " in dx_show_leaf()
712 h.hash = EXT4_DIRENT_HASH(de); in dx_show_leaf()
715 de->name, in dx_show_leaf()
716 de->name_len, &h); in dx_show_leaf()
718 h.hash, (unsigned) ((char *) de in dx_show_leaf()
719 - base)); in dx_show_leaf()
724 int len = de->name_len; in dx_show_leaf()
725 char *name = de->name; in dx_show_leaf()
726 (void) ext4fs_dirhash(dir, de->name, in dx_show_leaf()
727 de->name_len, &h); in dx_show_leaf()
729 (unsigned) ((char *) de - base)); in dx_show_leaf()
732 space += ext4_dir_rec_len(de->name_len, dir); in dx_show_leaf()
735 de = ext4_next_entry(de, size); in dx_show_leaf()
744 unsigned blocksize = dir->i_sb->s_blocksize; in dx_show_entries()
753 u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash; in dx_show_entries()
760 dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1): in dx_show_entries()
762 bh->b_data, blocksize, 0); in dx_show_entries()
782 while (n--) { in htree_rep_invariant_check()
785 at--; in htree_rep_invariant_check()
789 ASSERT(at == target - 1); in htree_rep_invariant_check()
822 frame->bh = ext4_read_dirblock(dir, 0, INDEX); in dx_probe()
823 if (IS_ERR(frame->bh)) in dx_probe()
824 return (struct dx_frame *) frame->bh; in dx_probe()
826 root = (struct dx_root *) frame->bh->b_data; in dx_probe()
827 if (root->info.hash_version != DX_HASH_TEA && in dx_probe()
828 root->info.hash_version != DX_HASH_HALF_MD4 && in dx_probe()
829 root->info.hash_version != DX_HASH_LEGACY && in dx_probe()
830 root->info.hash_version != DX_HASH_SIPHASH) { in dx_probe()
832 root->info.hash_version); in dx_probe()
836 if (root->info.hash_version != DX_HASH_SIPHASH) { in dx_probe()
842 if (root->info.hash_version == DX_HASH_SIPHASH) { in dx_probe()
849 hinfo = &fname->hinfo; in dx_probe()
850 hinfo->hash_version = root->info.hash_version; in dx_probe()
851 if (hinfo->hash_version <= DX_HASH_TEA) in dx_probe()
852 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; in dx_probe()
853 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed; in dx_probe()
864 hash = hinfo->hash; in dx_probe()
866 if (root->info.unused_flags & 1) { in dx_probe()
868 root->info.unused_flags); in dx_probe()
872 indirect = root->info.indirect_levels; in dx_probe()
873 if (indirect >= ext4_dir_htree_level(dir->i_sb)) { in dx_probe()
874 ext4_warning(dir->i_sb, in dx_probe()
876 "supported value", dir->i_ino, in dx_probe()
877 ext4_dir_htree_level(dir->i_sb)); in dx_probe()
878 if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) { in dx_probe()
879 ext4_warning(dir->i_sb, "Enable large directory " in dx_probe()
885 entries = (struct dx_entry *)(((char *)&root->info) + in dx_probe()
886 root->info.info_length); in dx_probe()
889 root->info.info_length)) { in dx_probe()
892 dx_root_limit(dir, root->info.info_length)); in dx_probe()
909 q = entries + count - 1; in dx_probe()
911 m = p + (q - p) / 2; in dx_probe()
914 q = m - 1; in dx_probe()
919 htree_rep_invariant_check(entries, p, hash, count - 1); in dx_probe()
921 at = p - 1; in dx_probe()
922 dxtrace(printk(KERN_CONT " %x->%u\n", in dx_probe()
925 frame->entries = entries; in dx_probe()
926 frame->at = at; in dx_probe()
941 frame->bh = ext4_read_dirblock(dir, block, INDEX); in dx_probe()
942 if (IS_ERR(frame->bh)) { in dx_probe()
943 ret_err = (struct dx_frame *) frame->bh; in dx_probe()
944 frame->bh = NULL; in dx_probe()
948 entries = ((struct dx_node *) frame->bh->b_data)->entries; in dx_probe()
959 brelse(frame->bh); in dx_probe()
960 frame--; in dx_probe()
978 info = &((struct dx_root *)frames[0].bh->b_data)->info; in dx_release()
979 /* save local copy, "info" may be freed after brelse() */ in dx_release()
980 indirect_levels = info->indirect_levels; in dx_release()
992 * should be necessary. Whether or not the search is necessary is
1003 * If start_hash is non-null, it will be filled in with the starting
1022 * nodes need to be read. in ext4_htree_next_block()
1025 if (++(p->at) < p->entries + dx_get_count(p->entries)) in ext4_htree_next_block()
1030 p--; in ext4_htree_next_block()
1040 bhash = dx_get_hash(p->at); in ext4_htree_next_block()
1051 while (num_frames--) { in ext4_htree_next_block()
1052 bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX); in ext4_htree_next_block()
1056 brelse(p->bh); in ext4_htree_next_block()
1057 p->bh = bh; in ext4_htree_next_block()
1058 p->at = p->entries = ((struct dx_node *) bh->b_data)->entries; in ext4_htree_next_block()
1065 * This function fills a red-black tree with information from a
1075 struct ext4_dir_entry_2 *de, *top; in htree_dirblock_to_tree() local
1078 int csum = ext4_has_metadata_csum(dir->i_sb); in htree_dirblock_to_tree()
1086 de = (struct ext4_dir_entry_2 *) bh->b_data; in htree_dirblock_to_tree()
1088 top = (struct ext4_dir_entry_2 *) ((char *) de + in htree_dirblock_to_tree()
1089 dir->i_sb->s_blocksize - in htree_dirblock_to_tree()
1107 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) { in htree_dirblock_to_tree()
1108 if (ext4_check_dir_entry(dir, NULL, de, bh, in htree_dirblock_to_tree()
1109 bh->b_data, bh->b_size, in htree_dirblock_to_tree()
1110 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb)) in htree_dirblock_to_tree()
1111 + ((char *)de - bh->b_data))) { in htree_dirblock_to_tree()
1116 if (de->name_len && de->inode) { in htree_dirblock_to_tree()
1117 hinfo->hash = EXT4_DIRENT_HASH(de); in htree_dirblock_to_tree()
1118 hinfo->minor_hash = EXT4_DIRENT_MINOR_HASH(de); in htree_dirblock_to_tree()
1120 hinfo->hash = 0; in htree_dirblock_to_tree()
1121 hinfo->minor_hash = 0; in htree_dirblock_to_tree()
1124 err = ext4fs_dirhash(dir, de->name, in htree_dirblock_to_tree()
1125 de->name_len, hinfo); in htree_dirblock_to_tree()
1131 if ((hinfo->hash < start_hash) || in htree_dirblock_to_tree()
1132 ((hinfo->hash == start_hash) && in htree_dirblock_to_tree()
1133 (hinfo->minor_hash < start_minor_hash))) in htree_dirblock_to_tree()
1135 if (de->inode == 0) in htree_dirblock_to_tree()
1138 tmp_str.name = de->name; in htree_dirblock_to_tree()
1139 tmp_str.len = de->name_len; in htree_dirblock_to_tree()
1141 hinfo->hash, hinfo->minor_hash, de, in htree_dirblock_to_tree()
1145 struct fscrypt_str de_name = FSTR_INIT(de->name, in htree_dirblock_to_tree()
1146 de->name_len); in htree_dirblock_to_tree()
1149 err = fscrypt_fname_disk_to_usr(dir, hinfo->hash, in htree_dirblock_to_tree()
1150 hinfo->minor_hash, &de_name, in htree_dirblock_to_tree()
1157 hinfo->hash, hinfo->minor_hash, de, in htree_dirblock_to_tree()
1175 * This function fills a red-black tree with information from a
1186 struct ext4_dir_entry_2 *de; in ext4_htree_fill_tree() local
1203 EXT4_SB(dir->i_sb)->s_def_hash_version; in ext4_htree_fill_tree()
1206 EXT4_SB(dir->i_sb)->s_hash_unsigned; in ext4_htree_fill_tree()
1207 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; in ext4_htree_fill_tree()
1232 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data; in ext4_htree_fill_tree()
1233 tmp_str.name = de->name; in ext4_htree_fill_tree()
1234 tmp_str.len = de->name_len; in ext4_htree_fill_tree()
1236 de, &tmp_str); in ext4_htree_fill_tree()
1242 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data; in ext4_htree_fill_tree()
1243 de = ext4_next_entry(de, dir->i_sb->s_blocksize); in ext4_htree_fill_tree()
1244 tmp_str.name = de->name; in ext4_htree_fill_tree()
1245 tmp_str.len = de->name_len; in ext4_htree_fill_tree()
1247 de, &tmp_str); in ext4_htree_fill_tree()
1255 err = -ERESTARTSYS; in ext4_htree_fill_tree()
1259 block = dx_get_block(frame->at); in ext4_htree_fill_tree()
1299 return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir, in search_dirblock()
1316 struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)bh->b_data; in dx_make_map() local
1317 unsigned int buflen = bh->b_size; in dx_make_map()
1318 char *base = bh->b_data; in dx_make_map()
1320 int blocksize = EXT4_BLOCK_SIZE(dir->i_sb); in dx_make_map()
1322 if (ext4_has_metadata_csum(dir->i_sb)) in dx_make_map()
1323 buflen -= sizeof(struct ext4_dir_entry_tail); in dx_make_map()
1325 while ((char *) de < base + buflen) { in dx_make_map()
1326 if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen, in dx_make_map()
1327 ((char *)de) - base)) in dx_make_map()
1328 return -EFSCORRUPTED; in dx_make_map()
1329 if (de->name_len && de->inode) { in dx_make_map()
1331 h.hash = EXT4_DIRENT_HASH(de); in dx_make_map()
1333 int err = ext4fs_dirhash(dir, de->name, in dx_make_map()
1334 de->name_len, &h); in dx_make_map()
1338 map_tail--; in dx_make_map()
1339 map_tail->hash = h.hash; in dx_make_map()
1340 map_tail->offs = ((char *) de - base)>>2; in dx_make_map()
1341 map_tail->size = ext4_rec_len_from_disk(de->rec_len, in dx_make_map()
1346 de = ext4_next_entry(de, blocksize); in dx_make_map()
1354 struct dx_map_entry *p, *q, *top = map + count - 1; in dx_sort_map()
1359 if (count - 9 < 2) /* 9, 10 -> 11 */ in dx_sort_map()
1361 for (p = top, q = p - count; q >= map; p--, q--) in dx_sort_map()
1362 if (p->hash < q->hash) in dx_sort_map()
1369 while (q-- > map) { in dx_sort_map()
1380 struct dx_entry *entries = frame->entries; in dx_insert_block()
1381 struct dx_entry *old = frame->at, *new = old + 1; in dx_insert_block()
1386 memmove(new + 1, new, (char *)(entries + count) - (char *)(new)); in dx_insert_block()
1394 * Test whether a case-insensitive directory entry matches the filename
1404 const struct super_block *sb = parent->i_sb; in ext4_ci_compare()
1405 const struct unicode_map *um = sb->s_encoding; in ext4_ci_compare()
1416 return -ENOMEM; in ext4_ci_compare()
1434 ret = -EINVAL; in ext4_ci_compare()
1435 else if (name->len != entry.len) in ext4_ci_compare()
1438 ret = !!memcmp(name->name, entry.name, entry.len); in ext4_ci_compare()
1448 struct fscrypt_str *cf_name = &name->cf_name; in ext4_fname_setup_ci_filename()
1449 struct dx_hash_info *hinfo = &name->hinfo; in ext4_fname_setup_ci_filename()
1454 cf_name->name = NULL; in ext4_fname_setup_ci_filename()
1458 cf_name->name = kmalloc(EXT4_NAME_LEN, GFP_NOFS); in ext4_fname_setup_ci_filename()
1459 if (!cf_name->name) in ext4_fname_setup_ci_filename()
1460 return -ENOMEM; in ext4_fname_setup_ci_filename()
1462 len = utf8_casefold(dir->i_sb->s_encoding, in ext4_fname_setup_ci_filename()
1463 iname, cf_name->name, in ext4_fname_setup_ci_filename()
1466 kfree(cf_name->name); in ext4_fname_setup_ci_filename()
1467 cf_name->name = NULL; in ext4_fname_setup_ci_filename()
1469 cf_name->len = (unsigned) len; in ext4_fname_setup_ci_filename()
1473 hinfo->hash_version = DX_HASH_SIPHASH; in ext4_fname_setup_ci_filename()
1474 hinfo->seed = NULL; in ext4_fname_setup_ci_filename()
1475 if (cf_name->name) in ext4_fname_setup_ci_filename()
1476 return ext4fs_dirhash(dir, cf_name->name, cf_name->len, hinfo); in ext4_fname_setup_ci_filename()
1478 return ext4fs_dirhash(dir, iname->name, iname->len, hinfo); in ext4_fname_setup_ci_filename()
1489 struct ext4_dir_entry_2 *de) in ext4_match() argument
1493 if (!de->inode) in ext4_match()
1496 f.usr_fname = fname->usr_fname; in ext4_match()
1497 f.disk_name = fname->disk_name; in ext4_match()
1499 f.crypto_buf = fname->crypto_buf; in ext4_match()
1505 if (fname->cf_name.name) { in ext4_match()
1506 struct qstr cf = {.name = fname->cf_name.name, in ext4_match()
1507 .len = fname->cf_name.len}; in ext4_match()
1509 if (fname->hinfo.hash != EXT4_DIRENT_HASH(de) || in ext4_match()
1510 fname->hinfo.minor_hash != in ext4_match()
1511 EXT4_DIRENT_MINOR_HASH(de)) { in ext4_match()
1516 return !ext4_ci_compare(parent, &cf, de->name, in ext4_match()
1517 de->name_len, true); in ext4_match()
1519 return !ext4_ci_compare(parent, fname->usr_fname, de->name, in ext4_match()
1520 de->name_len, false); in ext4_match()
1524 return fscrypt_match_name(&f, de->name, de->name_len); in ext4_match()
1528 * Returns 0 if not found, -1 on failure, and 1 on success
1534 struct ext4_dir_entry_2 * de; in ext4_search_dir() local
1538 de = (struct ext4_dir_entry_2 *)search_buf; in ext4_search_dir()
1540 while ((char *) de < dlimit - EXT4_BASE_DIR_LEN) { in ext4_search_dir()
1543 if (de->name + de->name_len <= dlimit && in ext4_search_dir()
1544 ext4_match(dir, fname, de)) { in ext4_search_dir()
1545 /* found a match - just to be sure, do in ext4_search_dir()
1547 if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf, in ext4_search_dir()
1549 return -1; in ext4_search_dir()
1550 *res_dir = de; in ext4_search_dir()
1554 de_len = ext4_rec_len_from_disk(de->rec_len, in ext4_search_dir()
1555 dir->i_sb->s_blocksize); in ext4_search_dir()
1557 return -1; in ext4_search_dir()
1559 de = (struct ext4_dir_entry_2 *) ((char *) de + de_len); in ext4_search_dir()
1565 struct ext4_dir_entry *de) in is_dx_internal_node() argument
1567 struct super_block *sb = dir->i_sb; in is_dx_internal_node()
1573 if (de->inode == 0 && in is_dx_internal_node()
1574 ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) == in is_dx_internal_node()
1575 sb->s_blocksize) in is_dx_internal_node()
1585 * itself (as a parameter - res_dir). It does NOT read the inode of the
1586 * entry - you'll have to do that yourself if you want to.
1588 * The returned buffer_head has ->b_count elevated. The caller is expected
1600 const u8 *name = fname->usr_fname->name; in __ext4_find_entry()
1609 sb = dir->i_sb; in __ext4_find_entry()
1610 namelen = fname->usr_fname->len; in __ext4_find_entry()
1627 * "." or ".." will only be in the first block in __ext4_find_entry()
1628 * NFS may look up ".."; "." should be handled by the VFS in __ext4_find_entry()
1647 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb); in __ext4_find_entry()
1652 start = EXT4_I(dir)->i_dir_start_lookup; in __ext4_find_entry()
1659 * We deal with the read-ahead logic here. in __ext4_find_entry()
1666 ra_max = start - block; in __ext4_find_entry()
1668 ra_max = nblocks - block; in __ext4_find_entry()
1686 ret = ERR_PTR(-EIO); in __ext4_find_entry()
1691 (struct ext4_dir_entry *)bh->b_data) && in __ext4_find_entry()
1697 ret = ERR_PTR(-EFSBADCRC); in __ext4_find_entry()
1704 EXT4_I(dir)->i_dir_start_lookup = block; in __ext4_find_entry()
1722 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb); in __ext4_find_entry()
1729 /* Clean up the read-ahead blocks */ in __ext4_find_entry()
1745 if (err == -ENOENT) in ext4_find_entry()
1766 if (err == -ENOENT) in ext4_lookup_entry()
1781 struct super_block * sb = dir->i_sb; in ext4_dx_find_entry()
1794 block = dx_get_block(frame->at); in ext4_dx_find_entry()
1805 if (retval == -1) { in ext4_dx_find_entry()
1811 retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame, in ext4_dx_find_entry()
1824 dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name)); in ext4_dx_find_entry()
1833 struct ext4_dir_entry_2 *de; in ext4_lookup() local
1836 if (dentry->d_name.len > EXT4_NAME_LEN) in ext4_lookup()
1837 return ERR_PTR(-ENAMETOOLONG); in ext4_lookup()
1839 bh = ext4_lookup_entry(dir, dentry, &de); in ext4_lookup()
1844 __u32 ino = le32_to_cpu(de->inode); in ext4_lookup()
1846 if (!ext4_valid_inum(dir->i_sb, ino)) { in ext4_lookup()
1848 return ERR_PTR(-EFSCORRUPTED); in ext4_lookup()
1850 if (unlikely(ino == dir->i_ino)) { in ext4_lookup()
1853 return ERR_PTR(-EFSCORRUPTED); in ext4_lookup()
1855 inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL); in ext4_lookup()
1856 if (inode == ERR_PTR(-ESTALE)) { in ext4_lookup()
1860 return ERR_PTR(-EFSCORRUPTED); in ext4_lookup()
1863 (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) && in ext4_lookup()
1865 ext4_warning(inode->i_sb, in ext4_lookup()
1867 dir->i_ino, inode->i_ino); in ext4_lookup()
1869 return ERR_PTR(-EPERM); in ext4_lookup()
1890 struct ext4_dir_entry_2 * de; in ext4_get_parent() local
1893 bh = ext4_find_entry(d_inode(child), &dotdot_name, &de, NULL); in ext4_get_parent()
1897 return ERR_PTR(-ENOENT); in ext4_get_parent()
1898 ino = le32_to_cpu(de->inode); in ext4_get_parent()
1901 if (!ext4_valid_inum(child->d_sb, ino)) { in ext4_get_parent()
1904 return ERR_PTR(-EFSCORRUPTED); in ext4_get_parent()
1907 return d_obtain_alias(ext4_iget(child->d_sb, ino, EXT4_IGET_NORMAL)); in ext4_get_parent()
1921 while (count--) { in dx_move_dirents()
1922 struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *) in dx_move_dirents() local
1923 (from + (map->offs<<2)); in dx_move_dirents()
1924 rec_len = ext4_dir_rec_len(de->name_len, dir); in dx_move_dirents()
1926 memcpy (to, de, rec_len); in dx_move_dirents()
1927 ((struct ext4_dir_entry_2 *) to)->rec_len = in dx_move_dirents()
1931 de->inode = 0; in dx_move_dirents()
1932 memset(&de->name_len, 0, ext4_rec_len_from_disk(de->rec_len, in dx_move_dirents()
1933 blocksize) - in dx_move_dirents()
1940 return (struct ext4_dir_entry_2 *) (to - rec_len); in dx_move_dirents()
1950 struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base; in dx_pack_dirents() local
1953 prev = to = de; in dx_pack_dirents()
1954 while ((char*)de < base + blocksize) { in dx_pack_dirents()
1955 next = ext4_next_entry(de, blocksize); in dx_pack_dirents()
1956 if (de->inode && de->name_len) { in dx_pack_dirents()
1957 rec_len = ext4_dir_rec_len(de->name_len, dir); in dx_pack_dirents()
1958 if (de > to) in dx_pack_dirents()
1959 memmove(to, de, rec_len); in dx_pack_dirents()
1960 to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize); in dx_pack_dirents()
1964 de = next; in dx_pack_dirents()
1972 * Returns pointer to de in block into which the new entry will be inserted.
1978 unsigned blocksize = dir->i_sb->s_blocksize; in do_split()
1985 char *data1 = (*bh)->b_data, *data2; in do_split()
1987 struct ext4_dir_entry_2 *de = NULL, *de2; in do_split() local
1991 if (ext4_has_metadata_csum(dir->i_sb)) in do_split()
2002 err = ext4_journal_get_write_access(handle, dir->i_sb, *bh, in do_split()
2007 BUFFER_TRACE(frame->bh, "get_write_access"); in do_split()
2008 err = ext4_journal_get_write_access(handle, dir->i_sb, frame->bh, in do_split()
2013 data2 = bh2->b_data; in do_split()
2022 map -= count; in do_split()
2027 for (i = count-1; i >= 0; i--) { in do_split()
2042 split = count - move; in do_split()
2047 continued = hash2 == map[split - 1].hash; in do_split()
2049 (unsigned long)dx_get_block(frame->at), in do_split()
2050 hash2, split, count-split)); in do_split()
2053 de2 = dx_move_dirents(dir, data1, data2, map + split, count - split, in do_split()
2055 de = dx_pack_dirents(dir, data1, blocksize); in do_split()
2056 de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) - in do_split()
2057 (char *) de, in do_split()
2059 de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) - in do_split()
2073 if (hinfo->hash >= hash2) { in do_split()
2075 de = de2; in do_split()
2081 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh); in do_split()
2085 dxtrace(dx_show_index("frame", frame->entries)); in do_split()
2086 return de; in do_split()
2092 ext4_std_error(dir->i_sb, err); in do_split()
2102 struct ext4_dir_entry_2 *de; in ext4_find_dest_de() local
2108 de = buf; in ext4_find_dest_de()
2109 top = buf + buf_size - reclen; in ext4_find_dest_de()
2110 while ((char *) de <= top) { in ext4_find_dest_de()
2111 if (ext4_check_dir_entry(dir, NULL, de, bh, in ext4_find_dest_de()
2113 return -EFSCORRUPTED; in ext4_find_dest_de()
2114 if (ext4_match(dir, fname, de)) in ext4_find_dest_de()
2115 return -EEXIST; in ext4_find_dest_de()
2116 nlen = ext4_dir_rec_len(de->name_len, dir); in ext4_find_dest_de()
2117 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size); in ext4_find_dest_de()
2118 if ((de->inode ? rlen - nlen : rlen) >= reclen) in ext4_find_dest_de()
2120 de = (struct ext4_dir_entry_2 *)((char *)de + rlen); in ext4_find_dest_de()
2123 if ((char *) de > top) in ext4_find_dest_de()
2124 return -ENOSPC; in ext4_find_dest_de()
2126 *dest_de = de; in ext4_find_dest_de()
2132 struct ext4_dir_entry_2 *de, in ext4_insert_dentry() argument
2139 nlen = ext4_dir_rec_len(de->name_len, dir); in ext4_insert_dentry()
2140 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size); in ext4_insert_dentry()
2141 if (de->inode) { in ext4_insert_dentry()
2143 (struct ext4_dir_entry_2 *)((char *)de + nlen); in ext4_insert_dentry()
2144 de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size); in ext4_insert_dentry()
2145 de->rec_len = ext4_rec_len_to_disk(nlen, buf_size); in ext4_insert_dentry()
2146 de = de1; in ext4_insert_dentry()
2148 de->file_type = EXT4_FT_UNKNOWN; in ext4_insert_dentry()
2149 de->inode = cpu_to_le32(inode->i_ino); in ext4_insert_dentry()
2150 ext4_set_de_type(inode->i_sb, de, inode->i_mode); in ext4_insert_dentry()
2151 de->name_len = fname_len(fname); in ext4_insert_dentry()
2152 memcpy(de->name, fname_name(fname), fname_len(fname)); in ext4_insert_dentry()
2154 struct dx_hash_info *hinfo = &fname->hinfo; in ext4_insert_dentry()
2156 EXT4_DIRENT_HASHES(de)->hash = cpu_to_le32(hinfo->hash); in ext4_insert_dentry()
2157 EXT4_DIRENT_HASHES(de)->minor_hash = in ext4_insert_dentry()
2158 cpu_to_le32(hinfo->minor_hash); in ext4_insert_dentry()
2163 * Add a new entry into a directory (leaf) block. If de is non-NULL,
2164 * it points to a directory entry which is guaranteed to be large
2165 * enough for new directory entry. If de is NULL, then
2167 * space. It will return -ENOSPC if no space is available, and -EIO
2168 * and -EEXIST if directory entry already exists.
2172 struct inode *inode, struct ext4_dir_entry_2 *de, in add_dirent_to_buf() argument
2175 unsigned int blocksize = dir->i_sb->s_blocksize; in add_dirent_to_buf()
2179 if (ext4_has_metadata_csum(inode->i_sb)) in add_dirent_to_buf()
2182 if (!de) { in add_dirent_to_buf()
2183 err = ext4_find_dest_de(dir, inode, bh, bh->b_data, in add_dirent_to_buf()
2184 blocksize - csum_size, fname, &de); in add_dirent_to_buf()
2189 err = ext4_journal_get_write_access(handle, dir->i_sb, bh, in add_dirent_to_buf()
2192 ext4_std_error(dir->i_sb, err); in add_dirent_to_buf()
2197 ext4_insert_dentry(dir, inode, de, blocksize, fname); in add_dirent_to_buf()
2210 dir->i_mtime = inode_set_ctime_current(dir); in add_dirent_to_buf()
2217 ext4_std_error(dir->i_sb, err); in add_dirent_to_buf()
2233 struct ext4_dir_entry_2 *de, *de2; in make_indexed_dir() local
2242 if (ext4_has_metadata_csum(inode->i_sb)) in make_indexed_dir()
2245 blocksize = dir->i_sb->s_blocksize; in make_indexed_dir()
2246 dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino)); in make_indexed_dir()
2248 retval = ext4_journal_get_write_access(handle, dir->i_sb, bh, in make_indexed_dir()
2251 ext4_std_error(dir->i_sb, retval); in make_indexed_dir()
2255 root = (struct dx_root *) bh->b_data; in make_indexed_dir()
2258 fde = &root->dotdot; in make_indexed_dir()
2259 de = (struct ext4_dir_entry_2 *)((char *)fde + in make_indexed_dir()
2260 ext4_rec_len_from_disk(fde->rec_len, blocksize)); in make_indexed_dir()
2261 if ((char *) de >= (((char *) root) + blocksize)) { in make_indexed_dir()
2264 return -EFSCORRUPTED; in make_indexed_dir()
2266 len = ((char *) root) + (blocksize - csum_size) - (char *) de; in make_indexed_dir()
2275 data2 = bh2->b_data; in make_indexed_dir()
2277 memcpy(data2, de, len); in make_indexed_dir()
2278 memset(de, 0, len); /* wipe old data */ in make_indexed_dir()
2279 de = (struct ext4_dir_entry_2 *) data2; in make_indexed_dir()
2281 while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top) { in make_indexed_dir()
2282 if (ext4_check_dir_entry(dir, NULL, de, bh2, data2, len, in make_indexed_dir()
2283 (data2 + (blocksize - csum_size) - in make_indexed_dir()
2284 (char *) de))) { in make_indexed_dir()
2287 return -EFSCORRUPTED; in make_indexed_dir()
2289 de = de2; in make_indexed_dir()
2291 de->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) - in make_indexed_dir()
2292 (char *) de, blocksize); in make_indexed_dir()
2298 de = (struct ext4_dir_entry_2 *) (&root->dotdot); in make_indexed_dir()
2299 de->rec_len = ext4_rec_len_to_disk( in make_indexed_dir()
2300 blocksize - ext4_dir_rec_len(2, NULL), blocksize); in make_indexed_dir()
2301 memset (&root->info, 0, sizeof(root->info)); in make_indexed_dir()
2302 root->info.info_length = sizeof(root->info); in make_indexed_dir()
2304 root->info.hash_version = DX_HASH_SIPHASH; in make_indexed_dir()
2306 root->info.hash_version = in make_indexed_dir()
2307 EXT4_SB(dir->i_sb)->s_def_hash_version; in make_indexed_dir()
2309 entries = root->entries; in make_indexed_dir()
2312 dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info))); in make_indexed_dir()
2315 fname->hinfo.hash_version = root->info.hash_version; in make_indexed_dir()
2316 if (fname->hinfo.hash_version <= DX_HASH_TEA) in make_indexed_dir()
2317 fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; in make_indexed_dir()
2318 fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; in make_indexed_dir()
2323 fname_len(fname), &fname->hinfo); in make_indexed_dir()
2332 frame->entries = entries; in make_indexed_dir()
2333 frame->at = entries; in make_indexed_dir()
2334 frame->bh = bh; in make_indexed_dir()
2336 retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh); in make_indexed_dir()
2343 de = do_split(handle,dir, &bh2, frame, &fname->hinfo); in make_indexed_dir()
2344 if (IS_ERR(de)) { in make_indexed_dir()
2345 retval = PTR_ERR(de); in make_indexed_dir()
2349 retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2); in make_indexed_dir()
2369 * NOTE!! The inode part of 'de' is left at 0 - which means you
2376 struct inode *dir = d_inode(dentry->d_parent); in ext4_add_entry()
2378 struct ext4_dir_entry_2 *de; in ext4_add_entry() local
2387 if (ext4_has_metadata_csum(inode->i_sb)) in ext4_add_entry()
2390 sb = dir->i_sb; in ext4_add_entry()
2391 blocksize = sb->s_blocksize; in ext4_add_entry()
2392 if (!dentry->d_name.len) in ext4_add_entry()
2393 return -EINVAL; in ext4_add_entry()
2396 return -ENOKEY; in ext4_add_entry()
2400 utf8_validate(sb->s_encoding, &dentry->d_name)) in ext4_add_entry()
2401 return -EINVAL; in ext4_add_entry()
2404 retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname); in ext4_add_entry()
2426 retval = -EFSCORRUPTED; in ext4_add_entry()
2435 blocks = dir->i_size >> sb->s_blocksize_bits; in ext4_add_entry()
2450 if (retval != -ENOSPC) in ext4_add_entry()
2469 de = (struct ext4_dir_entry_2 *) bh->b_data; in ext4_add_entry()
2470 de->inode = 0; in ext4_add_entry()
2471 de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize); in ext4_add_entry()
2476 retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh); in ext4_add_entry()
2494 struct super_block *sb = dir->i_sb; in ext4_dx_add_entry()
2495 struct ext4_dir_entry_2 *de; in ext4_dx_add_entry() local
2504 entries = frame->entries; in ext4_dx_add_entry()
2505 at = frame->at; in ext4_dx_add_entry()
2506 bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE); in ext4_dx_add_entry()
2519 if (err != -ENOSPC) in ext4_dx_add_entry()
2529 int levels = frame - frames + 1; in ext4_dx_add_entry()
2537 if (dx_get_count((frame - 1)->entries) < in ext4_dx_add_entry()
2538 dx_get_limit((frame - 1)->entries)) { in ext4_dx_add_entry()
2542 frame--; /* split higher index block */ in ext4_dx_add_entry()
2543 at = frame->at; in ext4_dx_add_entry()
2544 entries = frame->entries; in ext4_dx_add_entry()
2550 dir->i_ino, levels); in ext4_dx_add_entry()
2556 err = -ENOSPC; in ext4_dx_add_entry()
2565 node2 = (struct dx_node *)(bh2->b_data); in ext4_dx_add_entry()
2566 entries2 = node2->entries; in ext4_dx_add_entry()
2567 memset(&node2->fake, 0, sizeof(struct fake_dirent)); in ext4_dx_add_entry()
2568 node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize, in ext4_dx_add_entry()
2569 sb->s_blocksize); in ext4_dx_add_entry()
2570 BUFFER_TRACE(frame->bh, "get_write_access"); in ext4_dx_add_entry()
2571 err = ext4_journal_get_write_access(handle, sb, frame->bh, in ext4_dx_add_entry()
2576 unsigned icount1 = icount/2, icount2 = icount - icount1; in ext4_dx_add_entry()
2581 BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */ in ext4_dx_add_entry()
2583 (frame - 1)->bh, in ext4_dx_add_entry()
2595 if (at - entries >= icount1) { in ext4_dx_add_entry()
2596 frame->at = at - entries - icount1 + entries2; in ext4_dx_add_entry()
2597 frame->entries = entries = entries2; in ext4_dx_add_entry()
2598 swap(frame->bh, bh2); in ext4_dx_add_entry()
2600 dx_insert_block((frame - 1), hash2, newblock); in ext4_dx_add_entry()
2601 dxtrace(dx_show_index("node", frame->entries)); in ext4_dx_add_entry()
2603 ((struct dx_node *) bh2->b_data)->entries)); in ext4_dx_add_entry()
2609 (frame - 1)->bh); in ext4_dx_add_entry()
2613 frame->bh); in ext4_dx_add_entry()
2625 dxroot = (struct dx_root *)frames[0].bh->b_data; in ext4_dx_add_entry()
2626 dxroot->info.indirect_levels += 1; in ext4_dx_add_entry()
2629 dxroot->info.indirect_levels)); in ext4_dx_add_entry()
2630 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh); in ext4_dx_add_entry()
2639 de = do_split(handle, dir, &bh, frame, &fname->hinfo); in ext4_dx_add_entry()
2640 if (IS_ERR(de)) { in ext4_dx_add_entry()
2641 err = PTR_ERR(de); in ext4_dx_add_entry()
2644 err = add_dirent_to_buf(handle, fname, dir, inode, de, bh); in ext4_dx_add_entry()
2648 ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */ in ext4_dx_add_entry()
2652 /* @restart is true means htree-path has been changed, we need to in ext4_dx_add_entry()
2653 * repeat dx_probe() to find out valid htree-path in ext4_dx_add_entry()
2671 struct ext4_dir_entry_2 *de, *pde; in ext4_generic_delete_entry() local
2672 unsigned int blocksize = dir->i_sb->s_blocksize; in ext4_generic_delete_entry()
2677 de = entry_buf; in ext4_generic_delete_entry()
2678 while (i < buf_size - csum_size) { in ext4_generic_delete_entry()
2679 if (ext4_check_dir_entry(dir, NULL, de, bh, in ext4_generic_delete_entry()
2681 return -EFSCORRUPTED; in ext4_generic_delete_entry()
2682 if (de == de_del) { in ext4_generic_delete_entry()
2684 pde->rec_len = ext4_rec_len_to_disk( in ext4_generic_delete_entry()
2685 ext4_rec_len_from_disk(pde->rec_len, in ext4_generic_delete_entry()
2687 ext4_rec_len_from_disk(de->rec_len, in ext4_generic_delete_entry()
2692 memset(de, 0, ext4_rec_len_from_disk(de->rec_len, in ext4_generic_delete_entry()
2696 de->inode = 0; in ext4_generic_delete_entry()
2697 memset(&de->name_len, 0, in ext4_generic_delete_entry()
2698 ext4_rec_len_from_disk(de->rec_len, in ext4_generic_delete_entry()
2699 blocksize) - in ext4_generic_delete_entry()
2707 i += ext4_rec_len_from_disk(de->rec_len, blocksize); in ext4_generic_delete_entry()
2708 pde = de; in ext4_generic_delete_entry()
2709 de = ext4_next_entry(de, blocksize); in ext4_generic_delete_entry()
2711 return -ENOENT; in ext4_generic_delete_entry()
2729 if (ext4_has_metadata_csum(dir->i_sb)) in ext4_delete_entry()
2733 err = ext4_journal_get_write_access(handle, dir->i_sb, bh, in ext4_delete_entry()
2738 err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data, in ext4_delete_entry()
2739 dir->i_sb->s_blocksize, csum_size); in ext4_delete_entry()
2750 if (err != -ENOENT) in ext4_delete_entry()
2751 ext4_std_error(dir->i_sb, err); in ext4_delete_entry()
2758 * the 16-bit i_links_count field on disk. Directories with i_nlink == 1 mean
2762 * feature is not enabled and returned -EMLINK. The is_dx() check is a proxy
2763 * for checking S_ISDIR(inode) (since the INODE_INDEX feature will not be set
2764 * on regular files) and to avoid creating huge/slow non-HTREE directories.
2770 (inode->i_nlink > EXT4_LINK_MAX || inode->i_nlink == 2)) in ext4_inc_count()
2775 * If a directory had nlink == 1, then we should let it be 1. This indicates
2780 if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2) in ext4_dec_count()
2786 * Add non-directory inode to a directory. On success, the inode reference is
2794 struct inode *dir = d_inode(dentry->d_parent); in ext4_add_nondir()
2815 * is so far negative - it has no inode.
2831 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_create()
2834 inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name, in ext4_create()
2839 inode->i_op = &ext4_file_inode_operations; in ext4_create()
2840 inode->i_fop = &ext4_file_operations; in ext4_create()
2850 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_create()
2866 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_mknod()
2869 inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name, in ext4_mknod()
2874 init_special_inode(inode, inode->i_mode, rdev); in ext4_mknod()
2875 inode->i_op = &ext4_special_inode_operations; in ext4_mknod()
2884 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_mknod()
2904 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + in ext4_tmpfile()
2909 inode->i_op = &ext4_file_inode_operations; in ext4_tmpfile()
2910 inode->i_fop = &ext4_file_operations; in ext4_tmpfile()
2921 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_tmpfile()
2931 struct ext4_dir_entry_2 *de, in ext4_init_dot_dotdot() argument
2935 de->inode = cpu_to_le32(inode->i_ino); in ext4_init_dot_dotdot()
2936 de->name_len = 1; in ext4_init_dot_dotdot()
2937 de->rec_len = ext4_rec_len_to_disk(ext4_dir_rec_len(de->name_len, NULL), in ext4_init_dot_dotdot()
2939 strcpy(de->name, "."); in ext4_init_dot_dotdot()
2940 ext4_set_de_type(inode->i_sb, de, S_IFDIR); in ext4_init_dot_dotdot()
2942 de = ext4_next_entry(de, blocksize); in ext4_init_dot_dotdot()
2943 de->inode = cpu_to_le32(parent_ino); in ext4_init_dot_dotdot()
2944 de->name_len = 2; in ext4_init_dot_dotdot()
2946 de->rec_len = ext4_rec_len_to_disk(blocksize - in ext4_init_dot_dotdot()
2950 de->rec_len = ext4_rec_len_to_disk( in ext4_init_dot_dotdot()
2951 ext4_dir_rec_len(de->name_len, NULL), in ext4_init_dot_dotdot()
2953 strcpy(de->name, ".."); in ext4_init_dot_dotdot()
2954 ext4_set_de_type(inode->i_sb, de, S_IFDIR); in ext4_init_dot_dotdot()
2956 return ext4_next_entry(de, blocksize); in ext4_init_dot_dotdot()
2963 struct ext4_dir_entry_2 *de; in ext4_init_new_dir() local
2965 unsigned int blocksize = dir->i_sb->s_blocksize; in ext4_init_new_dir()
2969 if (ext4_has_metadata_csum(dir->i_sb)) in ext4_init_new_dir()
2974 if (err < 0 && err != -ENOSPC) in ext4_init_new_dir()
2980 inode->i_size = 0; in ext4_init_new_dir()
2984 de = (struct ext4_dir_entry_2 *)dir_block->b_data; in ext4_init_new_dir()
2985 ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0); in ext4_init_new_dir()
3008 return -EMLINK; in ext4_mkdir()
3014 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_mkdir()
3018 &dentry->d_name, in ext4_mkdir()
3025 inode->i_op = &ext4_dir_inode_operations; in ext4_mkdir()
3026 inode->i_fop = &ext4_dir_operations; in ext4_mkdir()
3060 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_mkdir()
3072 struct ext4_dir_entry_2 *de; in ext4_empty_dir() local
3084 sb = inode->i_sb; in ext4_empty_dir()
3085 if (inode->i_size < ext4_dir_rec_len(1, NULL) + in ext4_empty_dir()
3090 /* The first directory block must not be a hole, in ext4_empty_dir()
3097 de = (struct ext4_dir_entry_2 *) bh->b_data; in ext4_empty_dir()
3098 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size, in ext4_empty_dir()
3100 le32_to_cpu(de->inode) != inode->i_ino || strcmp(".", de->name)) { in ext4_empty_dir()
3105 offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize); in ext4_empty_dir()
3106 de = ext4_next_entry(de, sb->s_blocksize); in ext4_empty_dir()
3107 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size, in ext4_empty_dir()
3109 le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) { in ext4_empty_dir()
3114 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize); in ext4_empty_dir()
3115 while (offset < inode->i_size) { in ext4_empty_dir()
3116 if (!(offset & (sb->s_blocksize - 1))) { in ext4_empty_dir()
3122 offset += sb->s_blocksize; in ext4_empty_dir()
3128 de = (struct ext4_dir_entry_2 *) (bh->b_data + in ext4_empty_dir()
3129 (offset & (sb->s_blocksize - 1))); in ext4_empty_dir()
3130 if (ext4_check_dir_entry(inode, NULL, de, bh, in ext4_empty_dir()
3131 bh->b_data, bh->b_size, offset) || in ext4_empty_dir()
3132 le32_to_cpu(de->inode)) { in ext4_empty_dir()
3136 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize); in ext4_empty_dir()
3147 struct ext4_dir_entry_2 *de; in ext4_rmdir() local
3150 if (unlikely(ext4_forced_shutdown(dir->i_sb))) in ext4_rmdir()
3151 return -EIO; in ext4_rmdir()
3162 retval = -ENOENT; in ext4_rmdir()
3163 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL); in ext4_rmdir()
3171 retval = -EFSCORRUPTED; in ext4_rmdir()
3172 if (le32_to_cpu(de->inode) != inode->i_ino) in ext4_rmdir()
3175 retval = -ENOTEMPTY; in ext4_rmdir()
3180 EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); in ext4_rmdir()
3190 retval = ext4_delete_entry(handle, dir, de, bh); in ext4_rmdir()
3196 dentry->d_name.len, dentry->d_name.name, in ext4_rmdir()
3197 inode->i_nlink); in ext4_rmdir()
3203 inode->i_size = 0; in ext4_rmdir()
3205 dir->i_mtime = inode_set_ctime_current(dir); in ext4_rmdir()
3217 * Case-insensitiveness. Eventually we'll want avoid in ext4_rmdir()
3237 int retval = -ENOENT; in __ext4_unlink()
3239 struct ext4_dir_entry_2 *de; in __ext4_unlink() local
3245 * directory's encryption key, which isn't GFP_NOFS-safe. in __ext4_unlink()
3247 bh = ext4_find_entry(dir, d_name, &de, NULL); in __ext4_unlink()
3252 return -ENOENT; in __ext4_unlink()
3254 if (le32_to_cpu(de->inode) != inode->i_ino) { in __ext4_unlink()
3260 if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY) in __ext4_unlink()
3267 EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); in __ext4_unlink()
3277 retval = ext4_delete_entry(handle, dir, de, bh); in __ext4_unlink()
3280 dir->i_mtime = inode_set_ctime_current(dir); in __ext4_unlink()
3288 if (inode->i_nlink == 0) in __ext4_unlink()
3290 d_name->len, d_name->name); in __ext4_unlink()
3293 if (!inode->i_nlink) in __ext4_unlink()
3310 if (unlikely(ext4_forced_shutdown(dir->i_sb))) in ext4_unlink()
3311 return -EIO; in ext4_unlink()
3325 retval = __ext4_unlink(dir, &dentry->d_name, d_inode(dentry), dentry); in ext4_unlink()
3328 * Case-insensitiveness. Eventually we'll want avoid in ext4_unlink()
3354 err = ext4_journal_get_write_access(handle, inode->i_sb, bh, EXT4_JTR_NONE); in ext4_init_symlink_block()
3358 kaddr = (char *)bh->b_data; in ext4_init_symlink_block()
3359 memcpy(kaddr, disk_link->name, disk_link->len); in ext4_init_symlink_block()
3360 inode->i_size = disk_link->len - 1; in ext4_init_symlink_block()
3361 EXT4_I(inode)->i_disksize = inode->i_size; in ext4_init_symlink_block()
3378 if (unlikely(ext4_forced_shutdown(dir->i_sb))) in ext4_symlink()
3379 return -EIO; in ext4_symlink()
3381 err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize, in ext4_symlink()
3396 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_symlink()
3400 &dentry->d_name, 0, NULL, in ext4_symlink()
3414 inode->i_op = &ext4_encrypted_symlink_inode_operations; in ext4_symlink()
3417 inode->i_op = &ext4_symlink_inode_operations; in ext4_symlink()
3419 inode->i_op = &ext4_fast_symlink_inode_operations; in ext4_symlink()
3420 inode->i_link = (char *)&EXT4_I(inode)->i_data; in ext4_symlink()
3432 memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name, in ext4_symlink()
3434 inode->i_size = disk_link.len - 1; in ext4_symlink()
3435 EXT4_I(inode)->i_disksize = inode->i_size; in ext4_symlink()
3452 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_symlink()
3465 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in __ext4_link()
3483 if (inode->i_nlink == 1) in __ext4_link()
3492 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in __ext4_link()
3503 if (inode->i_nlink >= EXT4_LINK_MAX) in ext4_link()
3504 return -EMLINK; in ext4_link()
3511 (!projid_eq(EXT4_I(dir)->i_projid, in ext4_link()
3512 EXT4_I(old_dentry->d_inode)->i_projid))) in ext4_link()
3513 return -EXDEV; in ext4_link()
3523 * It should be the inode block if it is inlined or the 1st block
3535 struct ext4_dir_entry_2 *de; in ext4_get_first_dir_block() local
3538 /* The first directory block must not be a hole, so in ext4_get_first_dir_block()
3547 de = (struct ext4_dir_entry_2 *) bh->b_data; in ext4_get_first_dir_block()
3548 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, in ext4_get_first_dir_block()
3549 bh->b_size, 0) || in ext4_get_first_dir_block()
3550 le32_to_cpu(de->inode) != inode->i_ino || in ext4_get_first_dir_block()
3551 strcmp(".", de->name)) { in ext4_get_first_dir_block()
3554 *retval = -EFSCORRUPTED; in ext4_get_first_dir_block()
3557 offset = ext4_rec_len_from_disk(de->rec_len, in ext4_get_first_dir_block()
3558 inode->i_sb->s_blocksize); in ext4_get_first_dir_block()
3559 de = ext4_next_entry(de, inode->i_sb->s_blocksize); in ext4_get_first_dir_block()
3560 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, in ext4_get_first_dir_block()
3561 bh->b_size, offset) || in ext4_get_first_dir_block()
3562 le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) { in ext4_get_first_dir_block()
3565 *retval = -EFSCORRUPTED; in ext4_get_first_dir_block()
3568 *parent_de = de; in ext4_get_first_dir_block()
3586 struct ext4_dir_entry_2 *de; member
3599 ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode, in ext4_rename_dir_prepare()
3600 &retval, &ent->parent_de, in ext4_rename_dir_prepare()
3601 &ent->dir_inlined); in ext4_rename_dir_prepare()
3602 if (!ent->dir_bh) in ext4_rename_dir_prepare()
3604 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino) in ext4_rename_dir_prepare()
3605 return -EFSCORRUPTED; in ext4_rename_dir_prepare()
3606 BUFFER_TRACE(ent->dir_bh, "get_write_access"); in ext4_rename_dir_prepare()
3607 return ext4_journal_get_write_access(handle, ent->dir->i_sb, in ext4_rename_dir_prepare()
3608 ent->dir_bh, EXT4_JTR_NONE); in ext4_rename_dir_prepare()
3616 ent->parent_de->inode = cpu_to_le32(dir_ino); in ext4_rename_dir_finish()
3617 BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata"); in ext4_rename_dir_finish()
3618 if (!ent->dir_inlined) { in ext4_rename_dir_finish()
3619 if (is_dx(ent->inode)) { in ext4_rename_dir_finish()
3621 ent->inode, in ext4_rename_dir_finish()
3622 ent->dir_bh); in ext4_rename_dir_finish()
3624 retval = ext4_handle_dirty_dirblock(handle, ent->inode, in ext4_rename_dir_finish()
3625 ent->dir_bh); in ext4_rename_dir_finish()
3628 retval = ext4_mark_inode_dirty(handle, ent->inode); in ext4_rename_dir_finish()
3631 ext4_std_error(ent->dir->i_sb, retval); in ext4_rename_dir_finish()
3642 BUFFER_TRACE(ent->bh, "get write access"); in ext4_setent()
3643 retval = ext4_journal_get_write_access(handle, ent->dir->i_sb, ent->bh, in ext4_setent()
3647 ent->de->inode = cpu_to_le32(ino); in ext4_setent()
3648 if (ext4_has_feature_filetype(ent->dir->i_sb)) in ext4_setent()
3649 ent->de->file_type = file_type; in ext4_setent()
3650 inode_inc_iversion(ent->dir); in ext4_setent()
3651 ent->dir->i_mtime = inode_set_ctime_current(ent->dir); in ext4_setent()
3652 retval = ext4_mark_inode_dirty(handle, ent->dir); in ext4_setent()
3653 BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata"); in ext4_setent()
3654 if (!ent->inlined) { in ext4_setent()
3655 retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh); in ext4_setent()
3657 ext4_std_error(ent->dir->i_sb, retval2); in ext4_setent()
3671 * old->de could have moved from under us during make indexed dir, in ext4_resetent()
3672 * so the old->de may no longer valid and need to find it again in ext4_resetent()
3675 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, in ext4_resetent()
3680 retval = -ENOENT; in ext4_resetent()
3682 ext4_std_error(old.dir->i_sb, retval); in ext4_resetent()
3693 int retval = -ENOENT; in ext4_find_delete_entry()
3695 struct ext4_dir_entry_2 *de; in ext4_find_delete_entry() local
3697 bh = ext4_find_entry(dir, d_name, &de, NULL); in ext4_find_delete_entry()
3701 retval = ext4_delete_entry(handle, dir, de, bh); in ext4_find_delete_entry()
3712 * ent->de could have moved from under us during htree split, so make in ext4_rename_delete()
3713 * sure that we are deleting the right entry. We might also be pointing in ext4_rename_delete()
3714 * to a stale entry in the unused part of ent->bh so just checking inum in ext4_rename_delete()
3717 if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino || in ext4_rename_delete()
3718 ent->de->name_len != ent->dentry->d_name.len || in ext4_rename_delete()
3719 strncmp(ent->de->name, ent->dentry->d_name.name, in ext4_rename_delete()
3720 ent->de->name_len) || in ext4_rename_delete()
3722 retval = ext4_find_delete_entry(handle, ent->dir, in ext4_rename_delete()
3723 &ent->dentry->d_name); in ext4_rename_delete()
3725 retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh); in ext4_rename_delete()
3726 if (retval == -ENOENT) { in ext4_rename_delete()
3727 retval = ext4_find_delete_entry(handle, ent->dir, in ext4_rename_delete()
3728 &ent->dentry->d_name); in ext4_rename_delete()
3733 ext4_warning_inode(ent->dir, in ext4_rename_delete()
3735 ent->dir->i_nlink, retval); in ext4_rename_delete()
3741 if (ent->dir_nlink_delta) { in ext4_update_dir_count()
3742 if (ent->dir_nlink_delta == -1) in ext4_update_dir_count()
3743 ext4_dec_count(ent->dir); in ext4_update_dir_count()
3745 ext4_inc_count(ent->dir); in ext4_update_dir_count()
3746 ext4_mark_inode_dirty(handle, ent->dir); in ext4_update_dir_count()
3762 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) + in ext4_whiteout_for_rename()
3765 wh = ext4_new_inode_start_handle(idmap, ent->dir, in ext4_whiteout_for_rename()
3767 &ent->dentry->d_name, 0, NULL, in ext4_whiteout_for_rename()
3774 if (PTR_ERR(wh) == -ENOSPC && in ext4_whiteout_for_rename()
3775 ext4_should_retry_alloc(ent->dir->i_sb, &retries)) in ext4_whiteout_for_rename()
3779 init_special_inode(wh, wh->i_mode, WHITEOUT_DEV); in ext4_whiteout_for_rename()
3780 wh->i_op = &ext4_special_inode_operations; in ext4_whiteout_for_rename()
3787 * higher-level routines.
3814 if (new.inode && new.inode->i_nlink == 0) { in ext4_rename()
3817 return -EFSCORRUPTED; in ext4_rename()
3821 (!projid_eq(EXT4_I(new_dir)->i_projid, in ext4_rename()
3822 EXT4_I(old_dentry->d_inode)->i_projid))) in ext4_rename()
3823 return -EXDEV; in ext4_rename()
3843 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, in ext4_rename()
3852 * same name. Goodbye sticky bit ;-< in ext4_rename()
3854 retval = -ENOENT; in ext4_rename()
3855 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino) in ext4_rename()
3858 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name, in ext4_rename()
3859 &new.de, &new.inlined); in ext4_rename()
3871 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC)) in ext4_rename()
3874 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + in ext4_rename()
3890 old_file_type = old.de->file_type; in ext4_rename()
3894 if (S_ISDIR(old.inode->i_mode)) { in ext4_rename()
3896 retval = -ENOTEMPTY; in ext4_rename()
3900 retval = -EMLINK; in ext4_rename()
3912 * re-read the directory, or else we end up trying to delete a dirent in ext4_rename()
3915 force_reread = (new.dir->i_ino == old.dir->i_ino && in ext4_rename()
3921 * to be still pointing to the valid old entry. in ext4_rename()
3923 retval = ext4_setent(handle, &old, whiteout->i_ino, in ext4_rename()
3938 old.inode->i_ino, old_file_type); in ext4_rename()
3966 old.dir->i_mtime = inode_set_ctime_current(old.dir); in ext4_rename()
3969 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino); in ext4_rename()
3976 * parent, ext4_dec_count() won't work for many-linked in ext4_rename()
3991 if (S_ISDIR(old.inode->i_mode)) { in ext4_rename()
3997 ext4_fc_mark_ineligible(old.inode->i_sb, in ext4_rename()
4000 struct super_block *sb = old.inode->i_sb; in ext4_rename()
4005 !(EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY) && in ext4_rename()
4019 if (!new.inode->i_nlink) in ext4_rename()
4028 old.inode->i_ino, old_file_type); in ext4_rename()
4065 !projid_eq(EXT4_I(new_dir)->i_projid, in ext4_cross_rename()
4066 EXT4_I(old_dentry->d_inode)->i_projid)) || in ext4_cross_rename()
4068 !projid_eq(EXT4_I(old_dir)->i_projid, in ext4_cross_rename()
4069 EXT4_I(new_dentry->d_inode)->i_projid))) in ext4_cross_rename()
4070 return -EXDEV; in ext4_cross_rename()
4079 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, in ext4_cross_rename()
4080 &old.de, &old.inlined); in ext4_cross_rename()
4087 * same name. Goodbye sticky bit ;-< in ext4_cross_rename()
4089 retval = -ENOENT; in ext4_cross_rename()
4090 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino) in ext4_cross_rename()
4093 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name, in ext4_cross_rename()
4094 &new.de, &new.inlined); in ext4_cross_rename()
4102 if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino) in ext4_cross_rename()
4106 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + in ext4_cross_rename()
4117 if (S_ISDIR(old.inode->i_mode)) { in ext4_cross_rename()
4123 if (S_ISDIR(new.inode->i_mode)) { in ext4_cross_rename()
4132 * nlink only needs to be modified if this is a cross directory rename. in ext4_cross_rename()
4135 old.dir_nlink_delta = old.is_dir ? -1 : 1; in ext4_cross_rename()
4136 new.dir_nlink_delta = -old.dir_nlink_delta; in ext4_cross_rename()
4137 retval = -EMLINK; in ext4_cross_rename()
4143 new_file_type = new.de->file_type; in ext4_cross_rename()
4144 retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type); in ext4_cross_rename()
4148 retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type); in ext4_cross_rename()
4164 ext4_fc_mark_ineligible(new.inode->i_sb, in ext4_cross_rename()
4167 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino); in ext4_cross_rename()
4172 retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino); in ext4_cross_rename()
4197 if (unlikely(ext4_forced_shutdown(old_dir->i_sb))) in ext4_rename2()
4198 return -EIO; in ext4_rename2()
4201 return -EINVAL; in ext4_rename2()