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);
136 int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
144 revoke_cred, ext4_ext_trunc_restart_fn(inode, &dropped));
146 down_write(&EXT4_I(inode)->i_data_sem);
155 static int ext4_ext_get_access(handle_t *handle, struct inode *inode,
163 err = ext4_journal_get_write_access(handle, inode->i_sb,
174 /* path points to leaf/index in inode body */
186 handle_t *handle, struct inode *inode,
191 WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem));
193 ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh));
196 inode, path->p_bh);
201 /* path points to leaf/index in inode body */
202 err = ext4_mark_inode_dirty(handle, inode);
207 #define ext4_ext_dirty(handle, inode, path) \
208 __ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path))
210 static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
252 /* OK. use inode's group */
253 return ext4_inode_to_goal_block(inode);
260 ext4_ext_new_meta_block(handle_t *handle, struct inode *inode,
266 goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
267 newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
272 static inline int ext4_ext_space_block(struct inode *inode, int check)
276 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
285 static inline int ext4_ext_space_block_idx(struct inode *inode, int check)
289 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
298 static inline int ext4_ext_space_root(struct inode *inode, int check)
302 size = sizeof(EXT4_I(inode)->i_data);
312 static inline int ext4_ext_space_root_idx(struct inode *inode, int check)
316 size = sizeof(EXT4_I(inode)->i_data);
327 ext4_force_split_extent_at(handle_t *handle, struct inode *inode,
338 return ext4_split_extent_at(handle, inode, ppath, lblk, unwritten ?
344 ext4_ext_max_entries(struct inode *inode, int depth)
348 if (depth == ext_depth(inode)) {
350 max = ext4_ext_space_root(inode, 1);
352 max = ext4_ext_space_root_idx(inode, 1);
355 max = ext4_ext_space_block(inode, 1);
357 max = ext4_ext_space_block_idx(inode, 1);
363 static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
376 return ext4_inode_block_valid(inode, block, len);
379 static int ext4_valid_extent_idx(struct inode *inode,
384 return ext4_inode_block_valid(inode, block, 1);
387 static int ext4_valid_extent_entries(struct inode *inode,
409 if (depth != ext_depth(inode) &&
413 if (!ext4_valid_extent(inode, ext))
433 if (depth != ext_depth(inode) &&
437 if (!ext4_valid_extent_idx(inode, ext_idx))
455 struct inode *inode, struct ext4_extent_header *eh,
473 max = ext4_ext_max_entries(inode, depth);
486 if (!ext4_valid_extent_entries(inode, eh, lblk, &pblk, depth)) {
495 if (ext_depth(inode) != depth &&
496 !ext4_extent_block_csum_verify(inode, eh)) {
504 ext4_error_inode_err(inode, function, line, 0, -err,
515 #define ext4_ext_check(inode, eh, depth, pblk) \
516 __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk), 0)
518 int ext4_ext_check_inode(struct inode *inode)
520 return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode), 0);
523 static void ext4_cache_extents(struct inode *inode,
536 ext4_es_cache_extent(inode, prev, lblk - prev, ~0,
541 ext4_es_cache_extent(inode, lblk, len,
549 struct inode *inode, struct ext4_extent_idx *idx,
561 bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags);
566 trace_ext4_ext_load_extent(inode, pblk, _RET_IP_);
573 err = __ext4_ext_check(function, line, inode, ext_block_hdr(bh),
583 ext4_cache_extents(inode, eh);
592 #define read_extent_tree_block(inode, idx, depth, flags) \
593 __read_extent_tree_block(__func__, __LINE__, (inode), (idx), \
600 int ext4_ext_precache(struct inode *inode)
602 struct ext4_inode_info *ei = EXT4_I(inode);
607 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
608 return 0; /* not an extent-mapped inode */
611 depth = ext_depth(inode);
626 path[0].p_hdr = ext_inode_hdr(inode);
627 ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0);
643 bh = read_extent_tree_block(inode, path[i].p_idx++,
655 ext4_set_inode_state(inode, EXT4_STATE_EXT_PRECACHED);
663 static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
667 ext_debug(inode, "path:");
670 ext_debug(inode, " %d->%llu",
674 ext_debug(inode, " %d:[%d]%d:%llu ",
680 ext_debug(inode, " []");
682 ext_debug(inode, "\n");
685 static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
687 int depth = ext_depth(inode);
698 ext_debug(inode, "Displaying leaf extents\n");
701 ext_debug(inode, "%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),
705 ext_debug(inode, "\n");
708 static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path,
711 int depth = ext_depth(inode);
718 ext_debug(inode, "%d: move %d:%llu in new index %llu\n",
729 ext_debug(inode, "move %d:%llu:[%d]%d in new leaf %llu\n",
740 #define ext4_ext_show_path(inode, path)
741 #define ext4_ext_show_leaf(inode, path)
742 #define ext4_ext_show_move(inode, path, newblock, level)
751 ext4_ext_binsearch_idx(struct inode *inode,
758 ext_debug(inode, "binsearch for %u(idx): ", block);
764 ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,
775 ext_debug(inode, " -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block),
812 ext4_ext_binsearch(struct inode *inode,
826 ext_debug(inode, "binsearch for %u: ", block);
833 ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,
844 ext_debug(inode, " -> %d:%llu:[%d]%d ",
869 void ext4_ext_tree_init(handle_t *handle, struct inode *inode)
873 eh = ext_inode_hdr(inode);
877 eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
879 ext4_mark_inode_dirty(handle, inode);
883 ext4_find_extent(struct inode *inode, ext4_lblk_t block,
896 eh = ext_inode_hdr(inode);
897 depth = ext_depth(inode);
899 EXT4_ERROR_INODE(inode, "inode has invalid extent depth: %d",
925 ext4_cache_extents(inode, eh);
928 ext_debug(inode, "depth %d: num %d, max %d\n",
931 ext4_ext_binsearch_idx(inode, path + ppos, block);
936 bh = read_extent_tree_block(inode, path[ppos].p_idx, --i, flags);
953 ext4_ext_binsearch(inode, path + ppos, block);
958 ext4_ext_show_path(inode, path);
974 static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
981 err = ext4_ext_get_access(handle, inode, curp);
986 EXT4_ERROR_INODE(inode,
994 EXT4_ERROR_INODE(inode,
1003 ext_debug(inode, "insert new index %d after: %llu\n",
1008 ext_debug(inode, "insert new index %d before: %llu\n",
1014 EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!");
1021 ext_debug(inode, "insert new index %d: "
1032 EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
1036 err = ext4_ext_dirty(handle, inode, curp);
1037 ext4_std_error(inode->i_sb, err);
1052 static int ext4_ext_split(handle_t *handle, struct inode *inode,
1058 int depth = ext_depth(inode);
1078 EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
1083 ext_debug(inode, "leaf will be split."
1088 ext_debug(inode, "leaf will be added."
1110 ext_debug(inode, "allocate %d blocks for indexes/leaf\n", depth - at);
1112 newblock = ext4_ext_new_meta_block(handle, inode, path,
1122 EXT4_ERROR_INODE(inode, "newblock == 0!");
1126 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1133 err = ext4_journal_get_create_access(handle, inode->i_sb, bh,
1140 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1148 EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
1156 ext4_ext_show_move(inode, path, newblock, depth);
1167 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1168 ext4_extent_block_csum_set(inode, neh);
1172 err = ext4_handle_dirty_metadata(handle, inode, bh);
1180 err = ext4_ext_get_access(handle, inode, path + depth);
1184 err = ext4_ext_dirty(handle, inode, path + depth);
1193 EXT4_ERROR_INODE(inode, "k %d < 0!", k);
1198 ext_debug(inode, "create %d intermediate indices\n", k);
1205 bh = sb_getblk(inode->i_sb, newblock);
1212 err = ext4_journal_get_create_access(handle, inode->i_sb, bh,
1220 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1227 ext_debug(inode, "int.index at %d (block %llu): %u -> %llu\n",
1233 EXT4_ERROR_INODE(inode,
1241 ext_debug(inode, "cur 0x%p, last 0x%p\n", path[i].p_idx,
1243 ext4_ext_show_move(inode, path, newblock, i);
1253 inode->i_sb->s_blocksize - ext_size);
1254 ext4_extent_block_csum_set(inode, neh);
1258 err = ext4_handle_dirty_metadata(handle, inode, bh);
1266 err = ext4_ext_get_access(handle, inode, path + i);
1270 err = ext4_ext_dirty(handle, inode, path + i);
1279 err = ext4_ext_insert_index(handle, inode, path + at,
1294 ext4_free_blocks(handle, inode, NULL, ablocks[i], 1,
1311 static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
1317 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
1322 if (ext_depth(inode))
1323 goal = ext4_idx_pblock(EXT_FIRST_INDEX(ext_inode_hdr(inode)));
1328 goal = ext4_inode_to_goal_block(inode);
1329 newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
1334 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1339 err = ext4_journal_get_create_access(handle, inode->i_sb, bh,
1346 ext_size = sizeof(EXT4_I(inode)->i_data);
1348 memmove(bh->b_data, EXT4_I(inode)->i_data, ext_size);
1350 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1356 if (ext_depth(inode))
1357 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1359 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1361 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,
1516 EXT4_ERROR_INODE(inode,
1534 static int ext4_ext_search_right(struct inode *inode,
1547 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1564 EXT4_ERROR_INODE(inode,
1572 EXT4_ERROR_INODE(inode,
1582 EXT4_ERROR_INODE(inode,
1611 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1619 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1705 static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
1709 int depth = ext_depth(inode);
1718 EXT4_ERROR_INODE(inode,
1738 err = ext4_ext_get_access(handle, inode, path + k);
1742 err = ext4_ext_dirty(handle, inode, path + k);
1750 err = ext4_ext_get_access(handle, inode, path + k);
1754 err = ext4_ext_dirty(handle, inode, path + k);
1762 static int ext4_can_extents_be_merged(struct inode *inode,
1801 static int ext4_ext_try_to_merge_right(struct inode *inode,
1809 depth = ext_depth(inode);
1814 if (!ext4_can_extents_be_merged(inode, ex, ex + 1))
1832 EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!");
1840 * an extent tree with a single extent tree leaf block into the inode.
1843 struct inode *inode,
1847 unsigned max_root = ext4_ext_space_root(inode, 0);
1861 ext4_free_metadata_revoke_credits(inode->i_sb, 1)))
1865 * Copy the extent data up to the inode
1880 ext4_free_blocks(handle, inode, NULL, blk, 1,
1886 * tries to collapse the extent tree into the inode.
1889 struct inode *inode,
1897 depth = ext_depth(inode);
1902 merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1);
1905 (void) ext4_ext_try_to_merge_right(inode, path, ex);
1907 ext4_ext_try_to_merge_up(handle, inode, path);
1919 struct inode *inode,
1929 depth = ext_depth(inode);
1967 int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1983 EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
1986 depth = ext_depth(inode);
1990 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2017 if (ext4_can_extents_be_merged(inode, ex, newext)) {
2018 ext_debug(inode, "append [%d]%d block to %u:[%d]%d"
2026 err = ext4_ext_get_access(handle, inode,
2041 if (ext4_can_extents_be_merged(inode, newext, ex)) {
2042 ext_debug(inode, "prepend %u[%d]%d block to %u:[%d]%d"
2051 err = ext4_ext_get_access(handle, inode,
2068 depth = ext_depth(inode);
2079 ext_debug(inode, "next leaf block - %u\n", next);
2081 npath = ext4_find_extent(inode, next, NULL, gb_flags);
2087 ext_debug(inode, "next leaf isn't full(%d)\n",
2092 ext_debug(inode, "next leaf has no free space(%d,%d)\n",
2102 err = ext4_ext_create_new_leaf(handle, inode, mb_flags, gb_flags,
2106 depth = ext_depth(inode);
2112 err = ext4_ext_get_access(handle, inode, path + depth);
2118 ext_debug(inode, "first extent in the leaf: %u:%llu:[%d]%d\n",
2128 ext_debug(inode, "insert %u:%llu:[%d]%d before: "
2139 ext_debug(inode, "insert %u:%llu:[%d]%d after: "
2149 ext_debug(inode, "insert %u:%llu:[%d]%d: "
2170 ext4_ext_try_to_merge(handle, inode, path, nearex);
2174 err = ext4_ext_correct_indexes(handle, inode, path);
2178 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
2185 static int ext4_fill_es_cache_info(struct inode *inode,
2191 unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
2198 if (!ext4_es_lookup_extent(inode, block, &next, &es))
2233 * @inode: inode we lookup in
2244 static ext4_lblk_t ext4_ext_find_hole(struct inode *inode,
2248 int depth = ext_depth(inode);
2277 static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
2288 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
2291 err = ext4_ext_get_access(handle, inode, path);
2302 err = ext4_ext_dirty(handle, inode, path);
2305 ext_debug(inode, "index is empty, remove it, free block %llu\n", leaf);
2306 trace_ext4_ext_rm_idx(inode, leaf);
2308 ext4_free_blocks(handle, inode, NULL, leaf, 1,
2315 err = ext4_ext_get_access(handle, inode, path);
2319 err = ext4_ext_dirty(handle, inode, path);
2333 int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks,
2337 int depth = ext_depth(inode);
2353 ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);
2358 return ext4_chunk_trans_blocks(inode, nrblocks);
2370 int ext4_ext_index_trans_blocks(struct inode *inode, int extents)
2376 if (ext4_has_inline_data(inode))
2379 depth = ext_depth(inode);
2389 static inline int get_default_free_blocks_flags(struct inode *inode)
2391 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) ||
2392 ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE))
2394 else if (ext4_should_journal_data(inode))
2403 * @inode - file containing the cluster
2414 static void ext4_rereserve_cluster(struct inode *inode, ext4_lblk_t lblk)
2416 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2417 struct ext4_inode_info *ei = EXT4_I(inode);
2419 dquot_reclaim_block(inode, EXT4_C2B(sbi, 1));
2427 ext4_remove_pending(inode, lblk);
2430 static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
2435 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2458 if (ext_depth(inode) > sbi->s_depth_max)
2459 sbi->s_depth_max = ext_depth(inode);
2463 trace_ext4_remove_blocks(inode, ex, from, to, partial);
2474 flags = get_default_free_blocks_flags(inode);
2475 if (ext4_is_pending(inode, partial->lblk))
2477 ext4_free_blocks(handle, inode, NULL,
2481 ext4_rereserve_cluster(inode, partial->lblk);
2495 flags = get_default_free_blocks_flags(inode);
2501 if (ext4_is_pending(inode, to))
2503 ext4_free_blocks(handle, inode, NULL,
2507 ext4_rereserve_cluster(inode, to);
2509 flags = get_default_free_blocks_flags(inode);
2521 ext4_free_blocks(handle, inode, NULL, pblk, num, flags);
2556 * @inode: The files inode
2566 ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
2571 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2573 int depth = ext_depth(inode), credits, revoke_credits;
2584 ext_debug(inode, "truncate since %u in leaf to %u\n", start, end);
2589 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2600 trace_ext4_ext_rm_leaf(inode, start, ex, partial);
2610 ext_debug(inode, "remove ext %u:[%d]%d\n", ex_ee_block,
2617 ext_debug(inode, " border %u:%u\n", a, b);
2638 EXT4_ERROR_INODE(inode,
2653 * 3 for leaf, sb, and inode plus 2 (bmap and group
2658 credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
2661 credits += (ext_depth(inode)) + 1;
2663 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
2670 ext4_free_metadata_revoke_credits(inode->i_sb,
2671 ext_depth(inode)) +
2672 ext4_free_data_revoke_credits(inode, b - a + 1);
2674 err = ext4_datasem_ensure_credits(handle, inode, credits,
2682 err = ext4_ext_get_access(handle, inode, path + depth);
2686 err = ext4_remove_blocks(handle, inode, ex, partial, a, b);
2722 err = ext4_ext_dirty(handle, inode, path + depth);
2726 ext_debug(inode, "new extent: %u:%u:%llu\n", ex_ee_block, num,
2734 err = ext4_ext_correct_indexes(handle, inode, path);
2746 int flags = get_default_free_blocks_flags(inode);
2748 if (ext4_is_pending(inode, partial->lblk))
2750 ext4_free_blocks(handle, inode, NULL,
2754 ext4_rereserve_cluster(inode, partial->lblk);
2762 err = ext4_ext_rm_idx(handle, inode, path, depth);
2789 int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
2792 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2793 int depth = ext_depth(inode);
2803 ext_debug(inode, "truncate since %u to %u\n", start, end);
2806 handle = ext4_journal_start_with_revoke(inode, EXT4_HT_TRUNCATE,
2808 ext4_free_metadata_revoke_credits(inode->i_sb, depth));
2813 trace_ext4_ext_remove_space(inode, start, end, depth);
2828 path = ext4_find_extent(inode, end, NULL,
2834 depth = ext_depth(inode);
2835 /* Leaf not may not exist only if inode has no blocks at all */
2839 EXT4_ERROR_INODE(inode,
2875 err = ext4_force_split_extent_at(handle, inode, &path,
2893 err = ext4_ext_search_right(inode, path, &lblk, &pblk,
2907 depth = ext_depth(inode);
2921 path[0].p_hdr = ext_inode_hdr(inode);
2924 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
2934 err = ext4_ext_rm_leaf(handle, inode, path,
2945 ext_debug(inode, "initialize header\n");
2953 ext_debug(inode, "init index ptr: hdr 0x%p, num %d\n",
2961 ext_debug(inode, "level %d - index, first 0x%p, cur 0x%p\n",
2967 ext_debug(inode, "move to level %d (block %llu)\n",
2970 bh = read_extent_tree_block(inode, path[i].p_idx,
2997 err = ext4_ext_rm_idx(handle, inode, path, i);
3003 ext_debug(inode, "return to level %d\n", i);
3007 trace_ext4_ext_remove_space_done(inode, start, end, depth, &partial,
3015 int flags = get_default_free_blocks_flags(inode);
3017 if (ext4_is_pending(inode, partial.lblk))
3019 ext4_free_blocks(handle, inode, NULL,
3023 ext4_rereserve_cluster(inode, partial.lblk);
3033 err = ext4_ext_get_access(handle, inode, path);
3035 ext_inode_hdr(inode)->eh_depth = 0;
3036 ext_inode_hdr(inode)->eh_max =
3037 cpu_to_le16(ext4_ext_space_root(inode, 0));
3038 err = ext4_ext_dirty(handle, inode, path);
3102 static void ext4_zeroout_es(struct inode *inode, struct ext4_extent *ex)
3115 ext4_es_insert_extent(inode, ee_block, ee_len, ee_pblock,
3120 static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
3127 return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,
3135 * @inode: the file inode
3153 struct inode *inode,
3170 ext_debug(inode, "logical block %llu\n", (unsigned long long)split);
3172 ext4_ext_show_leaf(inode, path);
3174 depth = ext_depth(inode);
3186 err = ext4_ext_get_access(handle, inode, path + depth);
3202 ext4_ext_try_to_merge(handle, inode, path, ex);
3204 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3218 err = ext4_ext_dirty(handle, inode, path + depth);
3229 err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags);
3236 err = ext4_ext_zeroout(inode, ex2);
3243 err = ext4_ext_zeroout(inode, ex);
3251 err = ext4_ext_zeroout(inode, &orig_ex);
3262 ext4_ext_try_to_merge(handle, inode, path, ex);
3263 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3266 ext4_zeroout_es(inode, &zero_ex);
3282 ext4_ext_dirty(handle, inode, path + path->p_depth);
3285 ext4_ext_show_leaf(inode, path);
3301 struct inode *inode,
3316 depth = ext_depth(inode);
3330 err = ext4_split_extent_at(handle, inode, ppath,
3341 path = ext4_find_extent(inode, map->m_lblk, ppath, flags);
3344 depth = ext_depth(inode);
3347 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3360 err = ext4_split_extent_at(handle, inode, ppath,
3366 ext4_ext_show_leaf(inode, path);
3392 struct inode *inode,
3409 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3412 sbi = EXT4_SB(inode->i_sb);
3413 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3414 >> inode->i_sb->s_blocksize_bits;
3418 depth = ext_depth(inode);
3426 trace_ext4_ext_convert_to_initialized_enter(inode, map, ex);
3474 err = ext4_ext_get_access(handle, inode, path + depth);
3478 trace_ext4_ext_convert_to_initialized_fastpath(inode,
3520 err = ext4_ext_get_access(handle, inode, path + depth);
3524 trace_ext4_ext_convert_to_initialized_fastpath(inode,
3542 err = ext4_ext_dirty(handle, inode, path + depth);
3559 (inode->i_sb->s_blocksize_bits - 10);
3586 err = ext4_ext_zeroout(inode, &zero_ex1);
3600 err = ext4_ext_zeroout(inode, &zero_ex2);
3612 err = ext4_split_extent(handle, inode, ppath, &split_map, split_flag,
3619 ext4_zeroout_es(inode, &zero_ex1);
3620 ext4_zeroout_es(inode, &zero_ex2);
3650 struct inode *inode,
3662 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3665 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3666 >> inode->i_sb->s_blocksize_bits;
3673 depth = ext_depth(inode);
3688 return ext4_split_extent(handle, inode, ppath, map, split_flag, flags);
3692 struct inode *inode,
3703 depth = ext_depth(inode);
3708 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3719 ext4_warning(inode->i_sb, "Inode (%ld) finished: extent logical block %llu,"
3721 inode->i_ino, (unsigned long long)ee_block, ee_len,
3724 err = ext4_split_convert_extents(handle, inode, map, ppath,
3728 path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3731 depth = ext_depth(inode);
3735 err = ext4_ext_get_access(handle, inode, path + depth);
3744 ext4_ext_try_to_merge(handle, inode, path, ex);
3747 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3749 ext4_ext_show_leaf(inode, path);
3754 convert_initialized_extent(handle_t *handle, struct inode *inode,
3773 depth = ext_depth(inode);
3778 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3782 err = ext4_split_convert_extents(handle, inode, map, ppath,
3786 path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3789 depth = ext_depth(inode);
3792 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3798 err = ext4_ext_get_access(handle, inode, path + depth);
3807 ext4_ext_try_to_merge(handle, inode, path, ex);
3810 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3813 ext4_ext_show_leaf(inode, path);
3815 ext4_update_inode_fsync_trans(handle, inode, 1);
3825 ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode,
3834 ext_debug(inode, "logical block %llu, max_blocks %u, flags 0x%x, allocated %u\n",
3837 ext4_ext_show_leaf(inode, path);
3845 trace_ext4_ext_handle_unwritten_extents(inode, map, flags,
3850 ret = ext4_split_convert_extents(handle, inode, map, ppath,
3861 EXT4_ERROR_INODE(inode,
3872 err = ext4_convert_unwritten_extents_endio(handle, inode, map,
3876 ext4_update_inode_fsync_trans(handle, inode, 1);
3907 ret = ext4_ext_convert_to_initialized(handle, inode, map, ppath, flags);
3912 ext4_update_inode_fsync_trans(handle, inode, 1);
3918 EXT4_ERROR_INODE(inode, "unexpected ret == 0, m_len = %u",
3934 ext4_ext_show_leaf(inode, path);
3949 * find blocks that were already in the inode's extent tree. Hence,
3951 * the extent from the inode's extent tree. There are three cases we
4048 static ext4_lblk_t ext4_ext_determine_insert_hole(struct inode *inode,
4056 len = ext4_ext_find_hole(inode, path, &hole_start);
4058 ext4_es_find_extent_range(inode, &ext4_es_is_delayed, hole_start,
4095 ext_debug(inode, " -> %u:%u\n", hole_start, len);
4096 ext4_es_insert_extent(inode, hole_start, len, ~0, EXTENT_STATUS_HOLE);
4110 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
4111 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
4123 int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
4128 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4136 ext_debug(inode, "blocks %u/%u requested\n", map->m_lblk, map->m_len);
4137 trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
4140 path = ext4_find_extent(inode, map->m_lblk, NULL, 0);
4147 depth = ext_depth(inode);
4155 EXT4_ERROR_INODE(inode, "bad extent address "
4176 trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len);
4183 ext_debug(inode, "%u fit into %u:%d -> %llu\n",
4193 inode, map, &path, &allocated);
4201 ext4_ext_show_leaf(inode, path);
4206 handle, inode, map, &path, flags,
4223 len = ext4_ext_determine_insert_hole(inode, path, map->m_lblk);
4241 get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {
4249 err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
4253 err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2);
4260 get_implied_cluster_alloc(inode->i_sb, map, &ex2, path)) {
4281 err = ext4_ext_check_overlap(sbi, inode, &newex, path);
4288 ar.inode = inode;
4289 ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);
4303 if (S_ISREG(inode->i_mode))
4319 ext_debug(inode, "allocate new block: goal %llu, found %llu/%u, requested %u\n",
4335 err = ext4_ext_insert_extent(handle, inode, &path, &newex, flags);
4345 ext4_discard_preallocations(inode, 0);
4348 ext4_free_blocks(handle, inode, NULL, newblock,
4361 if (test_opt(inode->i_sb, DELALLOC) && allocated_clusters) {
4367 ext4_da_update_reserve_space(inode, allocated_clusters,
4386 n = ext4_es_delayed_clu(inode, lblk, len);
4388 ext4_da_update_reserve_space(inode, (int) n, 0);
4397 ext4_update_inode_fsync_trans(handle, inode, 1);
4399 ext4_update_inode_fsync_trans(handle, inode, 0);
4405 ext4_ext_show_leaf(inode, path);
4409 trace_ext4_ext_map_blocks_exit(inode, flags, map,
4414 int ext4_ext_truncate(handle_t *handle, struct inode *inode)
4416 struct super_block *sb = inode->i_sb;
4427 EXT4_I(inode)->i_disksize = inode->i_size;
4428 err = ext4_mark_inode_dirty(handle, inode);
4432 last_block = (inode->i_size + sb->s_blocksize - 1)
4434 ext4_es_remove_extent(inode, last_block, EXT_MAX_BLOCKS - last_block);
4437 err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1);
4449 struct inode *inode = file_inode(file);
4458 BUG_ON(!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS));
4472 credits = ext4_chunk_trans_blocks(inode, len);
4473 depth = ext_depth(inode);
4480 if (depth != ext_depth(inode)) {
4481 credits = ext4_chunk_trans_blocks(inode, len);
4482 depth = ext_depth(inode);
4485 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
4491 ret = ext4_map_blocks(handle, inode, &map, flags);
4493 ext4_debug("inode #%lu: block %u: len %u: "
4495 inode->i_ino, map.m_lblk,
4497 ext4_mark_inode_dirty(handle, inode);
4507 epos = (loff_t)map.m_lblk << inode->i_blkbits;
4508 inode_set_ctime_current(inode);
4512 if (ext4_update_inode_size(inode, epos) & 0x1)
4513 inode->i_mtime = inode_get_ctime(inode);
4515 ret2 = ext4_mark_inode_dirty(handle, inode);
4516 ext4_update_inode_fsync_trans(handle, inode, 1);
4522 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
4535 struct inode *inode = file_inode(file);
4546 unsigned int blkbits = inode->i_blkbits;
4548 trace_ext4_zero_range(inode, offset, len, mode);
4572 inode_lock(inode);
4577 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4583 (offset + len > inode->i_size ||
4584 offset + len > EXT4_I(inode)->i_disksize)) {
4586 ret = inode_newsize_ok(inode, new_size);
4594 inode_dio_wait(inode);
4623 ret = ext4_break_layouts(inode);
4629 ret = ext4_update_disksize_before_punch(inode, offset, len);
4640 if (ext4_should_journal_data(inode)) {
4650 truncate_pagecache_range(inode, start, end - 1);
4651 inode->i_mtime = inode_set_ctime_current(inode);
4664 * blocks and update the inode
4666 credits = (2 * ext4_ext_index_trans_blocks(inode, 2)) + 1;
4667 if (ext4_should_journal_data(inode))
4669 handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
4672 ext4_std_error(inode->i_sb, ret);
4676 inode->i_mtime = inode_set_ctime_current(inode);
4678 ext4_update_inode_size(inode, new_size);
4679 ret = ext4_mark_inode_dirty(handle, inode);
4683 ret = ext4_zero_partial_blocks(handle, inode, offset, len);
4685 ext4_update_inode_fsync_trans(handle, inode, 1);
4693 inode_unlock(inode);
4706 struct inode *inode = file_inode(file);
4712 unsigned int blkbits = inode->i_blkbits;
4720 if (IS_ENCRYPTED(inode) &&
4730 inode_lock(inode);
4731 ret = ext4_convert_inline_data(inode);
4732 inode_unlock(inode);
4755 trace_ext4_fallocate_enter(inode, offset, len, mode);
4761 inode_lock(inode);
4766 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4772 (offset + len > inode->i_size ||
4773 offset + len > EXT4_I(inode)->i_disksize)) {
4775 ret = inode_newsize_ok(inode, new_size);
4781 inode_dio_wait(inode);
4791 if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) {
4792 ret = ext4_fc_commit(EXT4_SB(inode->i_sb)->s_journal,
4793 EXT4_I(inode)->i_sync_tid);
4796 inode_unlock(inode);
4797 trace_ext4_fallocate_exit(inode, offset, max_blocks, ret);
4812 int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
4818 unsigned int blkbits = inode->i_blkbits;
4828 credits = ext4_chunk_trans_blocks(inode, max_blocks);
4834 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
4841 ret = ext4_map_blocks(handle, inode, &map,
4844 ext4_warning(inode->i_sb,
4845 "inode #%lu: block %u: len %u: "
4847 inode->i_ino, map.m_lblk,
4849 ret2 = ext4_mark_inode_dirty(handle, inode);
4880 ret = ext4_convert_unwritten_extents(handle, io_end->inode,
4893 static int ext4_iomap_xattr_fiemap(struct inode *inode, struct iomap *iomap)
4897 int blockbits = inode->i_sb->s_blocksize_bits;
4901 /* in-inode? */
4902 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
4904 int offset; /* offset of xattr in inode */
4906 error = ext4_get_inode_loc(inode, &iloc);
4911 EXT4_I(inode)->i_extra_isize;
4913 length = EXT4_SB(inode->i_sb)->s_inode_size - offset;
4916 } else if (EXT4_I(inode)->i_file_acl) { /* external block */
4917 physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits;
4918 length = inode->i_sb->s_blocksize;
4921 /* no in-inode or external block for xattr, so return -ENOENT */
4935 static int ext4_iomap_xattr_begin(struct inode *inode, loff_t offset,
4941 error = ext4_iomap_xattr_fiemap(inode, iomap);
4951 static int ext4_fiemap_check_ranges(struct inode *inode, u64 start, u64 *len)
4955 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4956 maxbytes = inode->i_sb->s_maxbytes;
4958 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
4973 int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
4979 error = ext4_ext_precache(inode);
4990 error = ext4_fiemap_check_ranges(inode, start, &len);
4996 return iomap_fiemap(inode, fieinfo, start, len,
5000 return iomap_fiemap(inode, fieinfo, start, len, &ext4_iomap_report_ops);
5003 int ext4_get_es_cache(struct inode *inode, struct fiemap_extent_info *fieinfo,
5010 if (ext4_has_inline_data(inode)) {
5013 down_read(&EXT4_I(inode)->xattr_sem);
5014 has_inline = ext4_has_inline_data(inode);
5015 up_read(&EXT4_I(inode)->xattr_sem);
5021 error = ext4_ext_precache(inode);
5027 error = fiemap_prep(inode, fieinfo, start, &len, 0);
5031 error = ext4_fiemap_check_ranges(inode, start, &len);
5035 start_blk = start >> inode->i_sb->s_blocksize_bits;
5036 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
5045 return ext4_fill_es_cache_info(inode, start_blk, len_blks, fieinfo);
5056 struct inode *inode, handle_t *handle,
5072 /* leaf + sb + inode */
5076 /* extent tree + sb + inode */
5080 restart_credits = ext4_writepage_trans_blocks(inode);
5081 err = ext4_datasem_ensure_credits(handle, inode, credits,
5089 err = ext4_ext_get_access(handle, inode, path + depth);
5101 ext4_ext_try_to_merge_right(inode,
5108 ext4_ext_try_to_merge_right(inode, path,
5113 err = ext4_ext_dirty(handle, inode, path + depth);
5122 err = ext4_ext_get_access(handle, inode, path + depth);
5130 err = ext4_ext_dirty(handle, inode, path + depth);
5148 * block for the @inode are shifted either towards left or right (depending
5153 ext4_ext_shift_extents(struct inode *inode, handle_t *handle,
5164 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
5182 path = ext4_find_extent(inode, start - 1, &path,
5231 path = ext4_find_extent(inode, *iterator, &path,
5238 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
5277 ret = ext4_ext_shift_path_extents(path, shift, inode,
5297 struct inode *inode = file_inode(file);
5298 struct super_block *sb = inode->i_sb;
5299 struct address_space *mapping = inode->i_mapping;
5311 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5318 trace_ext4_collapse_range(inode, offset, len);
5323 inode_lock(inode);
5328 if (offset + len >= inode->i_size) {
5334 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5340 inode_dio_wait(inode);
5352 ret = ext4_break_layouts(inode);
5377 truncate_pagecache(inode, ioffset);
5379 credits = ext4_writepage_trans_blocks(inode);
5380 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5387 down_write(&EXT4_I(inode)->i_data_sem);
5388 ext4_discard_preallocations(inode, 0);
5389 ext4_es_remove_extent(inode, punch_start, EXT_MAX_BLOCKS - punch_start);
5391 ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1);
5393 up_write(&EXT4_I(inode)->i_data_sem);
5396 ext4_discard_preallocations(inode, 0);
5398 ret = ext4_ext_shift_extents(inode, handle, punch_stop,
5401 up_write(&EXT4_I(inode)->i_data_sem);
5405 new_size = inode->i_size - len;
5406 i_size_write(inode, new_size);
5407 EXT4_I(inode)->i_disksize = new_size;
5409 up_write(&EXT4_I(inode)->i_data_sem);
5410 if (IS_SYNC(inode))
5412 inode->i_mtime = inode_set_ctime_current(inode);
5413 ret = ext4_mark_inode_dirty(handle, inode);
5414 ext4_update_inode_fsync_trans(handle, inode, 1);
5421 inode_unlock(inode);
5429 * towards right to create a hole in the @inode. Inode size is increased
5435 struct inode *inode = file_inode(file);
5436 struct super_block *sb = inode->i_sb;
5437 struct address_space *mapping = inode->i_mapping;
5451 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5458 trace_ext4_insert_range(inode, offset, len);
5463 inode_lock(inode);
5465 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5471 if (len > inode->i_sb->s_maxbytes - inode->i_size) {
5477 if (offset >= inode->i_size) {
5483 inode_dio_wait(inode);
5495 ret = ext4_break_layouts(inode);
5505 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
5509 truncate_pagecache(inode, ioffset);
5511 credits = ext4_writepage_trans_blocks(inode);
5512 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5520 inode->i_size += len;
5521 EXT4_I(inode)->i_disksize += len;
5522 inode->i_mtime = inode_set_ctime_current(inode);
5523 ret = ext4_mark_inode_dirty(handle, inode);
5527 down_write(&EXT4_I(inode)->i_data_sem);
5528 ext4_discard_preallocations(inode, 0);
5530 path = ext4_find_extent(inode, offset_lblk, NULL, 0);
5532 up_write(&EXT4_I(inode)->i_data_sem);
5536 depth = ext_depth(inode);
5551 ret = ext4_split_extent_at(handle, inode, &path,
5560 up_write(&EXT4_I(inode)->i_data_sem);
5567 ext4_es_remove_extent(inode, offset_lblk, EXT_MAX_BLOCKS - offset_lblk);
5573 ret = ext4_ext_shift_extents(inode, handle,
5576 up_write(&EXT4_I(inode)->i_data_sem);
5577 if (IS_SYNC(inode))
5580 ext4_update_inode_fsync_trans(handle, inode, 1);
5587 inode_unlock(inode);
5594 * @inode1: First inode
5595 * @inode2: Second inode
5596 * @lblk1: Start block for first inode
5597 * @lblk2: Start block for second inode
5599 * @unwritten: Mark second inode's extents as unwritten after swap
5612 ext4_swap_extents(handle_t *handle, struct inode *inode1,
5613 struct inode *inode2, ext4_lblk_t lblk1, ext4_lblk_t lblk2,
5761 * Looks scarry ah..? second inode already points to new blocks,
5785 * @inode - file containing the logical cluster
5793 int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu)
5795 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5806 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) ||
5807 ext4_has_inline_data(inode))
5811 path = ext4_find_extent(inode, EXT4_C2B(sbi, lclu), NULL, 0);
5818 depth = ext_depth(inode);
5826 EXT4_ERROR_INODE(inode,
5875 int ext4_ext_replay_update_ex(struct inode *inode, ext4_lblk_t start,
5882 path = ext4_find_extent(inode, start, NULL, 0);
5895 down_write(&EXT4_I(inode)->i_data_sem);
5896 ret = ext4_force_split_extent_at(NULL, inode, &ppath, start, 1);
5897 up_write(&EXT4_I(inode)->i_data_sem);
5901 path = ext4_find_extent(inode, start, NULL, 0);
5908 down_write(&EXT4_I(inode)->i_data_sem);
5909 ret = ext4_force_split_extent_at(NULL, inode, &ppath,
5911 up_write(&EXT4_I(inode)->i_data_sem);
5915 path = ext4_find_extent(inode, start, NULL, 0);
5926 down_write(&EXT4_I(inode)->i_data_sem);
5927 ret = ext4_ext_dirty(NULL, inode, &path[path->p_depth]);
5928 up_write(&EXT4_I(inode)->i_data_sem);
5931 ext4_mark_inode_dirty(NULL, inode);
5936 void ext4_ext_replay_shrink_inode(struct inode *inode, ext4_lblk_t end)
5943 path = ext4_find_extent(inode, cur, NULL, 0);
5949 ext4_mark_inode_dirty(NULL, inode);
5956 ext4_ext_try_to_merge(NULL, inode, path, ex);
5957 down_write(&EXT4_I(inode)->i_data_sem);
5958 ext4_ext_dirty(NULL, inode, &path[path->p_depth]);
5959 up_write(&EXT4_I(inode)->i_data_sem);
5960 ext4_mark_inode_dirty(NULL, inode);
5966 static int skip_hole(struct inode *inode, ext4_lblk_t *cur)
5972 map.m_len = ((inode->i_size) >> inode->i_sb->s_blocksize_bits) - *cur;
5974 ret = ext4_map_blocks(NULL, inode, &map, 0);
5983 /* Count number of blocks used by this inode and update i_blocks */
5984 int ext4_ext_replay_set_iblocks(struct inode *inode)
5994 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
6011 ret = ext4_map_blocks(NULL, inode, &map, 0);
6027 ret = skip_hole(inode, &cur);
6030 path = ext4_find_extent(inode, cur, NULL, 0);
6036 path = ext4_find_extent(inode, cur, NULL, 0);
6046 ret = skip_hole(inode, &cur);
6051 path2 = ext4_find_extent(inode, cur, NULL, 0);
6072 inode->i_blocks = numblks << (inode->i_sb->s_blocksize_bits - 9);
6073 ext4_mark_inode_dirty(NULL, inode);
6077 int ext4_ext_clear_bb(struct inode *inode)
6085 if (ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA))
6089 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
6105 ret = ext4_map_blocks(NULL, inode, &map, 0);
6109 path = ext4_find_extent(inode, map.m_lblk, NULL, 0);
6113 ext4_mb_mark_bb(inode->i_sb,
6115 ext4_fc_record_regions(inode->i_sb, inode->i_ino,
6120 ext4_mb_mark_bb(inode->i_sb, map.m_pblk, map.m_len, 0);
6121 ext4_fc_record_regions(inode->i_sb, inode->i_ino,