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 ext4_std_error(inode->i_sb, err); in ext4_append()
103 * block being read to be an index block, or a block containing
108 * the caller doesn't know what kind of directory block will be read,
109 * so no specific verification will be done.
128 if (block >= inode->i_size >> inode->i_blkbits) { in __ext4_read_dirblock()
131 block, inode->i_size); in __ext4_read_dirblock()
132 return ERR_PTR(-EFSCORRUPTED); in __ext4_read_dirblock()
135 if (ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_EIO)) in __ext4_read_dirblock()
136 bh = ERR_PTR(-EIO); in __ext4_read_dirblock()
140 __ext4_warning(inode->i_sb, func, line, in __ext4_read_dirblock()
143 inode->i_ino, (unsigned long)block, in __ext4_read_dirblock()
144 current->comm, PTR_ERR(bh)); in __ext4_read_dirblock()
152 return ERR_PTR(-EFSCORRUPTED); in __ext4_read_dirblock()
156 dirent = (struct ext4_dir_entry *) bh->b_data; in __ext4_read_dirblock()
161 else if (ext4_rec_len_from_disk(dirent->rec_len, in __ext4_read_dirblock()
162 inode->i_sb->s_blocksize) == in __ext4_read_dirblock()
163 inode->i_sb->s_blocksize) in __ext4_read_dirblock()
170 return ERR_PTR(-EFSCORRUPTED); in __ext4_read_dirblock()
172 if (!ext4_has_metadata_csum(inode->i_sb) || in __ext4_read_dirblock()
179 * caller is sure it should be an index block. in __ext4_read_dirblock()
183 !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC)) in __ext4_read_dirblock()
190 return ERR_PTR(-EFSBADCRC); in __ext4_read_dirblock()
195 !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC)) in __ext4_read_dirblock()
202 return ERR_PTR(-EFSBADCRC); in __ext4_read_dirblock()
240 * dirent the two low bits of the hash version will be zero. Therefore, the
241 * hash version mod 4 should never be 0. Sincerely, the paranoia department.
329 struct ext4_dir_entry_tail *t = EXT4_DIRENT_TAIL(bh->b_data, blocksize); in ext4_initialize_dirent_tail()
332 t->det_rec_len = ext4_rec_len_to_disk( in ext4_initialize_dirent_tail()
334 t->det_reserved_ft = EXT4_FT_DIR_CSUM; in ext4_initialize_dirent_tail()
342 int blocksize = EXT4_BLOCK_SIZE(inode->i_sb); in get_dirent_tail()
347 d = (struct ext4_dir_entry *)bh->b_data; in get_dirent_tail()
348 top = (struct ext4_dir_entry *)(bh->b_data + in get_dirent_tail()
349 (blocksize - sizeof(struct ext4_dir_entry_tail))); in get_dirent_tail()
350 while (d < top && ext4_rec_len_from_disk(d->rec_len, blocksize)) in get_dirent_tail()
352 ext4_rec_len_from_disk(d->rec_len, blocksize)); in get_dirent_tail()
359 t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb)); in get_dirent_tail()
362 if (t->det_reserved_zero1 || in get_dirent_tail()
363 (ext4_rec_len_from_disk(t->det_rec_len, blocksize) != in get_dirent_tail()
365 t->det_reserved_zero2 || in get_dirent_tail()
366 t->det_reserved_ft != EXT4_FT_DIR_CSUM) in get_dirent_tail()
374 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_dirblock_csum()
378 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size); in ext4_dirblock_csum()
389 "No space for directory leaf checksum. Please run e2fsck -D."); in __warn_no_space_for_csum()
396 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dirblock_csum_verify()
405 if (t->det_checksum != ext4_dirblock_csum(inode, bh->b_data, in ext4_dirblock_csum_verify()
406 (char *)t - bh->b_data)) in ext4_dirblock_csum_verify()
417 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dirblock_csum_set()
426 t->det_checksum = ext4_dirblock_csum(inode, bh->b_data, in ext4_dirblock_csum_set()
427 (char *)t - bh->b_data); in ext4_dirblock_csum_set()
445 int blocksize = EXT4_BLOCK_SIZE(inode->i_sb); in get_dx_countlimit()
446 unsigned int rlen = ext4_rec_len_from_disk(dirent->rec_len, blocksize); in get_dx_countlimit()
452 if (ext4_rec_len_from_disk(dp->rec_len, blocksize) != blocksize - 12) in get_dx_countlimit()
455 if (root->reserved_zero || in get_dx_countlimit()
456 root->info_length != sizeof(struct dx_root_info)) in get_dx_countlimit()
470 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_dx_csum()
478 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size); in ext4_dx_csum()
492 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dx_csum_verify()
497 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D."); in ext4_dx_csum_verify()
500 limit = le16_to_cpu(c->limit); in ext4_dx_csum_verify()
501 count = le16_to_cpu(c->count); in ext4_dx_csum_verify()
503 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { in ext4_dx_csum_verify()
509 if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset, in ext4_dx_csum_verify()
521 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_dx_csum_set()
526 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D."); in ext4_dx_csum_set()
529 limit = le16_to_cpu(c->limit); in ext4_dx_csum_set()
530 count = le16_to_cpu(c->count); in ext4_dx_csum_set()
532 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { in ext4_dx_csum_set()
538 t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t); in ext4_dx_csum_set()
545 ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data); in ext4_handle_dirty_dx_node()
556 ext4_rec_len_from_disk(p->rec_len, blocksize)); in ext4_next_entry()
560 * Future: use high four bits of block for coalesce-on-delete flags
566 return le32_to_cpu(entry->block) & 0x0fffffff; in dx_get_block()
571 entry->block = cpu_to_le32(value); in dx_set_block()
576 return le32_to_cpu(entry->hash); in dx_get_hash()
581 entry->hash = cpu_to_le32(value); in dx_set_hash()
586 return le16_to_cpu(((struct dx_countlimit *) entries)->count); in dx_get_count()
591 return le16_to_cpu(((struct dx_countlimit *) entries)->limit); in dx_get_limit()
596 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value); in dx_set_count()
601 ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value); in dx_set_limit()
606 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) - in dx_root_limit()
607 EXT4_DIR_REC_LEN(2) - infosize; in dx_root_limit()
609 if (ext4_has_metadata_csum(dir->i_sb)) in dx_root_limit()
610 entry_space -= sizeof(struct dx_tail); in dx_root_limit()
616 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0); in dx_node_limit()
618 if (ext4_has_metadata_csum(dir->i_sb)) in dx_node_limit()
619 entry_space -= sizeof(struct dx_tail); in dx_node_limit()
632 printk(KERN_CONT " %x->%lu", in dx_show_index()
648 struct ext4_dir_entry_2 *de, in dx_show_leaf() argument
652 char *base = (char *) de; in dx_show_leaf()
656 while ((char *) de < base + size) in dx_show_leaf()
658 if (de->inode) in dx_show_leaf()
669 name = de->name; in dx_show_leaf()
670 len = de->name_len; in dx_show_leaf()
679 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()
711 ext4fs_dirhash(dir, de->name, in dx_show_leaf()
712 de->name_len, &h); in dx_show_leaf()
714 h.hash, (unsigned) ((char *) de in dx_show_leaf()
715 - base)); in dx_show_leaf()
720 int len = de->name_len; in dx_show_leaf()
721 char *name = de->name; in dx_show_leaf()
722 ext4fs_dirhash(dir, de->name, de->name_len, &h); in dx_show_leaf()
724 (unsigned) ((char *) de - base)); in dx_show_leaf()
727 space += EXT4_DIR_REC_LEN(de->name_len); in dx_show_leaf()
730 de = ext4_next_entry(de, size); in dx_show_leaf()
739 unsigned blocksize = dir->i_sb->s_blocksize; in dx_show_entries()
748 u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash; in dx_show_entries()
755 dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1): in dx_show_entries()
757 bh->b_data, blocksize, 0); in dx_show_entries()
794 frame->bh = ext4_read_dirblock(dir, 0, INDEX); in dx_probe()
795 if (IS_ERR(frame->bh)) in dx_probe()
796 return (struct dx_frame *) frame->bh; in dx_probe()
798 root = (struct dx_root *) frame->bh->b_data; in dx_probe()
799 if (root->info.hash_version != DX_HASH_TEA && in dx_probe()
800 root->info.hash_version != DX_HASH_HALF_MD4 && in dx_probe()
801 root->info.hash_version != DX_HASH_LEGACY) { in dx_probe()
803 root->info.hash_version); in dx_probe()
807 hinfo = &fname->hinfo; in dx_probe()
808 hinfo->hash_version = root->info.hash_version; in dx_probe()
809 if (hinfo->hash_version <= DX_HASH_TEA) in dx_probe()
810 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; in dx_probe()
811 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed; in dx_probe()
814 hash = hinfo->hash; in dx_probe()
816 if (root->info.unused_flags & 1) { in dx_probe()
818 root->info.unused_flags); in dx_probe()
822 indirect = root->info.indirect_levels; in dx_probe()
823 if (indirect >= ext4_dir_htree_level(dir->i_sb)) { in dx_probe()
824 ext4_warning(dir->i_sb, in dx_probe()
826 "supported value", dir->i_ino, in dx_probe()
827 ext4_dir_htree_level(dir->i_sb)); in dx_probe()
828 if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) { in dx_probe()
829 ext4_warning(dir->i_sb, "Enable large directory " in dx_probe()
835 entries = (struct dx_entry *)(((char *)&root->info) + in dx_probe()
836 root->info.info_length); in dx_probe()
839 root->info.info_length)) { in dx_probe()
842 dx_root_limit(dir, root->info.info_length)); in dx_probe()
859 q = entries + count - 1; in dx_probe()
861 m = p + (q - p) / 2; in dx_probe()
864 q = m - 1; in dx_probe()
870 unsigned n = count - 1; in dx_probe()
872 while (n--) in dx_probe()
877 at--; in dx_probe()
881 assert (at == p - 1); in dx_probe()
884 at = p - 1; in dx_probe()
885 dxtrace(printk(KERN_CONT " %x->%u\n", in dx_probe()
888 frame->entries = entries; in dx_probe()
889 frame->at = at; in dx_probe()
904 frame->bh = ext4_read_dirblock(dir, block, INDEX); in dx_probe()
905 if (IS_ERR(frame->bh)) { in dx_probe()
906 ret_err = (struct dx_frame *) frame->bh; in dx_probe()
907 frame->bh = NULL; in dx_probe()
911 entries = ((struct dx_node *) frame->bh->b_data)->entries; in dx_probe()
922 brelse(frame->bh); in dx_probe()
923 frame--; in dx_probe()
941 info = &((struct dx_root *)frames[0].bh->b_data)->info; in dx_release()
942 /* save local copy, "info" may be freed after brelse() */ in dx_release()
943 indirect_levels = info->indirect_levels; in dx_release()
955 * should be necessary. Whether or not the search is necessary is
966 * If start_hash is non-null, it will be filled in with the starting
985 * nodes need to be read. in ext4_htree_next_block()
988 if (++(p->at) < p->entries + dx_get_count(p->entries)) in ext4_htree_next_block()
993 p--; in ext4_htree_next_block()
1003 bhash = dx_get_hash(p->at); in ext4_htree_next_block()
1014 while (num_frames--) { in ext4_htree_next_block()
1015 bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX); in ext4_htree_next_block()
1019 brelse(p->bh); in ext4_htree_next_block()
1020 p->bh = bh; in ext4_htree_next_block()
1021 p->at = p->entries = ((struct dx_node *) bh->b_data)->entries; in ext4_htree_next_block()
1028 * This function fills a red-black tree with information from a
1038 struct ext4_dir_entry_2 *de, *top; in htree_dirblock_to_tree() local
1048 de = (struct ext4_dir_entry_2 *) bh->b_data; in htree_dirblock_to_tree()
1049 top = (struct ext4_dir_entry_2 *) ((char *) de + in htree_dirblock_to_tree()
1050 dir->i_sb->s_blocksize - in htree_dirblock_to_tree()
1067 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) { in htree_dirblock_to_tree()
1068 if (ext4_check_dir_entry(dir, NULL, de, bh, in htree_dirblock_to_tree()
1069 bh->b_data, bh->b_size, in htree_dirblock_to_tree()
1070 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb)) in htree_dirblock_to_tree()
1071 + ((char *)de - bh->b_data))) { in htree_dirblock_to_tree()
1075 ext4fs_dirhash(dir, de->name, de->name_len, hinfo); in htree_dirblock_to_tree()
1076 if ((hinfo->hash < start_hash) || in htree_dirblock_to_tree()
1077 ((hinfo->hash == start_hash) && in htree_dirblock_to_tree()
1078 (hinfo->minor_hash < start_minor_hash))) in htree_dirblock_to_tree()
1080 if (de->inode == 0) in htree_dirblock_to_tree()
1083 tmp_str.name = de->name; in htree_dirblock_to_tree()
1084 tmp_str.len = de->name_len; in htree_dirblock_to_tree()
1086 hinfo->hash, hinfo->minor_hash, de, in htree_dirblock_to_tree()
1090 struct fscrypt_str de_name = FSTR_INIT(de->name, in htree_dirblock_to_tree()
1091 de->name_len); in htree_dirblock_to_tree()
1094 err = fscrypt_fname_disk_to_usr(dir, hinfo->hash, in htree_dirblock_to_tree()
1095 hinfo->minor_hash, &de_name, in htree_dirblock_to_tree()
1102 hinfo->hash, hinfo->minor_hash, de, in htree_dirblock_to_tree()
1120 * This function fills a red-black tree with information from a
1131 struct ext4_dir_entry_2 *de; in ext4_htree_fill_tree() local
1144 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version; in ext4_htree_fill_tree()
1147 EXT4_SB(dir->i_sb)->s_hash_unsigned; in ext4_htree_fill_tree()
1148 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; in ext4_htree_fill_tree()
1173 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data; in ext4_htree_fill_tree()
1174 tmp_str.name = de->name; in ext4_htree_fill_tree()
1175 tmp_str.len = de->name_len; in ext4_htree_fill_tree()
1177 de, &tmp_str); in ext4_htree_fill_tree()
1183 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data; in ext4_htree_fill_tree()
1184 de = ext4_next_entry(de, dir->i_sb->s_blocksize); in ext4_htree_fill_tree()
1185 tmp_str.name = de->name; in ext4_htree_fill_tree()
1186 tmp_str.len = de->name_len; in ext4_htree_fill_tree()
1188 de, &tmp_str); in ext4_htree_fill_tree()
1196 err = -ERESTARTSYS; in ext4_htree_fill_tree()
1200 block = dx_get_block(frame->at); in ext4_htree_fill_tree()
1240 return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir, in search_dirblock()
1257 struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)bh->b_data; in dx_make_map() local
1258 unsigned int buflen = bh->b_size; in dx_make_map()
1259 char *base = bh->b_data; in dx_make_map()
1261 int blocksize = EXT4_BLOCK_SIZE(dir->i_sb); in dx_make_map()
1263 if (ext4_has_metadata_csum(dir->i_sb)) in dx_make_map()
1264 buflen -= sizeof(struct ext4_dir_entry_tail); in dx_make_map()
1266 while ((char *) de < base + buflen) { in dx_make_map()
1267 if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen, in dx_make_map()
1268 ((char *)de) - base)) in dx_make_map()
1269 return -EFSCORRUPTED; in dx_make_map()
1270 if (de->name_len && de->inode) { in dx_make_map()
1271 ext4fs_dirhash(dir, de->name, de->name_len, &h); in dx_make_map()
1272 map_tail--; in dx_make_map()
1273 map_tail->hash = h.hash; in dx_make_map()
1274 map_tail->offs = ((char *) de - base)>>2; in dx_make_map()
1275 map_tail->size = ext4_rec_len_from_disk(de->rec_len, in dx_make_map()
1280 de = ext4_next_entry(de, blocksize); in dx_make_map()
1288 struct dx_map_entry *p, *q, *top = map + count - 1; in dx_sort_map()
1293 if (count - 9 < 2) /* 9, 10 -> 11 */ in dx_sort_map()
1295 for (p = top, q = p - count; q >= map; p--, q--) in dx_sort_map()
1296 if (p->hash < q->hash) in dx_sort_map()
1303 while (q-- > map) { in dx_sort_map()
1314 struct dx_entry *entries = frame->entries; in dx_insert_block()
1315 struct dx_entry *old = frame->at, *new = old + 1; in dx_insert_block()
1320 memmove(new + 1, new, (char *)(entries + count) - (char *)(new)); in dx_insert_block()
1328 * Test whether a case-insensitive directory entry matches the filename
1338 const struct super_block *sb = parent->i_sb; in ext4_ci_compare()
1339 const struct unicode_map *um = sb->s_encoding; in ext4_ci_compare()
1352 return -EINVAL; in ext4_ci_compare()
1354 if (name->len != entry->len) in ext4_ci_compare()
1357 return !!memcmp(name->name, entry->name, name->len); in ext4_ci_compare()
1368 if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding) { in ext4_fname_setup_ci_filename()
1369 cf_name->name = NULL; in ext4_fname_setup_ci_filename()
1373 cf_name->name = kmalloc(EXT4_NAME_LEN, GFP_NOFS); in ext4_fname_setup_ci_filename()
1374 if (!cf_name->name) in ext4_fname_setup_ci_filename()
1377 len = utf8_casefold(dir->i_sb->s_encoding, in ext4_fname_setup_ci_filename()
1378 iname, cf_name->name, in ext4_fname_setup_ci_filename()
1381 kfree(cf_name->name); in ext4_fname_setup_ci_filename()
1382 cf_name->name = NULL; in ext4_fname_setup_ci_filename()
1385 cf_name->len = (unsigned) len; in ext4_fname_setup_ci_filename()
1397 const struct ext4_dir_entry_2 *de) in ext4_match() argument
1401 const struct qstr entry = {.name = de->name, .len = de->name_len}; in ext4_match()
1404 if (!de->inode) in ext4_match()
1407 f.usr_fname = fname->usr_fname; in ext4_match()
1408 f.disk_name = fname->disk_name; in ext4_match()
1410 f.crypto_buf = fname->crypto_buf; in ext4_match()
1414 if (parent->i_sb->s_encoding && IS_CASEFOLDED(parent)) { in ext4_match()
1415 if (fname->cf_name.name) { in ext4_match()
1416 struct qstr cf = {.name = fname->cf_name.name, in ext4_match()
1417 .len = fname->cf_name.len}; in ext4_match()
1420 return !ext4_ci_compare(parent, fname->usr_fname, &entry, in ext4_match()
1425 return fscrypt_match_name(&f, de->name, de->name_len); in ext4_match()
1429 * Returns 0 if not found, -1 on failure, and 1 on success
1435 struct ext4_dir_entry_2 * de; in ext4_search_dir() local
1439 de = (struct ext4_dir_entry_2 *)search_buf; in ext4_search_dir()
1441 while ((char *) de < dlimit - EXT4_BASE_DIR_LEN) { in ext4_search_dir()
1444 if (de->name + de->name_len <= dlimit && in ext4_search_dir()
1445 ext4_match(dir, fname, de)) { in ext4_search_dir()
1446 /* found a match - just to be sure, do in ext4_search_dir()
1448 if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf, in ext4_search_dir()
1450 return -1; in ext4_search_dir()
1451 *res_dir = de; in ext4_search_dir()
1455 de_len = ext4_rec_len_from_disk(de->rec_len, in ext4_search_dir()
1456 dir->i_sb->s_blocksize); in ext4_search_dir()
1458 return -1; in ext4_search_dir()
1460 de = (struct ext4_dir_entry_2 *) ((char *) de + de_len); in ext4_search_dir()
1466 struct ext4_dir_entry *de) in is_dx_internal_node() argument
1468 struct super_block *sb = dir->i_sb; in is_dx_internal_node()
1474 if (de->inode == 0 && in is_dx_internal_node()
1475 ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) == in is_dx_internal_node()
1476 sb->s_blocksize) in is_dx_internal_node()
1486 * itself (as a parameter - res_dir). It does NOT read the inode of the
1487 * entry - you'll have to do that yourself if you want to.
1489 * The returned buffer_head has ->b_count elevated. The caller is expected
1501 const u8 *name = fname->usr_fname->name; in __ext4_find_entry()
1510 sb = dir->i_sb; in __ext4_find_entry()
1511 namelen = fname->usr_fname->len; in __ext4_find_entry()
1528 * "." or ".." will only be in the first block in __ext4_find_entry()
1529 * NFS may look up ".."; "." should be handled by the VFS in __ext4_find_entry()
1548 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb); in __ext4_find_entry()
1553 start = EXT4_I(dir)->i_dir_start_lookup; in __ext4_find_entry()
1560 * We deal with the read-ahead logic here. in __ext4_find_entry()
1567 ra_max = start - block; in __ext4_find_entry()
1569 ra_max = nblocks - block; in __ext4_find_entry()
1587 ret = ERR_PTR(-EIO); in __ext4_find_entry()
1592 (struct ext4_dir_entry *)bh->b_data) && in __ext4_find_entry()
1598 ret = ERR_PTR(-EFSBADCRC); in __ext4_find_entry()
1605 EXT4_I(dir)->i_dir_start_lookup = block; in __ext4_find_entry()
1623 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb); in __ext4_find_entry()
1630 /* Clean up the read-ahead blocks */ in __ext4_find_entry()
1646 if (err == -ENOENT) in ext4_find_entry()
1666 if (err == -ENOENT) in ext4_lookup_entry()
1681 struct super_block * sb = dir->i_sb; in ext4_dx_find_entry()
1694 block = dx_get_block(frame->at); in ext4_dx_find_entry()
1705 if (retval == -1) { in ext4_dx_find_entry()
1711 retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame, in ext4_dx_find_entry()
1724 dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name)); in ext4_dx_find_entry()
1733 struct ext4_dir_entry_2 *de; in ext4_lookup() local
1736 if (dentry->d_name.len > EXT4_NAME_LEN) in ext4_lookup()
1737 return ERR_PTR(-ENAMETOOLONG); in ext4_lookup()
1739 bh = ext4_lookup_entry(dir, dentry, &de); in ext4_lookup()
1744 __u32 ino = le32_to_cpu(de->inode); in ext4_lookup()
1746 if (!ext4_valid_inum(dir->i_sb, ino)) { in ext4_lookup()
1748 return ERR_PTR(-EFSCORRUPTED); in ext4_lookup()
1750 if (unlikely(ino == dir->i_ino)) { in ext4_lookup()
1753 return ERR_PTR(-EFSCORRUPTED); in ext4_lookup()
1755 inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL); in ext4_lookup()
1756 if (inode == ERR_PTR(-ESTALE)) { in ext4_lookup()
1760 return ERR_PTR(-EFSCORRUPTED); in ext4_lookup()
1763 (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) && in ext4_lookup()
1765 ext4_warning(inode->i_sb, in ext4_lookup()
1767 dir->i_ino, inode->i_ino); in ext4_lookup()
1769 return ERR_PTR(-EPERM); in ext4_lookup()
1791 struct ext4_dir_entry_2 * de; in ext4_get_parent() local
1794 bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL); in ext4_get_parent()
1798 return ERR_PTR(-ENOENT); in ext4_get_parent()
1799 ino = le32_to_cpu(de->inode); in ext4_get_parent()
1802 if (!ext4_valid_inum(child->d_sb, ino)) { in ext4_get_parent()
1805 return ERR_PTR(-EFSCORRUPTED); in ext4_get_parent()
1808 return d_obtain_alias(ext4_iget(child->d_sb, ino, EXT4_IGET_NORMAL)); in ext4_get_parent()
1821 while (count--) { in dx_move_dirents()
1822 struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *) in dx_move_dirents() local
1823 (from + (map->offs<<2)); in dx_move_dirents()
1824 rec_len = EXT4_DIR_REC_LEN(de->name_len); in dx_move_dirents()
1825 memcpy (to, de, rec_len); in dx_move_dirents()
1826 ((struct ext4_dir_entry_2 *) to)->rec_len = in dx_move_dirents()
1830 de->inode = 0; in dx_move_dirents()
1831 memset(&de->name_len, 0, ext4_rec_len_from_disk(de->rec_len, in dx_move_dirents()
1832 blocksize) - in dx_move_dirents()
1839 return (struct ext4_dir_entry_2 *) (to - rec_len); in dx_move_dirents()
1848 struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base; in dx_pack_dirents() local
1851 prev = to = de; in dx_pack_dirents()
1852 while ((char*)de < base + blocksize) { in dx_pack_dirents()
1853 next = ext4_next_entry(de, blocksize); in dx_pack_dirents()
1854 if (de->inode && de->name_len) { in dx_pack_dirents()
1855 rec_len = EXT4_DIR_REC_LEN(de->name_len); in dx_pack_dirents()
1856 if (de > to) in dx_pack_dirents()
1857 memmove(to, de, rec_len); in dx_pack_dirents()
1858 to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize); in dx_pack_dirents()
1862 de = next; in dx_pack_dirents()
1870 * Returns pointer to de in block into which the new entry will be inserted.
1876 unsigned blocksize = dir->i_sb->s_blocksize; in do_split()
1883 char *data1 = (*bh)->b_data, *data2; in do_split()
1885 struct ext4_dir_entry_2 *de = NULL, *de2; in do_split() local
1889 if (ext4_has_metadata_csum(dir->i_sb)) in do_split()
1904 BUFFER_TRACE(frame->bh, "get_write_access"); in do_split()
1905 err = ext4_journal_get_write_access(handle, frame->bh); in do_split()
1909 data2 = bh2->b_data; in do_split()
1918 map -= count; in do_split()
1923 for (i = count-1; i >= 0; i--) { in do_split()
1938 split = count - move; in do_split()
1943 continued = hash2 == map[split - 1].hash; in do_split()
1945 (unsigned long)dx_get_block(frame->at), in do_split()
1946 hash2, split, count-split)); in do_split()
1949 de2 = dx_move_dirents(data1, data2, map + split, count - split, in do_split()
1951 de = dx_pack_dirents(data1, blocksize); in do_split()
1952 de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) - in do_split()
1953 (char *) de, in do_split()
1955 de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) - in do_split()
1969 if (hinfo->hash >= hash2) { in do_split()
1971 de = de2; in do_split()
1977 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh); in do_split()
1981 dxtrace(dx_show_index("frame", frame->entries)); in do_split()
1982 return de; in do_split()
1988 ext4_std_error(dir->i_sb, err); in do_split()
1998 struct ext4_dir_entry_2 *de; in ext4_find_dest_de() local
2004 de = (struct ext4_dir_entry_2 *)buf; in ext4_find_dest_de()
2005 top = buf + buf_size - reclen; in ext4_find_dest_de()
2006 while ((char *) de <= top) { in ext4_find_dest_de()
2007 if (ext4_check_dir_entry(dir, NULL, de, bh, in ext4_find_dest_de()
2009 return -EFSCORRUPTED; in ext4_find_dest_de()
2010 if (ext4_match(dir, fname, de)) in ext4_find_dest_de()
2011 return -EEXIST; in ext4_find_dest_de()
2012 nlen = EXT4_DIR_REC_LEN(de->name_len); in ext4_find_dest_de()
2013 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size); in ext4_find_dest_de()
2014 if ((de->inode ? rlen - nlen : rlen) >= reclen) in ext4_find_dest_de()
2016 de = (struct ext4_dir_entry_2 *)((char *)de + rlen); in ext4_find_dest_de()
2019 if ((char *) de > top) in ext4_find_dest_de()
2020 return -ENOSPC; in ext4_find_dest_de()
2022 *dest_de = de; in ext4_find_dest_de()
2027 struct ext4_dir_entry_2 *de, in ext4_insert_dentry() argument
2034 nlen = EXT4_DIR_REC_LEN(de->name_len); in ext4_insert_dentry()
2035 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size); in ext4_insert_dentry()
2036 if (de->inode) { in ext4_insert_dentry()
2038 (struct ext4_dir_entry_2 *)((char *)de + nlen); in ext4_insert_dentry()
2039 de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size); in ext4_insert_dentry()
2040 de->rec_len = ext4_rec_len_to_disk(nlen, buf_size); in ext4_insert_dentry()
2041 de = de1; in ext4_insert_dentry()
2043 de->file_type = EXT4_FT_UNKNOWN; in ext4_insert_dentry()
2044 de->inode = cpu_to_le32(inode->i_ino); in ext4_insert_dentry()
2045 ext4_set_de_type(inode->i_sb, de, inode->i_mode); in ext4_insert_dentry()
2046 de->name_len = fname_len(fname); in ext4_insert_dentry()
2047 memcpy(de->name, fname_name(fname), fname_len(fname)); in ext4_insert_dentry()
2051 * Add a new entry into a directory (leaf) block. If de is non-NULL,
2052 * it points to a directory entry which is guaranteed to be large
2053 * enough for new directory entry. If de is NULL, then
2055 * space. It will return -ENOSPC if no space is available, and -EIO
2056 * and -EEXIST if directory entry already exists.
2060 struct inode *inode, struct ext4_dir_entry_2 *de, in add_dirent_to_buf() argument
2063 unsigned int blocksize = dir->i_sb->s_blocksize; in add_dirent_to_buf()
2067 if (ext4_has_metadata_csum(inode->i_sb)) in add_dirent_to_buf()
2070 if (!de) { in add_dirent_to_buf()
2071 err = ext4_find_dest_de(dir, inode, bh, bh->b_data, in add_dirent_to_buf()
2072 blocksize - csum_size, fname, &de); in add_dirent_to_buf()
2079 ext4_std_error(dir->i_sb, err); in add_dirent_to_buf()
2084 ext4_insert_dentry(inode, de, blocksize, fname); in add_dirent_to_buf()
2097 dir->i_mtime = dir->i_ctime = current_time(dir); in add_dirent_to_buf()
2104 ext4_std_error(dir->i_sb, err); in add_dirent_to_buf()
2120 struct ext4_dir_entry_2 *de, *de2; in make_indexed_dir() local
2129 if (ext4_has_metadata_csum(inode->i_sb)) in make_indexed_dir()
2132 blocksize = dir->i_sb->s_blocksize; in make_indexed_dir()
2133 dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino)); in make_indexed_dir()
2137 ext4_std_error(dir->i_sb, retval); in make_indexed_dir()
2141 root = (struct dx_root *) bh->b_data; in make_indexed_dir()
2144 fde = &root->dotdot; in make_indexed_dir()
2145 de = (struct ext4_dir_entry_2 *)((char *)fde + in make_indexed_dir()
2146 ext4_rec_len_from_disk(fde->rec_len, blocksize)); in make_indexed_dir()
2147 if ((char *) de >= (((char *) root) + blocksize)) { in make_indexed_dir()
2150 return -EFSCORRUPTED; in make_indexed_dir()
2152 len = ((char *) root) + (blocksize - csum_size) - (char *) de; in make_indexed_dir()
2161 data2 = bh2->b_data; in make_indexed_dir()
2163 memcpy(data2, de, len); in make_indexed_dir()
2164 memset(de, 0, len); /* wipe old data */ in make_indexed_dir()
2165 de = (struct ext4_dir_entry_2 *) data2; in make_indexed_dir()
2167 while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top) { in make_indexed_dir()
2168 if (ext4_check_dir_entry(dir, NULL, de, bh2, data2, len, in make_indexed_dir()
2169 (data2 + (blocksize - csum_size) - in make_indexed_dir()
2170 (char *) de))) { in make_indexed_dir()
2173 return -EFSCORRUPTED; in make_indexed_dir()
2175 de = de2; in make_indexed_dir()
2177 de->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) - in make_indexed_dir()
2178 (char *) de, blocksize); in make_indexed_dir()
2184 de = (struct ext4_dir_entry_2 *) (&root->dotdot); in make_indexed_dir()
2185 de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2), in make_indexed_dir()
2187 memset (&root->info, 0, sizeof(root->info)); in make_indexed_dir()
2188 root->info.info_length = sizeof(root->info); in make_indexed_dir()
2189 root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version; in make_indexed_dir()
2190 entries = root->entries; in make_indexed_dir()
2193 dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info))); in make_indexed_dir()
2196 fname->hinfo.hash_version = root->info.hash_version; in make_indexed_dir()
2197 if (fname->hinfo.hash_version <= DX_HASH_TEA) in make_indexed_dir()
2198 fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; in make_indexed_dir()
2199 fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; in make_indexed_dir()
2200 ext4fs_dirhash(dir, fname_name(fname), fname_len(fname), &fname->hinfo); in make_indexed_dir()
2204 frame->entries = entries; in make_indexed_dir()
2205 frame->at = entries; in make_indexed_dir()
2206 frame->bh = bh; in make_indexed_dir()
2208 retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh); in make_indexed_dir()
2215 de = do_split(handle,dir, &bh2, frame, &fname->hinfo); in make_indexed_dir()
2216 if (IS_ERR(de)) { in make_indexed_dir()
2217 retval = PTR_ERR(de); in make_indexed_dir()
2221 retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2); in make_indexed_dir()
2241 * NOTE!! The inode part of 'de' is left at 0 - which means you
2248 struct inode *dir = d_inode(dentry->d_parent); in ext4_add_entry()
2250 struct ext4_dir_entry_2 *de; in ext4_add_entry() local
2259 if (ext4_has_metadata_csum(inode->i_sb)) in ext4_add_entry()
2262 sb = dir->i_sb; in ext4_add_entry()
2263 blocksize = sb->s_blocksize; in ext4_add_entry()
2264 if (!dentry->d_name.len) in ext4_add_entry()
2265 return -EINVAL; in ext4_add_entry()
2268 return -ENOKEY; in ext4_add_entry()
2272 sb->s_encoding && utf8_validate(sb->s_encoding, &dentry->d_name)) in ext4_add_entry()
2273 return -EINVAL; in ext4_add_entry()
2276 retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname); in ext4_add_entry()
2298 retval = -EFSCORRUPTED; in ext4_add_entry()
2307 blocks = dir->i_size >> sb->s_blocksize_bits; in ext4_add_entry()
2322 if (retval != -ENOSPC) in ext4_add_entry()
2341 de = (struct ext4_dir_entry_2 *) bh->b_data; in ext4_add_entry()
2342 de->inode = 0; in ext4_add_entry()
2343 de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize); in ext4_add_entry()
2348 retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh); in ext4_add_entry()
2366 struct super_block *sb = dir->i_sb; in ext4_dx_add_entry()
2367 struct ext4_dir_entry_2 *de; in ext4_dx_add_entry() local
2376 entries = frame->entries; in ext4_dx_add_entry()
2377 at = frame->at; in ext4_dx_add_entry()
2378 bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE); in ext4_dx_add_entry()
2391 if (err != -ENOSPC) in ext4_dx_add_entry()
2401 int levels = frame - frames + 1; in ext4_dx_add_entry()
2409 if (dx_get_count((frame - 1)->entries) < in ext4_dx_add_entry()
2410 dx_get_limit((frame - 1)->entries)) { in ext4_dx_add_entry()
2414 frame--; /* split higher index block */ in ext4_dx_add_entry()
2415 at = frame->at; in ext4_dx_add_entry()
2416 entries = frame->entries; in ext4_dx_add_entry()
2422 dir->i_ino, levels); in ext4_dx_add_entry()
2428 err = -ENOSPC; in ext4_dx_add_entry()
2437 node2 = (struct dx_node *)(bh2->b_data); in ext4_dx_add_entry()
2438 entries2 = node2->entries; in ext4_dx_add_entry()
2439 memset(&node2->fake, 0, sizeof(struct fake_dirent)); in ext4_dx_add_entry()
2440 node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize, in ext4_dx_add_entry()
2441 sb->s_blocksize); in ext4_dx_add_entry()
2442 BUFFER_TRACE(frame->bh, "get_write_access"); in ext4_dx_add_entry()
2443 err = ext4_journal_get_write_access(handle, frame->bh); in ext4_dx_add_entry()
2447 unsigned icount1 = icount/2, icount2 = icount - icount1; in ext4_dx_add_entry()
2452 BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */ in ext4_dx_add_entry()
2454 (frame - 1)->bh); in ext4_dx_add_entry()
2465 if (at - entries >= icount1) { in ext4_dx_add_entry()
2466 frame->at = at = at - entries - icount1 + entries2; in ext4_dx_add_entry()
2467 frame->entries = entries = entries2; in ext4_dx_add_entry()
2468 swap(frame->bh, bh2); in ext4_dx_add_entry()
2470 dx_insert_block((frame - 1), hash2, newblock); in ext4_dx_add_entry()
2471 dxtrace(dx_show_index("node", frame->entries)); in ext4_dx_add_entry()
2473 ((struct dx_node *) bh2->b_data)->entries)); in ext4_dx_add_entry()
2479 (frame - 1)->bh); in ext4_dx_add_entry()
2483 frame->bh); in ext4_dx_add_entry()
2495 dxroot = (struct dx_root *)frames[0].bh->b_data; in ext4_dx_add_entry()
2496 dxroot->info.indirect_levels += 1; in ext4_dx_add_entry()
2499 dxroot->info.indirect_levels)); in ext4_dx_add_entry()
2500 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh); in ext4_dx_add_entry()
2509 de = do_split(handle, dir, &bh, frame, &fname->hinfo); in ext4_dx_add_entry()
2510 if (IS_ERR(de)) { in ext4_dx_add_entry()
2511 err = PTR_ERR(de); in ext4_dx_add_entry()
2514 err = add_dirent_to_buf(handle, fname, dir, inode, de, bh); in ext4_dx_add_entry()
2518 ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */ in ext4_dx_add_entry()
2522 /* @restart is true means htree-path has been changed, we need to in ext4_dx_add_entry()
2523 * repeat dx_probe() to find out valid htree-path in ext4_dx_add_entry()
2541 struct ext4_dir_entry_2 *de, *pde; in ext4_generic_delete_entry() local
2542 unsigned int blocksize = dir->i_sb->s_blocksize; in ext4_generic_delete_entry()
2547 de = (struct ext4_dir_entry_2 *)entry_buf; in ext4_generic_delete_entry()
2548 while (i < buf_size - csum_size) { in ext4_generic_delete_entry()
2549 if (ext4_check_dir_entry(dir, NULL, de, bh, in ext4_generic_delete_entry()
2551 return -EFSCORRUPTED; in ext4_generic_delete_entry()
2552 if (de == de_del) { in ext4_generic_delete_entry()
2554 pde->rec_len = ext4_rec_len_to_disk( in ext4_generic_delete_entry()
2555 ext4_rec_len_from_disk(pde->rec_len, in ext4_generic_delete_entry()
2557 ext4_rec_len_from_disk(de->rec_len, in ext4_generic_delete_entry()
2562 memset(de, 0, ext4_rec_len_from_disk(de->rec_len, in ext4_generic_delete_entry()
2566 de->inode = 0; in ext4_generic_delete_entry()
2567 memset(&de->name_len, 0, in ext4_generic_delete_entry()
2568 ext4_rec_len_from_disk(de->rec_len, in ext4_generic_delete_entry()
2569 blocksize) - in ext4_generic_delete_entry()
2577 i += ext4_rec_len_from_disk(de->rec_len, blocksize); in ext4_generic_delete_entry()
2578 pde = de; in ext4_generic_delete_entry()
2579 de = ext4_next_entry(de, blocksize); in ext4_generic_delete_entry()
2581 return -ENOENT; in ext4_generic_delete_entry()
2599 if (ext4_has_metadata_csum(dir->i_sb)) in ext4_delete_entry()
2607 err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data, in ext4_delete_entry()
2608 dir->i_sb->s_blocksize, csum_size); in ext4_delete_entry()
2619 if (err != -ENOENT) in ext4_delete_entry()
2620 ext4_std_error(dir->i_sb, err); in ext4_delete_entry()
2627 * the 16-bit i_links_count field on disk. Directories with i_nlink == 1 mean
2631 * feature is not enabled and returned -EMLINK. The is_dx() check is a proxy
2632 * for checking S_ISDIR(inode) (since the INODE_INDEX feature will not be set
2633 * on regular files) and to avoid creating huge/slow non-HTREE directories.
2639 (inode->i_nlink > EXT4_LINK_MAX || inode->i_nlink == 2)) in ext4_inc_count()
2644 * If a directory had nlink == 1, then we should let it be 1. This indicates
2649 if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2) in ext4_dec_count()
2655 * Add non-directory inode to a directory. On success, the inode reference is
2663 struct inode *dir = d_inode(dentry->d_parent); in ext4_add_nondir()
2683 * is so far negative - it has no inode.
2699 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_create()
2702 inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0, in ext4_create()
2707 inode->i_op = &ext4_file_inode_operations; in ext4_create()
2708 inode->i_fop = &ext4_file_operations; in ext4_create()
2718 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_create()
2734 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_mknod()
2737 inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0, in ext4_mknod()
2742 init_special_inode(inode, inode->i_mode, rdev); in ext4_mknod()
2743 inode->i_op = &ext4_special_inode_operations; in ext4_mknod()
2752 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_mknod()
2771 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + in ext4_tmpfile()
2776 inode->i_op = &ext4_file_inode_operations; in ext4_tmpfile()
2777 inode->i_fop = &ext4_file_operations; in ext4_tmpfile()
2788 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_tmpfile()
2798 struct ext4_dir_entry_2 *de, in ext4_init_dot_dotdot() argument
2802 de->inode = cpu_to_le32(inode->i_ino); in ext4_init_dot_dotdot()
2803 de->name_len = 1; in ext4_init_dot_dotdot()
2804 de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len), in ext4_init_dot_dotdot()
2806 strcpy(de->name, "."); in ext4_init_dot_dotdot()
2807 ext4_set_de_type(inode->i_sb, de, S_IFDIR); in ext4_init_dot_dotdot()
2809 de = ext4_next_entry(de, blocksize); in ext4_init_dot_dotdot()
2810 de->inode = cpu_to_le32(parent_ino); in ext4_init_dot_dotdot()
2811 de->name_len = 2; in ext4_init_dot_dotdot()
2813 de->rec_len = ext4_rec_len_to_disk(blocksize - in ext4_init_dot_dotdot()
2817 de->rec_len = ext4_rec_len_to_disk( in ext4_init_dot_dotdot()
2818 EXT4_DIR_REC_LEN(de->name_len), blocksize); in ext4_init_dot_dotdot()
2819 strcpy(de->name, ".."); in ext4_init_dot_dotdot()
2820 ext4_set_de_type(inode->i_sb, de, S_IFDIR); in ext4_init_dot_dotdot()
2822 return ext4_next_entry(de, blocksize); in ext4_init_dot_dotdot()
2829 struct ext4_dir_entry_2 *de; in ext4_init_new_dir() local
2831 unsigned int blocksize = dir->i_sb->s_blocksize; in ext4_init_new_dir()
2835 if (ext4_has_metadata_csum(dir->i_sb)) in ext4_init_new_dir()
2840 if (err < 0 && err != -ENOSPC) in ext4_init_new_dir()
2846 inode->i_size = 0; in ext4_init_new_dir()
2850 de = (struct ext4_dir_entry_2 *)dir_block->b_data; in ext4_init_new_dir()
2851 ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0); in ext4_init_new_dir()
2873 return -EMLINK; in ext4_mkdir()
2879 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_mkdir()
2883 &dentry->d_name, in ext4_mkdir()
2890 inode->i_op = &ext4_dir_inode_operations; in ext4_mkdir()
2891 inode->i_fop = &ext4_dir_operations; in ext4_mkdir()
2925 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in ext4_mkdir()
2937 struct ext4_dir_entry_2 *de; in ext4_empty_dir() local
2949 sb = inode->i_sb; in ext4_empty_dir()
2950 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) { in ext4_empty_dir()
2954 /* The first directory block must not be a hole, in ext4_empty_dir()
2961 de = (struct ext4_dir_entry_2 *) bh->b_data; in ext4_empty_dir()
2962 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size, in ext4_empty_dir()
2964 le32_to_cpu(de->inode) != inode->i_ino || strcmp(".", de->name)) { in ext4_empty_dir()
2969 offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize); in ext4_empty_dir()
2970 de = ext4_next_entry(de, sb->s_blocksize); in ext4_empty_dir()
2971 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size, in ext4_empty_dir()
2973 le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) { in ext4_empty_dir()
2978 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize); in ext4_empty_dir()
2979 while (offset < inode->i_size) { in ext4_empty_dir()
2980 if (!(offset & (sb->s_blocksize - 1))) { in ext4_empty_dir()
2986 offset += sb->s_blocksize; in ext4_empty_dir()
2992 de = (struct ext4_dir_entry_2 *) (bh->b_data + in ext4_empty_dir()
2993 (offset & (sb->s_blocksize - 1))); in ext4_empty_dir()
2994 if (ext4_check_dir_entry(inode, NULL, de, bh, in ext4_empty_dir()
2995 bh->b_data, bh->b_size, offset) || in ext4_empty_dir()
2996 le32_to_cpu(de->inode)) { in ext4_empty_dir()
3000 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize); in ext4_empty_dir()
3015 * Orphan list manipulation functions must be called under i_mutex unless
3020 struct super_block *sb = inode->i_sb; in ext4_orphan_add()
3026 if (!sbi->s_journal || is_bad_inode(inode)) in ext4_orphan_add()
3029 WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) && in ext4_orphan_add()
3035 if (!list_empty(&EXT4_I(inode)->i_orphan)) in ext4_orphan_add()
3041 * hold i_mutex, or the inode can not be referenced from outside, in ext4_orphan_add()
3042 * so i_nlink should not be bumped due to race in ext4_orphan_add()
3044 J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || in ext4_orphan_add()
3045 S_ISLNK(inode->i_mode)) || inode->i_nlink == 0); in ext4_orphan_add()
3047 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); in ext4_orphan_add()
3048 err = ext4_journal_get_write_access(handle, sbi->s_sbh); in ext4_orphan_add()
3056 mutex_lock(&sbi->s_orphan_lock); in ext4_orphan_add()
3058 * Due to previous errors inode may be already a part of on-disk in ext4_orphan_add()
3059 * orphan list. If so skip on-disk list modification. in ext4_orphan_add()
3062 (le32_to_cpu(sbi->s_es->s_inodes_count))) { in ext4_orphan_add()
3063 /* Insert this inode at the head of the on-disk orphan list */ in ext4_orphan_add()
3064 NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan); in ext4_orphan_add()
3065 lock_buffer(sbi->s_sbh); in ext4_orphan_add()
3066 sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino); in ext4_orphan_add()
3068 unlock_buffer(sbi->s_sbh); in ext4_orphan_add()
3071 list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan); in ext4_orphan_add()
3072 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_add()
3075 err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh); in ext4_orphan_add()
3081 * We have to remove inode from in-memory list if in ext4_orphan_add()
3085 mutex_lock(&sbi->s_orphan_lock); in ext4_orphan_add()
3086 list_del_init(&EXT4_I(inode)->i_orphan); in ext4_orphan_add()
3087 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_add()
3092 jbd_debug(4, "superblock will point to %lu\n", inode->i_ino); in ext4_orphan_add()
3094 inode->i_ino, NEXT_ORPHAN(inode)); in ext4_orphan_add()
3108 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_orphan_del()
3113 if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS)) in ext4_orphan_del()
3116 WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) && in ext4_orphan_del()
3119 if (list_empty(&ei->i_orphan)) in ext4_orphan_del()
3127 mutex_lock(&sbi->s_orphan_lock); in ext4_orphan_del()
3128 jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino); in ext4_orphan_del()
3130 prev = ei->i_orphan.prev; in ext4_orphan_del()
3131 list_del_init(&ei->i_orphan); in ext4_orphan_del()
3138 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_del()
3143 if (prev == &sbi->s_orphan) { in ext4_orphan_del()
3145 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); in ext4_orphan_del()
3146 err = ext4_journal_get_write_access(handle, sbi->s_sbh); in ext4_orphan_del()
3148 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_del()
3151 lock_buffer(sbi->s_sbh); in ext4_orphan_del()
3152 sbi->s_es->s_last_orphan = cpu_to_le32(ino_next); in ext4_orphan_del()
3153 ext4_superblock_csum_set(inode->i_sb); in ext4_orphan_del()
3154 unlock_buffer(sbi->s_sbh); in ext4_orphan_del()
3155 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_del()
3156 err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh); in ext4_orphan_del()
3160 &list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode; in ext4_orphan_del()
3163 i_prev->i_ino, ino_next); in ext4_orphan_del()
3166 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_del()
3171 mutex_unlock(&sbi->s_orphan_lock); in ext4_orphan_del()
3178 ext4_std_error(inode->i_sb, err); in ext4_orphan_del()
3191 struct ext4_dir_entry_2 *de; in ext4_rmdir() local
3194 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb)))) in ext4_rmdir()
3195 return -EIO; in ext4_rmdir()
3206 retval = -ENOENT; in ext4_rmdir()
3207 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL); in ext4_rmdir()
3215 retval = -EFSCORRUPTED; in ext4_rmdir()
3216 if (le32_to_cpu(de->inode) != inode->i_ino) in ext4_rmdir()
3219 retval = -ENOTEMPTY; in ext4_rmdir()
3224 EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); in ext4_rmdir()
3234 retval = ext4_delete_entry(handle, dir, de, bh); in ext4_rmdir()
3240 dentry->d_name.len, dentry->d_name.name, in ext4_rmdir()
3241 inode->i_nlink); in ext4_rmdir()
3247 inode->i_size = 0; in ext4_rmdir()
3249 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode); in ext4_rmdir()
3260 * Case-insensitiveness. Eventually we'll want avoid in ext4_rmdir()
3280 int retval = -ENOENT; in __ext4_unlink()
3282 struct ext4_dir_entry_2 *de; in __ext4_unlink() local
3288 * directory's encryption key, which isn't GFP_NOFS-safe. in __ext4_unlink()
3290 bh = ext4_find_entry(dir, d_name, &de, NULL); in __ext4_unlink()
3295 return -ENOENT; in __ext4_unlink()
3297 if (le32_to_cpu(de->inode) != inode->i_ino) { in __ext4_unlink()
3303 if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY) in __ext4_unlink()
3310 EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); in __ext4_unlink()
3320 retval = ext4_delete_entry(handle, dir, de, bh); in __ext4_unlink()
3323 dir->i_ctime = dir->i_mtime = current_time(dir); in __ext4_unlink()
3331 if (inode->i_nlink == 0) in __ext4_unlink()
3333 d_name->len, d_name->name); in __ext4_unlink()
3336 if (!inode->i_nlink) in __ext4_unlink()
3338 inode->i_ctime = current_time(inode); in __ext4_unlink()
3353 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb)))) in ext4_unlink()
3354 return -EIO; in ext4_unlink()
3368 retval = __ext4_unlink(dir, &dentry->d_name, d_inode(dentry), dentry); in ext4_unlink()
3371 * Case-insensitiveness. Eventually we'll want avoid in ext4_unlink()
3394 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb)))) in ext4_symlink()
3395 return -EIO; in ext4_symlink()
3397 err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize, in ext4_symlink()
3408 * For non-fast symlinks, we just allocate inode and put it on in ext4_symlink()
3413 credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + in ext4_symlink()
3422 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_symlink()
3427 &dentry->d_name, 0, NULL, in ext4_symlink()
3440 inode->i_op = &ext4_encrypted_symlink_inode_operations; in ext4_symlink()
3445 inode->i_op = &ext4_symlink_inode_operations; in ext4_symlink()
3473 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in ext4_symlink()
3488 inode->i_op = &ext4_fast_symlink_inode_operations; in ext4_symlink()
3489 inode->i_link = (char *)&EXT4_I(inode)->i_data; in ext4_symlink()
3491 memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name, in ext4_symlink()
3493 inode->i_size = disk_link.len - 1; in ext4_symlink()
3495 EXT4_I(inode)->i_disksize = inode->i_size; in ext4_symlink()
3521 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + in __ext4_link()
3529 inode->i_ctime = current_time(inode); in __ext4_link()
3539 if (inode->i_nlink == 1) in __ext4_link()
3548 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) in __ext4_link()
3559 if (inode->i_nlink >= EXT4_LINK_MAX) in ext4_link()
3560 return -EMLINK; in ext4_link()
3567 (!projid_eq(EXT4_I(dir)->i_projid, in ext4_link()
3568 EXT4_I(old_dentry->d_inode)->i_projid))) in ext4_link()
3569 return -EXDEV; in ext4_link()
3579 * It should be the inode block if it is inlined or the 1st block
3591 struct ext4_dir_entry_2 *de; in ext4_get_first_dir_block() local
3594 /* The first directory block must not be a hole, so in ext4_get_first_dir_block()
3603 de = (struct ext4_dir_entry_2 *) bh->b_data; in ext4_get_first_dir_block()
3604 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, in ext4_get_first_dir_block()
3605 bh->b_size, 0) || in ext4_get_first_dir_block()
3606 le32_to_cpu(de->inode) != inode->i_ino || in ext4_get_first_dir_block()
3607 strcmp(".", de->name)) { in ext4_get_first_dir_block()
3610 *retval = -EFSCORRUPTED; in ext4_get_first_dir_block()
3613 offset = ext4_rec_len_from_disk(de->rec_len, in ext4_get_first_dir_block()
3614 inode->i_sb->s_blocksize); in ext4_get_first_dir_block()
3615 de = ext4_next_entry(de, inode->i_sb->s_blocksize); in ext4_get_first_dir_block()
3616 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, in ext4_get_first_dir_block()
3617 bh->b_size, offset) || in ext4_get_first_dir_block()
3618 le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) { in ext4_get_first_dir_block()
3621 *retval = -EFSCORRUPTED; in ext4_get_first_dir_block()
3624 *parent_de = de; in ext4_get_first_dir_block()
3642 struct ext4_dir_entry_2 *de; member
3655 ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode, in ext4_rename_dir_prepare()
3656 &retval, &ent->parent_de, in ext4_rename_dir_prepare()
3657 &ent->dir_inlined); in ext4_rename_dir_prepare()
3658 if (!ent->dir_bh) in ext4_rename_dir_prepare()
3660 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino) in ext4_rename_dir_prepare()
3661 return -EFSCORRUPTED; in ext4_rename_dir_prepare()
3662 BUFFER_TRACE(ent->dir_bh, "get_write_access"); in ext4_rename_dir_prepare()
3663 return ext4_journal_get_write_access(handle, ent->dir_bh); in ext4_rename_dir_prepare()
3671 ent->parent_de->inode = cpu_to_le32(dir_ino); in ext4_rename_dir_finish()
3672 BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata"); in ext4_rename_dir_finish()
3673 if (!ent->dir_inlined) { in ext4_rename_dir_finish()
3674 if (is_dx(ent->inode)) { in ext4_rename_dir_finish()
3676 ent->inode, in ext4_rename_dir_finish()
3677 ent->dir_bh); in ext4_rename_dir_finish()
3679 retval = ext4_handle_dirty_dirblock(handle, ent->inode, in ext4_rename_dir_finish()
3680 ent->dir_bh); in ext4_rename_dir_finish()
3683 retval = ext4_mark_inode_dirty(handle, ent->inode); in ext4_rename_dir_finish()
3686 ext4_std_error(ent->dir->i_sb, retval); in ext4_rename_dir_finish()
3697 BUFFER_TRACE(ent->bh, "get write access"); in ext4_setent()
3698 retval = ext4_journal_get_write_access(handle, ent->bh); in ext4_setent()
3701 ent->de->inode = cpu_to_le32(ino); in ext4_setent()
3702 if (ext4_has_feature_filetype(ent->dir->i_sb)) in ext4_setent()
3703 ent->de->file_type = file_type; in ext4_setent()
3704 inode_inc_iversion(ent->dir); in ext4_setent()
3705 ent->dir->i_ctime = ent->dir->i_mtime = in ext4_setent()
3706 current_time(ent->dir); in ext4_setent()
3707 retval = ext4_mark_inode_dirty(handle, ent->dir); in ext4_setent()
3708 BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata"); in ext4_setent()
3709 if (!ent->inlined) { in ext4_setent()
3710 retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh); in ext4_setent()
3712 ext4_std_error(ent->dir->i_sb, retval2); in ext4_setent()
3726 * old->de could have moved from under us during make indexed dir, in ext4_resetent()
3727 * so the old->de may no longer valid and need to find it again in ext4_resetent()
3730 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, in ext4_resetent()
3735 retval = -ENOENT; in ext4_resetent()
3737 ext4_std_error(old.dir->i_sb, retval); in ext4_resetent()
3748 int retval = -ENOENT; in ext4_find_delete_entry()
3750 struct ext4_dir_entry_2 *de; in ext4_find_delete_entry() local
3752 bh = ext4_find_entry(dir, d_name, &de, NULL); in ext4_find_delete_entry()
3756 retval = ext4_delete_entry(handle, dir, de, bh); in ext4_find_delete_entry()
3767 * ent->de could have moved from under us during htree split, so make in ext4_rename_delete()
3768 * sure that we are deleting the right entry. We might also be pointing in ext4_rename_delete()
3769 * to a stale entry in the unused part of ent->bh so just checking inum in ext4_rename_delete()
3772 if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino || in ext4_rename_delete()
3773 ent->de->name_len != ent->dentry->d_name.len || in ext4_rename_delete()
3774 strncmp(ent->de->name, ent->dentry->d_name.name, in ext4_rename_delete()
3775 ent->de->name_len) || in ext4_rename_delete()
3777 retval = ext4_find_delete_entry(handle, ent->dir, in ext4_rename_delete()
3778 &ent->dentry->d_name); in ext4_rename_delete()
3780 retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh); in ext4_rename_delete()
3781 if (retval == -ENOENT) { in ext4_rename_delete()
3782 retval = ext4_find_delete_entry(handle, ent->dir, in ext4_rename_delete()
3783 &ent->dentry->d_name); in ext4_rename_delete()
3788 ext4_warning_inode(ent->dir, in ext4_rename_delete()
3790 ent->dir->i_nlink, retval); in ext4_rename_delete()
3796 if (ent->dir_nlink_delta) { in ext4_update_dir_count()
3797 if (ent->dir_nlink_delta == -1) in ext4_update_dir_count()
3798 ext4_dec_count(ent->dir); in ext4_update_dir_count()
3800 ext4_inc_count(ent->dir); in ext4_update_dir_count()
3801 ext4_mark_inode_dirty(handle, ent->dir); in ext4_update_dir_count()
3816 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) + in ext4_whiteout_for_rename()
3819 wh = ext4_new_inode_start_handle(ent->dir, S_IFCHR | WHITEOUT_MODE, in ext4_whiteout_for_rename()
3820 &ent->dentry->d_name, 0, NULL, in ext4_whiteout_for_rename()
3827 if (PTR_ERR(wh) == -ENOSPC && in ext4_whiteout_for_rename()
3828 ext4_should_retry_alloc(ent->dir->i_sb, &retries)) in ext4_whiteout_for_rename()
3832 init_special_inode(wh, wh->i_mode, WHITEOUT_DEV); in ext4_whiteout_for_rename()
3833 wh->i_op = &ext4_special_inode_operations; in ext4_whiteout_for_rename()
3840 * higher-level routines.
3867 if (new.inode && new.inode->i_nlink == 0) { in ext4_rename()
3870 return -EFSCORRUPTED; in ext4_rename()
3874 (!projid_eq(EXT4_I(new_dir)->i_projid, in ext4_rename()
3875 EXT4_I(old_dentry->d_inode)->i_projid))) in ext4_rename()
3876 return -EXDEV; in ext4_rename()
3896 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, in ext4_rename()
3905 * same name. Goodbye sticky bit ;-< in ext4_rename()
3907 retval = -ENOENT; in ext4_rename()
3908 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino) in ext4_rename()
3911 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name, in ext4_rename()
3912 &new.de, &new.inlined); in ext4_rename()
3924 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC)) in ext4_rename()
3927 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + in ext4_rename()
3943 old_file_type = old.de->file_type; in ext4_rename()
3947 if (S_ISDIR(old.inode->i_mode)) { in ext4_rename()
3949 retval = -ENOTEMPTY; in ext4_rename()
3953 retval = -EMLINK; in ext4_rename()
3965 * re-read the directory, or else we end up trying to delete a dirent in ext4_rename()
3968 force_reread = (new.dir->i_ino == old.dir->i_ino && in ext4_rename()
3974 * to be still pointing to the valid old entry. in ext4_rename()
3976 retval = ext4_setent(handle, &old, whiteout->i_ino, in ext4_rename()
3991 old.inode->i_ino, old_file_type); in ext4_rename()
4003 old.inode->i_ctime = current_time(old.inode); in ext4_rename()
4017 new.inode->i_ctime = current_time(new.inode); in ext4_rename()
4019 old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir); in ext4_rename()
4022 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino); in ext4_rename()
4029 * parent, ext4_dec_count() won't work for many-linked in ext4_rename()
4044 if (S_ISDIR(old.inode->i_mode)) { in ext4_rename()
4050 ext4_fc_mark_ineligible(old.inode->i_sb, in ext4_rename()
4065 if (!new.inode->i_nlink) in ext4_rename()
4074 old.inode->i_ino, old_file_type); in ext4_rename()
4111 !projid_eq(EXT4_I(new_dir)->i_projid, in ext4_cross_rename()
4112 EXT4_I(old_dentry->d_inode)->i_projid)) || in ext4_cross_rename()
4114 !projid_eq(EXT4_I(old_dir)->i_projid, in ext4_cross_rename()
4115 EXT4_I(new_dentry->d_inode)->i_projid))) in ext4_cross_rename()
4116 return -EXDEV; in ext4_cross_rename()
4125 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, in ext4_cross_rename()
4126 &old.de, &old.inlined); in ext4_cross_rename()
4133 * same name. Goodbye sticky bit ;-< in ext4_cross_rename()
4135 retval = -ENOENT; in ext4_cross_rename()
4136 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino) in ext4_cross_rename()
4139 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name, in ext4_cross_rename()
4140 &new.de, &new.inlined); in ext4_cross_rename()
4148 if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino) in ext4_cross_rename()
4152 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + in ext4_cross_rename()
4163 if (S_ISDIR(old.inode->i_mode)) { in ext4_cross_rename()
4169 if (S_ISDIR(new.inode->i_mode)) { in ext4_cross_rename()
4178 * nlink only needs to be modified if this is a cross directory rename. in ext4_cross_rename()
4181 old.dir_nlink_delta = old.is_dir ? -1 : 1; in ext4_cross_rename()
4182 new.dir_nlink_delta = -old.dir_nlink_delta; in ext4_cross_rename()
4183 retval = -EMLINK; in ext4_cross_rename()
4189 new_file_type = new.de->file_type; in ext4_cross_rename()
4190 retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type); in ext4_cross_rename()
4194 retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type); in ext4_cross_rename()
4203 old.inode->i_ctime = ctime; in ext4_cross_rename()
4204 new.inode->i_ctime = ctime; in ext4_cross_rename()
4211 ext4_fc_mark_ineligible(new.inode->i_sb, in ext4_cross_rename()
4214 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino); in ext4_cross_rename()
4219 retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino); in ext4_cross_rename()
4243 if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir->i_sb)))) in ext4_rename2()
4244 return -EIO; in ext4_rename2()
4247 return -EINVAL; in ext4_rename2()