Lines Matching defs:inode
49 static __le32 ext4_extent_block_csum(struct inode *inode,
52 struct ext4_inode_info *ei = EXT4_I(inode);
53 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
61 static int ext4_extent_block_csum_verify(struct inode *inode,
66 if (!ext4_has_metadata_csum(inode->i_sb))
70 if (et->et_checksum != ext4_extent_block_csum(inode, eh))
75 static void ext4_extent_block_csum_set(struct inode *inode,
80 if (!ext4_has_metadata_csum(inode->i_sb))
84 et->et_checksum = ext4_extent_block_csum(inode, eh);
88 struct inode *inode,
94 static int ext4_ext_trunc_restart_fn(struct inode *inode, int *dropped)
102 BUG_ON(EXT4_JOURNAL(inode) == NULL);
103 ext4_discard_preallocations(inode, 0);
104 up_write(&EXT4_I(inode)->i_data_sem);
117 int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
125 revoke_cred, ext4_ext_trunc_restart_fn(inode, &dropped));
127 down_write(&EXT4_I(inode)->i_data_sem);
136 static int ext4_ext_get_access(handle_t *handle, struct inode *inode,
154 /* path points to leaf/index in inode body */
166 handle_t *handle, struct inode *inode,
171 WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem));
173 ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh));
176 inode, path->p_bh);
181 /* path points to leaf/index in inode body */
182 err = ext4_mark_inode_dirty(handle, inode);
187 #define ext4_ext_dirty(handle, inode, path) \
188 __ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path))
190 static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
232 /* OK. use inode's group */
233 return ext4_inode_to_goal_block(inode);
240 ext4_ext_new_meta_block(handle_t *handle, struct inode *inode,
246 goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
247 newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
252 static inline int ext4_ext_space_block(struct inode *inode, int check)
256 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
265 static inline int ext4_ext_space_block_idx(struct inode *inode, int check)
269 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
278 static inline int ext4_ext_space_root(struct inode *inode, int check)
282 size = sizeof(EXT4_I(inode)->i_data);
292 static inline int ext4_ext_space_root_idx(struct inode *inode, int check)
296 size = sizeof(EXT4_I(inode)->i_data);
307 ext4_force_split_extent_at(handle_t *handle, struct inode *inode,
318 return ext4_split_extent_at(handle, inode, ppath, lblk, unwritten ?
324 ext4_ext_max_entries(struct inode *inode, int depth)
328 if (depth == ext_depth(inode)) {
330 max = ext4_ext_space_root(inode, 1);
332 max = ext4_ext_space_root_idx(inode, 1);
335 max = ext4_ext_space_block(inode, 1);
337 max = ext4_ext_space_block_idx(inode, 1);
343 static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
356 return ext4_inode_block_valid(inode, block, len);
359 static int ext4_valid_extent_idx(struct inode *inode,
364 return ext4_inode_block_valid(inode, block, 1);
367 static int ext4_valid_extent_entries(struct inode *inode,
389 if (depth != ext_depth(inode) &&
393 if (!ext4_valid_extent(inode, ext))
413 if (depth != ext_depth(inode) &&
417 if (!ext4_valid_extent_idx(inode, ext_idx))
435 struct inode *inode, struct ext4_extent_header *eh,
453 max = ext4_ext_max_entries(inode, depth);
466 if (!ext4_valid_extent_entries(inode, eh, lblk, &pblk, depth)) {
475 if (ext_depth(inode) != depth &&
476 !ext4_extent_block_csum_verify(inode, eh)) {
484 ext4_error_inode_err(inode, function, line, 0, -err,
495 #define ext4_ext_check(inode, eh, depth, pblk) \
496 __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk), 0)
498 int ext4_ext_check_inode(struct inode *inode)
500 return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode), 0);
503 static void ext4_cache_extents(struct inode *inode,
516 ext4_es_cache_extent(inode, prev, lblk - prev, ~0,
521 ext4_es_cache_extent(inode, lblk, len,
529 struct inode *inode, struct ext4_extent_idx *idx,
541 bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags);
546 trace_ext4_ext_load_extent(inode, pblk, _RET_IP_);
554 ext4_error_inode(inode, function, line, 0,
563 err = __ext4_ext_check(function, line, inode, ext_block_hdr(bh),
574 ext4_cache_extents(inode, eh);
583 #define read_extent_tree_block(inode, idx, depth, flags) \
584 __read_extent_tree_block(__func__, __LINE__, (inode), (idx), \
591 int ext4_ext_precache(struct inode *inode)
593 struct ext4_inode_info *ei = EXT4_I(inode);
598 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
599 return 0; /* not an extent-mapped inode */
602 depth = ext_depth(inode);
617 path[0].p_hdr = ext_inode_hdr(inode);
618 ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0);
634 bh = read_extent_tree_block(inode, path[i].p_idx++,
646 ext4_set_inode_state(inode, EXT4_STATE_EXT_PRECACHED);
655 static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
659 ext_debug(inode, "path:");
662 ext_debug(inode, " %d->%llu",
666 ext_debug(inode, " %d:[%d]%d:%llu ",
672 ext_debug(inode, " []");
674 ext_debug(inode, "\n");
677 static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
679 int depth = ext_depth(inode);
690 ext_debug(inode, "Displaying leaf extents\n");
693 ext_debug(inode, "%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),
697 ext_debug(inode, "\n");
700 static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path,
703 int depth = ext_depth(inode);
710 ext_debug(inode, "%d: move %d:%llu in new index %llu\n",
721 ext_debug(inode, "move %d:%llu:[%d]%d in new leaf %llu\n",
732 #define ext4_ext_show_path(inode, path)
733 #define ext4_ext_show_leaf(inode, path)
734 #define ext4_ext_show_move(inode, path, newblock, level)
756 ext4_ext_binsearch_idx(struct inode *inode,
763 ext_debug(inode, "binsearch for %u(idx): ", block);
773 ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,
779 ext_debug(inode, " -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block),
816 ext4_ext_binsearch(struct inode *inode,
830 ext_debug(inode, "binsearch for %u: ", block);
841 ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,
847 ext_debug(inode, " -> %d:%llu:[%d]%d ",
872 void ext4_ext_tree_init(handle_t *handle, struct inode *inode)
876 eh = ext_inode_hdr(inode);
880 eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
882 ext4_mark_inode_dirty(handle, inode);
886 ext4_find_extent(struct inode *inode, ext4_lblk_t block,
899 eh = ext_inode_hdr(inode);
900 depth = ext_depth(inode);
902 EXT4_ERROR_INODE(inode, "inode has invalid extent depth: %d",
928 ext4_cache_extents(inode, eh);
931 ext_debug(inode, "depth %d: num %d, max %d\n",
934 ext4_ext_binsearch_idx(inode, path + ppos, block);
939 bh = read_extent_tree_block(inode, path[ppos].p_idx, --i, flags);
956 ext4_ext_binsearch(inode, path + ppos, block);
961 ext4_ext_show_path(inode, path);
978 static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
985 err = ext4_ext_get_access(handle, inode, curp);
990 EXT4_ERROR_INODE(inode,
998 EXT4_ERROR_INODE(inode,
1007 ext_debug(inode, "insert new index %d after: %llu\n",
1012 ext_debug(inode, "insert new index %d before: %llu\n",
1018 EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!");
1025 ext_debug(inode, "insert new index %d: "
1036 EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
1040 err = ext4_ext_dirty(handle, inode, curp);
1041 ext4_std_error(inode->i_sb, err);
1056 static int ext4_ext_split(handle_t *handle, struct inode *inode,
1062 int depth = ext_depth(inode);
1082 EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
1087 ext_debug(inode, "leaf will be split."
1092 ext_debug(inode, "leaf will be added."
1114 ext_debug(inode, "allocate %d blocks for indexes/leaf\n", depth - at);
1116 newblock = ext4_ext_new_meta_block(handle, inode, path,
1126 EXT4_ERROR_INODE(inode, "newblock == 0!");
1130 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1143 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1151 EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
1159 ext4_ext_show_move(inode, path, newblock, depth);
1170 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1171 ext4_extent_block_csum_set(inode, neh);
1175 err = ext4_handle_dirty_metadata(handle, inode, bh);
1183 err = ext4_ext_get_access(handle, inode, path + depth);
1187 err = ext4_ext_dirty(handle, inode, path + depth);
1196 EXT4_ERROR_INODE(inode, "k %d < 0!", k);
1201 ext_debug(inode, "create %d intermediate indices\n", k);
1208 bh = sb_getblk(inode->i_sb, newblock);
1222 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1229 ext_debug(inode, "int.index at %d (block %llu): %u -> %llu\n",
1235 EXT4_ERROR_INODE(inode,
1243 ext_debug(inode, "cur 0x%p, last 0x%p\n", path[i].p_idx,
1245 ext4_ext_show_move(inode, path, newblock, i);
1255 inode->i_sb->s_blocksize - ext_size);
1256 ext4_extent_block_csum_set(inode, neh);
1260 err = ext4_handle_dirty_metadata(handle, inode, bh);
1268 err = ext4_ext_get_access(handle, inode, path + i);
1272 err = ext4_ext_dirty(handle, inode, path + i);
1281 err = ext4_ext_insert_index(handle, inode, path + at,
1296 ext4_free_blocks(handle, inode, NULL, ablocks[i], 1,
1313 static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
1319 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
1324 if (ext_depth(inode))
1325 goal = ext4_idx_pblock(EXT_FIRST_INDEX(ext_inode_hdr(inode)));
1330 goal = ext4_inode_to_goal_block(inode);
1331 newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
1336 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1347 ext_size = sizeof(EXT4_I(inode)->i_data);
1349 memmove(bh->b_data, EXT4_I(inode)->i_data, ext_size);
1351 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1357 if (ext_depth(inode))
1358 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1360 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1362 ext4_extent_block_csum_set(inode, neh);
1366 err = ext4_handle_dirty_metadata(handle, inode, bh);
1371 neh = ext_inode_hdr(inode);
1376 neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
1380 ext_debug(inode, "new root: num %d(%d), lblock %d, ptr %llu\n",
1386 err = ext4_mark_inode_dirty(handle, inode);
1398 static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode,
1409 i = depth = ext_depth(inode);
1423 err = ext4_ext_split(handle, inode, mb_flags, path, newext, i);
1428 path = ext4_find_extent(inode,
1435 err = ext4_ext_grow_indepth(handle, inode, mb_flags);
1440 path = ext4_find_extent(inode,
1452 depth = ext_depth(inode);
1470 static int ext4_ext_search_left(struct inode *inode,
1479 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1496 EXT4_ERROR_INODE(inode,
1504 EXT4_ERROR_INODE(inode,
1517 EXT4_ERROR_INODE(inode,
1535 static int ext4_ext_search_right(struct inode *inode,
1548 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1565 EXT4_ERROR_INODE(inode,
1573 EXT4_ERROR_INODE(inode,
1583 EXT4_ERROR_INODE(inode,
1612 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1620 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1706 static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
1710 int depth = ext_depth(inode);
1719 EXT4_ERROR_INODE(inode,
1739 err = ext4_ext_get_access(handle, inode, path + k);
1743 err = ext4_ext_dirty(handle, inode, path + k);
1751 err = ext4_ext_get_access(handle, inode, path + k);
1755 err = ext4_ext_dirty(handle, inode, path + k);
1763 static int ext4_can_extents_be_merged(struct inode *inode,
1802 static int ext4_ext_try_to_merge_right(struct inode *inode,
1810 depth = ext_depth(inode);
1815 if (!ext4_can_extents_be_merged(inode, ex, ex + 1))
1833 EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!");
1841 * an extent tree with a single extent tree leaf block into the inode.
1844 struct inode *inode,
1848 unsigned max_root = ext4_ext_space_root(inode, 0);
1862 ext4_free_metadata_revoke_credits(inode->i_sb, 1)))
1866 * Copy the extent data up to the inode
1881 ext4_free_blocks(handle, inode, NULL, blk, 1,
1887 * tries to collapse the extent tree into the inode.
1890 struct inode *inode,
1898 depth = ext_depth(inode);
1903 merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1);
1906 (void) ext4_ext_try_to_merge_right(inode, path, ex);
1908 ext4_ext_try_to_merge_up(handle, inode, path);
1920 struct inode *inode,
1930 depth = ext_depth(inode);
1968 int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1984 EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
1987 depth = ext_depth(inode);
1991 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2018 if (ext4_can_extents_be_merged(inode, ex, newext)) {
2019 ext_debug(inode, "append [%d]%d block to %u:[%d]%d"
2027 err = ext4_ext_get_access(handle, inode,
2043 if (ext4_can_extents_be_merged(inode, newext, ex)) {
2044 ext_debug(inode, "prepend %u[%d]%d block to %u:[%d]%d"
2053 err = ext4_ext_get_access(handle, inode,
2071 depth = ext_depth(inode);
2082 ext_debug(inode, "next leaf block - %u\n", next);
2084 npath = ext4_find_extent(inode, next, NULL, gb_flags);
2090 ext_debug(inode, "next leaf isn't full(%d)\n",
2095 ext_debug(inode, "next leaf has no free space(%d,%d)\n",
2105 err = ext4_ext_create_new_leaf(handle, inode, mb_flags, gb_flags,
2109 depth = ext_depth(inode);
2115 err = ext4_ext_get_access(handle, inode, path + depth);
2121 ext_debug(inode, "first extent in the leaf: %u:%llu:[%d]%d\n",
2131 ext_debug(inode, "insert %u:%llu:[%d]%d before: "
2142 ext_debug(inode, "insert %u:%llu:[%d]%d after: "
2152 ext_debug(inode, "insert %u:%llu:[%d]%d: "
2173 ext4_ext_try_to_merge(handle, inode, path, nearex);
2177 err = ext4_ext_correct_indexes(handle, inode, path);
2181 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
2189 static int ext4_fill_es_cache_info(struct inode *inode,
2195 unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
2202 if (!ext4_es_lookup_extent(inode, block, &next, &es))
2237 * @inode: inode we lookup in
2248 static ext4_lblk_t ext4_ext_determine_hole(struct inode *inode,
2252 int depth = ext_depth(inode);
2283 ext4_ext_put_gap_in_cache(struct inode *inode, ext4_lblk_t hole_start,
2288 ext4_es_find_extent_range(inode, &ext4_es_is_delayed, hole_start,
2296 ext_debug(inode, " -> %u:%u\n", hole_start, hole_len);
2297 ext4_es_insert_extent(inode, hole_start, hole_len, ~0,
2305 static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
2316 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
2319 err = ext4_ext_get_access(handle, inode, path);
2330 err = ext4_ext_dirty(handle, inode, path);
2333 ext_debug(inode, "index is empty, remove it, free block %llu\n", leaf);
2334 trace_ext4_ext_rm_idx(inode, leaf);
2336 ext4_free_blocks(handle, inode, NULL, leaf, 1,
2343 err = ext4_ext_get_access(handle, inode, path);
2347 err = ext4_ext_dirty(handle, inode, path);
2361 int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks,
2365 int depth = ext_depth(inode);
2381 ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);
2386 return ext4_chunk_trans_blocks(inode, nrblocks);
2398 int ext4_ext_index_trans_blocks(struct inode *inode, int extents)
2404 if (ext4_has_inline_data(inode))
2407 depth = ext_depth(inode);
2417 static inline int get_default_free_blocks_flags(struct inode *inode)
2419 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) ||
2420 ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE))
2422 else if (ext4_should_journal_data(inode))
2431 * @inode - file containing the cluster
2442 static void ext4_rereserve_cluster(struct inode *inode, ext4_lblk_t lblk)
2444 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2445 struct ext4_inode_info *ei = EXT4_I(inode);
2447 dquot_reclaim_block(inode, EXT4_C2B(sbi, 1));
2455 ext4_remove_pending(inode, lblk);
2458 static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
2463 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2486 if (ext_depth(inode) > sbi->s_depth_max)
2487 sbi->s_depth_max = ext_depth(inode);
2491 trace_ext4_remove_blocks(inode, ex, from, to, partial);
2502 flags = get_default_free_blocks_flags(inode);
2503 if (ext4_is_pending(inode, partial->lblk))
2505 ext4_free_blocks(handle, inode, NULL,
2509 ext4_rereserve_cluster(inode, partial->lblk);
2523 flags = get_default_free_blocks_flags(inode);
2529 if (ext4_is_pending(inode, to))
2531 ext4_free_blocks(handle, inode, NULL,
2535 ext4_rereserve_cluster(inode, to);
2537 flags = get_default_free_blocks_flags(inode);
2549 ext4_free_blocks(handle, inode, NULL, pblk, num, flags);
2584 * @inode: The files inode
2594 ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
2599 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2601 int depth = ext_depth(inode), credits, revoke_credits;
2612 ext_debug(inode, "truncate since %u in leaf to %u\n", start, end);
2617 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2628 trace_ext4_ext_rm_leaf(inode, start, ex, partial);
2638 ext_debug(inode, "remove ext %u:[%d]%d\n", ex_ee_block,
2646 ext_debug(inode, " border %u:%u\n", a, b);
2667 EXT4_ERROR_INODE(inode,
2682 * 3 for leaf, sb, and inode plus 2 (bmap and group
2687 credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
2690 credits += (ext_depth(inode)) + 1;
2692 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
2699 ext4_free_metadata_revoke_credits(inode->i_sb,
2700 ext_depth(inode)) +
2701 ext4_free_data_revoke_credits(inode, b - a + 1);
2703 err = ext4_datasem_ensure_credits(handle, inode, credits,
2711 err = ext4_ext_get_access(handle, inode, path + depth);
2715 err = ext4_remove_blocks(handle, inode, ex, partial, a, b);
2751 err = ext4_ext_dirty(handle, inode, path + depth);
2755 ext_debug(inode, "new extent: %u:%u:%llu\n", ex_ee_block, num,
2763 err = ext4_ext_correct_indexes(handle, inode, path);
2775 int flags = get_default_free_blocks_flags(inode);
2777 if (ext4_is_pending(inode, partial->lblk))
2779 ext4_free_blocks(handle, inode, NULL,
2783 ext4_rereserve_cluster(inode, partial->lblk);
2791 err = ext4_ext_rm_idx(handle, inode, path, depth);
2818 int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
2821 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2822 int depth = ext_depth(inode);
2832 ext_debug(inode, "truncate since %u to %u\n", start, end);
2835 handle = ext4_journal_start_with_revoke(inode, EXT4_HT_TRUNCATE,
2837 ext4_free_metadata_revoke_credits(inode->i_sb, depth));
2842 trace_ext4_ext_remove_space(inode, start, end, depth);
2857 path = ext4_find_extent(inode, end, NULL,
2863 depth = ext_depth(inode);
2864 /* Leaf not may not exist only if inode has no blocks at all */
2868 EXT4_ERROR_INODE(inode,
2904 err = ext4_force_split_extent_at(handle, inode, &path,
2922 err = ext4_ext_search_right(inode, path, &lblk, &pblk,
2936 depth = ext_depth(inode);
2950 path[0].p_hdr = ext_inode_hdr(inode);
2953 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
2963 err = ext4_ext_rm_leaf(handle, inode, path,
2974 ext_debug(inode, "initialize header\n");
2982 ext_debug(inode, "init index ptr: hdr 0x%p, num %d\n",
2990 ext_debug(inode, "level %d - index, first 0x%p, cur 0x%p\n",
2996 ext_debug(inode, "move to level %d (block %llu)\n",
2999 bh = read_extent_tree_block(inode, path[i].p_idx,
3026 err = ext4_ext_rm_idx(handle, inode, path, i);
3032 ext_debug(inode, "return to level %d\n", i);
3036 trace_ext4_ext_remove_space_done(inode, start, end, depth, &partial,
3044 int flags = get_default_free_blocks_flags(inode);
3046 if (ext4_is_pending(inode, partial.lblk))
3048 ext4_free_blocks(handle, inode, NULL,
3052 ext4_rereserve_cluster(inode, partial.lblk);
3062 err = ext4_ext_get_access(handle, inode, path);
3064 ext_inode_hdr(inode)->eh_depth = 0;
3065 ext_inode_hdr(inode)->eh_max =
3066 cpu_to_le16(ext4_ext_space_root(inode, 0));
3067 err = ext4_ext_dirty(handle, inode, path);
3132 static int ext4_zeroout_es(struct inode *inode, struct ext4_extent *ex)
3145 return ext4_es_insert_extent(inode, ee_block, ee_len, ee_pblock,
3150 static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
3157 return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,
3165 * @inode: the file inode
3183 struct inode *inode,
3200 ext_debug(inode, "logical block %llu\n", (unsigned long long)split);
3202 ext4_ext_show_leaf(inode, path);
3204 depth = ext_depth(inode);
3216 err = ext4_ext_get_access(handle, inode, path + depth);
3232 ext4_ext_try_to_merge(handle, inode, path, ex);
3234 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3248 err = ext4_ext_dirty(handle, inode, path + depth);
3259 err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags);
3266 err = ext4_ext_zeroout(inode, ex2);
3273 err = ext4_ext_zeroout(inode, ex);
3281 err = ext4_ext_zeroout(inode, &orig_ex);
3292 ext4_ext_try_to_merge(handle, inode, path, ex);
3293 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3296 err = ext4_zeroout_es(inode, &zero_ex);
3312 ext4_ext_dirty(handle, inode, path + path->p_depth);
3315 ext4_ext_show_leaf(inode, path);
3331 struct inode *inode,
3346 depth = ext_depth(inode);
3360 err = ext4_split_extent_at(handle, inode, ppath,
3371 path = ext4_find_extent(inode, map->m_lblk, ppath, flags);
3374 depth = ext_depth(inode);
3377 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3391 err = ext4_split_extent_at(handle, inode, ppath,
3397 ext4_ext_show_leaf(inode, path);
3423 struct inode *inode,
3440 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3443 sbi = EXT4_SB(inode->i_sb);
3444 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3445 >> inode->i_sb->s_blocksize_bits;
3449 depth = ext_depth(inode);
3457 trace_ext4_ext_convert_to_initialized_enter(inode, map, ex);
3505 err = ext4_ext_get_access(handle, inode, path + depth);
3509 trace_ext4_ext_convert_to_initialized_fastpath(inode,
3551 err = ext4_ext_get_access(handle, inode, path + depth);
3555 trace_ext4_ext_convert_to_initialized_fastpath(inode,
3573 err = ext4_ext_dirty(handle, inode, path + depth);
3590 (inode->i_sb->s_blocksize_bits - 10);
3617 err = ext4_ext_zeroout(inode, &zero_ex1);
3631 err = ext4_ext_zeroout(inode, &zero_ex2);
3643 err = ext4_split_extent(handle, inode, ppath, &split_map, split_flag,
3650 err = ext4_zeroout_es(inode, &zero_ex1);
3652 err = ext4_zeroout_es(inode, &zero_ex2);
3682 struct inode *inode,
3694 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3697 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3698 >> inode->i_sb->s_blocksize_bits;
3705 depth = ext_depth(inode);
3720 return ext4_split_extent(handle, inode, ppath, map, split_flag, flags);
3724 struct inode *inode,
3735 depth = ext_depth(inode);
3740 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3751 ext4_warning(inode->i_sb, "Inode (%ld) finished: extent logical block %llu,"
3753 inode->i_ino, (unsigned long long)ee_block, ee_len,
3756 err = ext4_split_convert_extents(handle, inode, map, ppath,
3760 path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3763 depth = ext_depth(inode);
3767 err = ext4_ext_get_access(handle, inode, path + depth);
3776 ext4_ext_try_to_merge(handle, inode, path, ex);
3779 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3781 ext4_ext_show_leaf(inode, path);
3786 convert_initialized_extent(handle_t *handle, struct inode *inode,
3805 depth = ext_depth(inode);
3810 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3814 err = ext4_split_convert_extents(handle, inode, map, ppath,
3818 path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3821 depth = ext_depth(inode);
3824 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3830 err = ext4_ext_get_access(handle, inode, path + depth);
3839 ext4_ext_try_to_merge(handle, inode, path, ex);
3842 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3845 ext4_ext_show_leaf(inode, path);
3847 ext4_update_inode_fsync_trans(handle, inode, 1);
3857 ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode,
3866 ext_debug(inode, "logical block %llu, max_blocks %u, flags 0x%x, allocated %u\n",
3869 ext4_ext_show_leaf(inode, path);
3877 trace_ext4_ext_handle_unwritten_extents(inode, map, flags,
3882 ret = ext4_split_convert_extents(handle, inode, map, ppath,
3893 EXT4_ERROR_INODE(inode,
3904 err = ext4_convert_unwritten_extents_endio(handle, inode, map,
3908 ext4_update_inode_fsync_trans(handle, inode, 1);
3939 ret = ext4_ext_convert_to_initialized(handle, inode, map, ppath, flags);
3944 ext4_update_inode_fsync_trans(handle, inode, 1);
3950 EXT4_ERROR_INODE(inode, "unexpected ret == 0, m_len = %u",
3966 ext4_ext_show_leaf(inode, path);
3981 * find blocks that were already in the inode's extent tree. Hence,
3983 * the extent from the inode's extent tree. There are three cases we
4079 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
4080 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
4092 int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
4097 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4105 ext_debug(inode, "blocks %u/%u requested\n", map->m_lblk, map->m_len);
4106 trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
4109 path = ext4_find_extent(inode, map->m_lblk, NULL, 0);
4116 depth = ext_depth(inode);
4124 EXT4_ERROR_INODE(inode, "bad extent address "
4145 trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len);
4152 ext_debug(inode, "%u fit into %u:%d -> %llu\n",
4162 inode, map, &path, &allocated);
4170 ext4_ext_show_leaf(inode, path);
4175 handle, inode, map, &path, flags,
4193 hole_len = ext4_ext_determine_hole(inode, path, &hole_start);
4198 ext4_ext_put_gap_in_cache(inode, hole_start, hole_len);
4220 get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {
4228 err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
4232 err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2);
4239 get_implied_cluster_alloc(inode->i_sb, map, &ex2, path)) {
4260 err = ext4_ext_check_overlap(sbi, inode, &newex, path);
4267 ar.inode = inode;
4268 ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);
4282 if (S_ISREG(inode->i_mode))
4298 ext_debug(inode, "allocate new block: goal %llu, found %llu/%u, requested %u\n",
4314 err = ext4_ext_insert_extent(handle, inode, &path, &newex, flags);
4324 ext4_discard_preallocations(inode, 0);
4327 ext4_free_blocks(handle, inode, NULL, newblock,
4340 if (test_opt(inode->i_sb, DELALLOC) && allocated_clusters) {
4346 ext4_da_update_reserve_space(inode, allocated_clusters,
4365 n = ext4_es_delayed_clu(inode, lblk, len);
4367 ext4_da_update_reserve_space(inode, (int) n, 0);
4376 ext4_update_inode_fsync_trans(handle, inode, 1);
4378 ext4_update_inode_fsync_trans(handle, inode, 0);
4384 ext4_ext_show_leaf(inode, path);
4389 trace_ext4_ext_map_blocks_exit(inode, flags, map,
4394 int ext4_ext_truncate(handle_t *handle, struct inode *inode)
4396 struct super_block *sb = inode->i_sb;
4407 EXT4_I(inode)->i_disksize = inode->i_size;
4408 err = ext4_mark_inode_dirty(handle, inode);
4412 last_block = (inode->i_size + sb->s_blocksize - 1)
4415 err = ext4_es_remove_extent(inode, last_block,
4425 err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1);
4438 struct inode *inode = file_inode(file);
4448 BUG_ON(!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS));
4462 credits = ext4_chunk_trans_blocks(inode, len);
4463 depth = ext_depth(inode);
4470 if (depth != ext_depth(inode)) {
4471 credits = ext4_chunk_trans_blocks(inode, len);
4472 depth = ext_depth(inode);
4475 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
4481 ret = ext4_map_blocks(handle, inode, &map, flags);
4483 ext4_debug("inode #%lu: block %u: len %u: "
4485 inode->i_ino, map.m_lblk,
4487 ext4_mark_inode_dirty(handle, inode);
4493 epos = (loff_t)map.m_lblk << inode->i_blkbits;
4494 inode->i_ctime = current_time(inode);
4498 if (ext4_update_inode_size(inode, epos) & 0x1)
4499 inode->i_mtime = inode->i_ctime;
4501 ret2 = ext4_mark_inode_dirty(handle, inode);
4502 ext4_update_inode_fsync_trans(handle, inode, 1);
4509 ext4_should_retry_alloc(inode->i_sb, &retries)) {
4524 struct inode *inode = file_inode(file);
4534 unsigned int blkbits = inode->i_blkbits;
4536 trace_ext4_zero_range(inode, offset, len, mode);
4539 if (ext4_should_journal_data(inode)) {
4540 ret = ext4_force_commit(inode->i_sb);
4566 inode_lock(inode);
4571 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4577 (offset + len > inode->i_size ||
4578 offset + len > EXT4_I(inode)->i_disksize)) {
4580 ret = inode_newsize_ok(inode, new_size);
4588 inode_dio_wait(inode);
4615 down_write(&EXT4_I(inode)->i_mmap_sem);
4617 ret = ext4_break_layouts(inode);
4619 up_write(&EXT4_I(inode)->i_mmap_sem);
4623 ret = ext4_update_disksize_before_punch(inode, offset, len);
4625 up_write(&EXT4_I(inode)->i_mmap_sem);
4629 truncate_pagecache_range(inode, start, end - 1);
4630 inode->i_mtime = inode->i_ctime = current_time(inode);
4634 up_write(&EXT4_I(inode)->i_mmap_sem);
4643 * blocks and update the inode
4645 credits = (2 * ext4_ext_index_trans_blocks(inode, 2)) + 1;
4646 if (ext4_should_journal_data(inode))
4648 handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
4651 ext4_std_error(inode->i_sb, ret);
4655 inode->i_mtime = inode->i_ctime = current_time(inode);
4657 ext4_update_inode_size(inode, new_size);
4658 ret = ext4_mark_inode_dirty(handle, inode);
4662 ret = ext4_zero_partial_blocks(handle, inode, offset, len);
4664 ext4_update_inode_fsync_trans(handle, inode, 1);
4672 inode_unlock(inode);
4685 struct inode *inode = file_inode(file);
4691 unsigned int blkbits = inode->i_blkbits;
4699 if (IS_ENCRYPTED(inode) &&
4709 inode_lock(inode);
4710 ret = ext4_convert_inline_data(inode);
4711 inode_unlock(inode);
4734 trace_ext4_fallocate_enter(inode, offset, len, mode);
4740 inode_lock(inode);
4745 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4751 (offset + len > inode->i_size ||
4752 offset + len > EXT4_I(inode)->i_disksize)) {
4754 ret = inode_newsize_ok(inode, new_size);
4760 inode_dio_wait(inode);
4770 if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) {
4771 ret = ext4_fc_commit(EXT4_SB(inode->i_sb)->s_journal,
4772 EXT4_I(inode)->i_sync_tid);
4775 inode_unlock(inode);
4776 trace_ext4_fallocate_exit(inode, offset, max_blocks, ret);
4791 int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
4797 unsigned int blkbits = inode->i_blkbits;
4807 credits = ext4_chunk_trans_blocks(inode, max_blocks);
4813 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
4820 ret = ext4_map_blocks(handle, inode, &map,
4823 ext4_warning(inode->i_sb,
4824 "inode #%lu: block %u: len %u: "
4826 inode->i_ino, map.m_lblk,
4828 ret2 = ext4_mark_inode_dirty(handle, inode);
4859 ret = ext4_convert_unwritten_extents(handle, io_end->inode,
4872 static int ext4_iomap_xattr_fiemap(struct inode *inode, struct iomap *iomap)
4876 int blockbits = inode->i_sb->s_blocksize_bits;
4880 /* in-inode? */
4881 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
4883 int offset; /* offset of xattr in inode */
4885 error = ext4_get_inode_loc(inode, &iloc);
4890 EXT4_I(inode)->i_extra_isize;
4892 length = EXT4_SB(inode->i_sb)->s_inode_size - offset;
4895 } else if (EXT4_I(inode)->i_file_acl) { /* external block */
4896 physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits;
4897 length = inode->i_sb->s_blocksize;
4900 /* no in-inode or external block for xattr, so return -ENOENT */
4914 static int ext4_iomap_xattr_begin(struct inode *inode, loff_t offset,
4920 error = ext4_iomap_xattr_fiemap(inode, iomap);
4930 static int ext4_fiemap_check_ranges(struct inode *inode, u64 start, u64 *len)
4934 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4935 maxbytes = inode->i_sb->s_maxbytes;
4937 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
4952 int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
4958 error = ext4_ext_precache(inode);
4969 error = ext4_fiemap_check_ranges(inode, start, &len);
4975 return iomap_fiemap(inode, fieinfo, start, len,
4979 return iomap_fiemap(inode, fieinfo, start, len, &ext4_iomap_report_ops);
4982 int ext4_get_es_cache(struct inode *inode, struct fiemap_extent_info *fieinfo,
4989 if (ext4_has_inline_data(inode)) {
4992 down_read(&EXT4_I(inode)->xattr_sem);
4993 has_inline = ext4_has_inline_data(inode);
4994 up_read(&EXT4_I(inode)->xattr_sem);
5000 error = ext4_ext_precache(inode);
5006 error = fiemap_prep(inode, fieinfo, start, &len, 0);
5010 error = ext4_fiemap_check_ranges(inode, start, &len);
5014 start_blk = start >> inode->i_sb->s_blocksize_bits;
5015 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
5024 return ext4_fill_es_cache_info(inode, start_blk, len_blks, fieinfo);
5035 struct inode *inode, handle_t *handle,
5051 /* leaf + sb + inode */
5055 /* extent tree + sb + inode */
5059 restart_credits = ext4_writepage_trans_blocks(inode);
5060 err = ext4_datasem_ensure_credits(handle, inode, credits,
5068 err = ext4_ext_get_access(handle, inode, path + depth);
5080 ext4_ext_try_to_merge_right(inode,
5087 ext4_ext_try_to_merge_right(inode, path,
5092 err = ext4_ext_dirty(handle, inode, path + depth);
5101 err = ext4_ext_get_access(handle, inode, path + depth);
5109 err = ext4_ext_dirty(handle, inode, path + depth);
5127 * block for the @inode are shifted either towards left or right (depending
5132 ext4_ext_shift_extents(struct inode *inode, handle_t *handle,
5143 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
5161 path = ext4_find_extent(inode, start - 1, &path,
5210 path = ext4_find_extent(inode, *iterator, &path,
5217 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
5256 ret = ext4_ext_shift_path_extents(path, shift, inode,
5277 struct inode *inode = file_inode(file);
5278 struct super_block *sb = inode->i_sb;
5290 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5297 trace_ext4_collapse_range(inode, offset, len);
5303 if (ext4_should_journal_data(inode)) {
5304 ret = ext4_force_commit(inode->i_sb);
5309 inode_lock(inode);
5314 if (offset + len >= inode->i_size) {
5320 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5326 inode_dio_wait(inode);
5336 down_write(&EXT4_I(inode)->i_mmap_sem);
5338 ret = ext4_break_layouts(inode);
5351 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset);
5359 ret = filemap_write_and_wait_range(inode->i_mapping, offset + len,
5363 truncate_pagecache(inode, ioffset);
5365 credits = ext4_writepage_trans_blocks(inode);
5366 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5373 down_write(&EXT4_I(inode)->i_data_sem);
5374 ext4_discard_preallocations(inode, 0);
5376 ret = ext4_es_remove_extent(inode, punch_start,
5379 up_write(&EXT4_I(inode)->i_data_sem);
5383 ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1);
5385 up_write(&EXT4_I(inode)->i_data_sem);
5388 ext4_discard_preallocations(inode, 0);
5390 ret = ext4_ext_shift_extents(inode, handle, punch_stop,
5393 up_write(&EXT4_I(inode)->i_data_sem);
5397 new_size = inode->i_size - len;
5398 i_size_write(inode, new_size);
5399 EXT4_I(inode)->i_disksize = new_size;
5401 up_write(&EXT4_I(inode)->i_data_sem);
5402 if (IS_SYNC(inode))
5404 inode->i_mtime = inode->i_ctime = current_time(inode);
5405 ret = ext4_mark_inode_dirty(handle, inode);
5406 ext4_update_inode_fsync_trans(handle, inode, 1);
5412 up_write(&EXT4_I(inode)->i_mmap_sem);
5414 inode_unlock(inode);
5422 * towards right to create a hole in the @inode. Inode size is increased
5428 struct inode *inode = file_inode(file);
5429 struct super_block *sb = inode->i_sb;
5443 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5450 trace_ext4_insert_range(inode, offset, len);
5456 if (ext4_should_journal_data(inode)) {
5457 ret = ext4_force_commit(inode->i_sb);
5462 inode_lock(inode);
5464 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5470 if (len > inode->i_sb->s_maxbytes - inode->i_size) {
5476 if (offset >= inode->i_size) {
5482 inode_dio_wait(inode);
5492 down_write(&EXT4_I(inode)->i_mmap_sem);
5494 ret = ext4_break_layouts(inode);
5504 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
5508 truncate_pagecache(inode, ioffset);
5510 credits = ext4_writepage_trans_blocks(inode);
5511 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5519 inode->i_size += len;
5520 EXT4_I(inode)->i_disksize += len;
5521 inode->i_mtime = inode->i_ctime = current_time(inode);
5522 ret = ext4_mark_inode_dirty(handle, inode);
5526 down_write(&EXT4_I(inode)->i_data_sem);
5527 ext4_discard_preallocations(inode, 0);
5529 path = ext4_find_extent(inode, offset_lblk, NULL, 0);
5531 up_write(&EXT4_I(inode)->i_data_sem);
5535 depth = ext_depth(inode);
5550 ret = ext4_split_extent_at(handle, inode, &path,
5560 up_write(&EXT4_I(inode)->i_data_sem);
5568 ret = ext4_es_remove_extent(inode, offset_lblk,
5571 up_write(&EXT4_I(inode)->i_data_sem);
5579 ret = ext4_ext_shift_extents(inode, handle,
5583 up_write(&EXT4_I(inode)->i_data_sem);
5584 if (IS_SYNC(inode))
5587 ext4_update_inode_fsync_trans(handle, inode, 1);
5593 up_write(&EXT4_I(inode)->i_mmap_sem);
5595 inode_unlock(inode);
5602 * @inode1: First inode
5603 * @inode2: Second inode
5604 * @lblk1: Start block for first inode
5605 * @lblk2: Start block for second inode
5607 * @unwritten: Mark second inode's extents as unwritten after swap
5620 ext4_swap_extents(handle_t *handle, struct inode *inode1,
5621 struct inode *inode2, ext4_lblk_t lblk1, ext4_lblk_t lblk2,
5773 * Looks scarry ah..? second inode already points to new blocks,
5799 * @inode - file containing the logical cluster
5807 int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu)
5809 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5820 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) ||
5821 ext4_has_inline_data(inode))
5825 path = ext4_find_extent(inode, EXT4_C2B(sbi, lclu), NULL, 0);
5832 depth = ext_depth(inode);
5840 EXT4_ERROR_INODE(inode,
5890 int ext4_ext_replay_update_ex(struct inode *inode, ext4_lblk_t start,
5897 path = ext4_find_extent(inode, start, NULL, 0);
5910 down_write(&EXT4_I(inode)->i_data_sem);
5911 ret = ext4_force_split_extent_at(NULL, inode, &ppath, start, 1);
5912 up_write(&EXT4_I(inode)->i_data_sem);
5916 path = ext4_find_extent(inode, start, NULL, 0);
5923 down_write(&EXT4_I(inode)->i_data_sem);
5924 ret = ext4_force_split_extent_at(NULL, inode, &ppath,
5926 up_write(&EXT4_I(inode)->i_data_sem);
5930 path = ext4_find_extent(inode, start, NULL, 0);
5941 down_write(&EXT4_I(inode)->i_data_sem);
5942 ret = ext4_ext_dirty(NULL, inode, &path[path->p_depth]);
5943 up_write(&EXT4_I(inode)->i_data_sem);
5947 ext4_mark_inode_dirty(NULL, inode);
5952 void ext4_ext_replay_shrink_inode(struct inode *inode, ext4_lblk_t end)
5959 path = ext4_find_extent(inode, cur, NULL, 0);
5966 ext4_mark_inode_dirty(NULL, inode);
5973 ext4_ext_try_to_merge(NULL, inode, path, ex);
5974 down_write(&EXT4_I(inode)->i_data_sem);
5975 ext4_ext_dirty(NULL, inode, &path[path->p_depth]);
5976 up_write(&EXT4_I(inode)->i_data_sem);
5977 ext4_mark_inode_dirty(NULL, inode);
5984 static int skip_hole(struct inode *inode, ext4_lblk_t *cur)
5990 map.m_len = ((inode->i_size) >> inode->i_sb->s_blocksize_bits) - *cur;
5992 ret = ext4_map_blocks(NULL, inode, &map, 0);
6001 /* Count number of blocks used by this inode and update i_blocks */
6002 int ext4_ext_replay_set_iblocks(struct inode *inode)
6012 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
6031 ret = ext4_map_blocks(NULL, inode, &map, 0);
6047 ret = skip_hole(inode, &cur);
6050 path = ext4_find_extent(inode, cur, NULL, 0);
6057 path = ext4_find_extent(inode, cur, NULL, 0);
6068 ret = skip_hole(inode, &cur);
6074 path2 = ext4_find_extent(inode, cur, NULL, 0);
6099 inode->i_blocks = numblks << (inode->i_sb->s_blocksize_bits - 9);
6100 ext4_mark_inode_dirty(NULL, inode);
6104 int ext4_ext_clear_bb(struct inode *inode)
6113 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
6131 ret = ext4_map_blocks(NULL, inode, &map, 0);
6135 path = ext4_find_extent(inode, map.m_lblk, NULL, 0);
6139 ext4_mb_mark_bb(inode->i_sb,
6141 ext4_fc_record_regions(inode->i_sb, inode->i_ino,
6147 ext4_mb_mark_bb(inode->i_sb, map.m_pblk, map.m_len, 0);
6148 ext4_fc_record_regions(inode->i_sb, inode->i_ino,