Lines Matching +full:path +full:- +full:map
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
15 * - ext4*_error() should be used in some situations
16 * - analyze all BUG()/BUG_ON(), use -EIO where appropriate
17 * - smart tree reduction
30 #include <linux/backing-dev.h>
53 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_extent_block_csum()
56 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh, in ext4_extent_block_csum()
66 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_extent_block_csum_verify()
70 if (et->et_checksum != ext4_extent_block_csum(inode, eh)) in ext4_extent_block_csum_verify()
80 if (!ext4_has_metadata_csum(inode->i_sb)) in ext4_extent_block_csum_set()
84 et->et_checksum = ext4_extent_block_csum(inode, eh); in ext4_extent_block_csum_set()
104 up_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_trunc_restart_fn()
127 down_write(&EXT4_I(inode)->i_data_sem); in ext4_datasem_ensure_credits()
133 * - EROFS
134 * - ENOMEM
137 struct ext4_ext_path *path) in ext4_ext_get_access() argument
141 if (path->p_bh) { in ext4_ext_get_access()
142 /* path points to block */ in ext4_ext_get_access()
143 BUFFER_TRACE(path->p_bh, "get_write_access"); in ext4_ext_get_access()
144 err = ext4_journal_get_write_access(handle, path->p_bh); in ext4_ext_get_access()
152 clear_buffer_verified(path->p_bh); in ext4_ext_get_access()
154 /* path points to leaf/index in inode body */ in ext4_ext_get_access()
155 /* we use in-core data, no need to protect them */ in ext4_ext_get_access()
161 * - EROFS
162 * - ENOMEM
163 * - EIO
167 struct ext4_ext_path *path) in __ext4_ext_dirty() argument
171 WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem)); in __ext4_ext_dirty()
172 if (path->p_bh) { in __ext4_ext_dirty()
173 ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh)); in __ext4_ext_dirty()
174 /* path points to block */ in __ext4_ext_dirty()
176 inode, path->p_bh); in __ext4_ext_dirty()
177 /* Extents updating done, re-set verified flag */ in __ext4_ext_dirty()
179 set_buffer_verified(path->p_bh); in __ext4_ext_dirty()
181 /* path points to leaf/index in inode body */ in __ext4_ext_dirty()
187 #define ext4_ext_dirty(handle, inode, path) \ argument
188 __ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path))
191 struct ext4_ext_path *path, in ext4_ext_find_goal() argument
194 if (path) { in ext4_ext_find_goal()
195 int depth = path->p_depth; in ext4_ext_find_goal()
201 * non-sparse --- i.e., in the case of libbfd writing in ext4_ext_find_goal()
202 * an ELF object sections out-of-order but in a way in ext4_ext_find_goal()
206 * non-ideal if we are writing a sparse file such as in ext4_ext_find_goal()
215 ex = path[depth].p_ext; in ext4_ext_find_goal()
218 ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block); in ext4_ext_find_goal()
221 return ext_pblk + (block - ext_block); in ext4_ext_find_goal()
223 return ext_pblk - (ext_block - block); in ext4_ext_find_goal()
228 if (path[depth].p_bh) in ext4_ext_find_goal()
229 return path[depth].p_bh->b_blocknr; in ext4_ext_find_goal()
241 struct ext4_ext_path *path, in ext4_ext_new_meta_block() argument
246 goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block)); in ext4_ext_new_meta_block()
256 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) in ext4_ext_space_block()
269 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) in ext4_ext_space_block_idx()
282 size = sizeof(EXT4_I(inode)->i_data); in ext4_ext_space_root()
283 size -= sizeof(struct ext4_extent_header); in ext4_ext_space_root()
296 size = sizeof(EXT4_I(inode)->i_data); in ext4_ext_space_root_idx()
297 size -= sizeof(struct ext4_extent_header); in ext4_ext_space_root_idx()
311 struct ext4_ext_path *path = *ppath; in ext4_force_split_extent_at() local
312 int unwritten = ext4_ext_is_unwritten(path[path->p_depth].p_ext); in ext4_force_split_extent_at()
347 ext4_lblk_t lblock = le32_to_cpu(ext->ee_block); in ext4_valid_extent()
351 * - zero length in ext4_valid_extent()
352 * - overflow/wrap-around in ext4_valid_extent()
376 if (eh->eh_entries == 0) in ext4_valid_extent_entries()
379 entries = le16_to_cpu(eh->eh_entries); in ext4_valid_extent_entries()
390 lblk != le32_to_cpu(ext->ee_block)) in ext4_valid_extent_entries()
397 lblock = le32_to_cpu(ext->ee_block); in ext4_valid_extent_entries()
404 entries--; in ext4_valid_extent_entries()
414 lblk != le32_to_cpu(ext_idx->ei_block)) in ext4_valid_extent_entries()
421 lblock = le32_to_cpu(ext_idx->ei_block); in ext4_valid_extent_entries()
427 entries--; in ext4_valid_extent_entries()
439 int max = 0, err = -EFSCORRUPTED; in __ext4_ext_check()
441 if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) { in __ext4_ext_check()
445 if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) { in __ext4_ext_check()
449 if (unlikely(eh->eh_max == 0)) { in __ext4_ext_check()
454 if (unlikely(le16_to_cpu(eh->eh_max) > max)) { in __ext4_ext_check()
458 if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) { in __ext4_ext_check()
462 if (unlikely((eh->eh_entries == 0) && (depth > 0))) { in __ext4_ext_check()
474 /* Verify checksum on non-root extent tree nodes */ in __ext4_ext_check()
478 err = -EFSBADCRC; in __ext4_ext_check()
484 ext4_error_inode_err(inode, function, line, 0, -err, in __ext4_ext_check()
485 "pblk %llu bad header/extent: %s - magic %x, " in __ext4_ext_check()
488 le16_to_cpu(eh->eh_magic), in __ext4_ext_check()
489 le16_to_cpu(eh->eh_entries), in __ext4_ext_check()
490 le16_to_cpu(eh->eh_max), in __ext4_ext_check()
491 max, le16_to_cpu(eh->eh_depth), depth); in __ext4_ext_check()
510 for (i = le16_to_cpu(eh->eh_entries); i > 0; i--, ex++) { in ext4_cache_extents()
512 ext4_lblk_t lblk = le32_to_cpu(ex->ee_block); in ext4_cache_extents()
516 ext4_es_cache_extent(inode, prev, lblk - prev, ~0, in ext4_cache_extents()
541 bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags); in __read_extent_tree_block()
543 return ERR_PTR(-ENOMEM); in __read_extent_tree_block()
554 depth, pblk, le32_to_cpu(idx->ei_block)); in __read_extent_tree_block()
583 struct ext4_ext_path *path = NULL; in ext4_ext_precache() local
588 return 0; /* not an extent-mapped inode */ in ext4_ext_precache()
590 down_read(&ei->i_data_sem); in ext4_ext_precache()
595 up_read(&ei->i_data_sem); in ext4_ext_precache()
599 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path), in ext4_ext_precache()
601 if (path == NULL) { in ext4_ext_precache()
602 up_read(&ei->i_data_sem); in ext4_ext_precache()
603 return -ENOMEM; in ext4_ext_precache()
606 path[0].p_hdr = ext_inode_hdr(inode); in ext4_ext_precache()
607 ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0); in ext4_ext_precache()
610 path[0].p_idx = EXT_FIRST_INDEX(path[0].p_hdr); in ext4_ext_precache()
617 path[i].p_idx > EXT_LAST_INDEX(path[i].p_hdr)) { in ext4_ext_precache()
618 brelse(path[i].p_bh); in ext4_ext_precache()
619 path[i].p_bh = NULL; in ext4_ext_precache()
620 i--; in ext4_ext_precache()
623 bh = read_extent_tree_block(inode, path[i].p_idx++, in ext4_ext_precache()
624 depth - i - 1, in ext4_ext_precache()
631 path[i].p_bh = bh; in ext4_ext_precache()
632 path[i].p_hdr = ext_block_hdr(bh); in ext4_ext_precache()
633 path[i].p_idx = EXT_FIRST_INDEX(path[i].p_hdr); in ext4_ext_precache()
637 up_read(&ei->i_data_sem); in ext4_ext_precache()
638 ext4_ext_drop_refs(path); in ext4_ext_precache()
639 kfree(path); in ext4_ext_precache()
644 static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path) in ext4_ext_show_path() argument
646 int k, l = path->p_depth; in ext4_ext_show_path()
648 ext_debug(inode, "path:"); in ext4_ext_show_path()
649 for (k = 0; k <= l; k++, path++) { in ext4_ext_show_path()
650 if (path->p_idx) { in ext4_ext_show_path()
651 ext_debug(inode, " %d->%llu", in ext4_ext_show_path()
652 le32_to_cpu(path->p_idx->ei_block), in ext4_ext_show_path()
653 ext4_idx_pblock(path->p_idx)); in ext4_ext_show_path()
654 } else if (path->p_ext) { in ext4_ext_show_path()
656 le32_to_cpu(path->p_ext->ee_block), in ext4_ext_show_path()
657 ext4_ext_is_unwritten(path->p_ext), in ext4_ext_show_path()
658 ext4_ext_get_actual_len(path->p_ext), in ext4_ext_show_path()
659 ext4_ext_pblock(path->p_ext)); in ext4_ext_show_path()
666 static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path) in ext4_ext_show_leaf() argument
673 if (!path) in ext4_ext_show_leaf()
676 eh = path[depth].p_hdr; in ext4_ext_show_leaf()
681 for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) { in ext4_ext_show_leaf()
682 ext_debug(inode, "%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block), in ext4_ext_show_leaf()
689 static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path, in ext4_ext_show_move() argument
697 idx = path[level].p_idx; in ext4_ext_show_move()
698 while (idx <= EXT_MAX_INDEX(path[level].p_hdr)) { in ext4_ext_show_move()
700 level, le32_to_cpu(idx->ei_block), in ext4_ext_show_move()
708 ex = path[depth].p_ext; in ext4_ext_show_move()
709 while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) { in ext4_ext_show_move()
711 le32_to_cpu(ex->ee_block), in ext4_ext_show_move()
721 #define ext4_ext_show_path(inode, path) argument
722 #define ext4_ext_show_leaf(inode, path) argument
723 #define ext4_ext_show_move(inode, path, newblock, level) argument
726 void ext4_ext_drop_refs(struct ext4_ext_path *path) in ext4_ext_drop_refs() argument
730 if (!path) in ext4_ext_drop_refs()
732 depth = path->p_depth; in ext4_ext_drop_refs()
733 for (i = 0; i <= depth; i++, path++) { in ext4_ext_drop_refs()
734 brelse(path->p_bh); in ext4_ext_drop_refs()
735 path->p_bh = NULL; in ext4_ext_drop_refs()
746 struct ext4_ext_path *path, ext4_lblk_t block) in ext4_ext_binsearch_idx() argument
748 struct ext4_extent_header *eh = path->p_hdr; in ext4_ext_binsearch_idx()
757 m = l + (r - l) / 2; in ext4_ext_binsearch_idx()
758 if (block < le32_to_cpu(m->ei_block)) in ext4_ext_binsearch_idx()
759 r = m - 1; in ext4_ext_binsearch_idx()
763 le32_to_cpu(l->ei_block), m, le32_to_cpu(m->ei_block), in ext4_ext_binsearch_idx()
764 r, le32_to_cpu(r->ei_block)); in ext4_ext_binsearch_idx()
767 path->p_idx = l - 1; in ext4_ext_binsearch_idx()
768 ext_debug(inode, " -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block), in ext4_ext_binsearch_idx()
769 ext4_idx_pblock(path->p_idx)); in ext4_ext_binsearch_idx()
777 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) { in ext4_ext_binsearch_idx()
778 if (k != 0 && le32_to_cpu(ix->ei_block) <= in ext4_ext_binsearch_idx()
779 le32_to_cpu(ix[-1].ei_block)) { in ext4_ext_binsearch_idx()
784 le32_to_cpu(ix->ei_block), in ext4_ext_binsearch_idx()
785 le32_to_cpu(ix[-1].ei_block)); in ext4_ext_binsearch_idx()
787 BUG_ON(k && le32_to_cpu(ix->ei_block) in ext4_ext_binsearch_idx()
788 <= le32_to_cpu(ix[-1].ei_block)); in ext4_ext_binsearch_idx()
789 if (block < le32_to_cpu(ix->ei_block)) in ext4_ext_binsearch_idx()
793 BUG_ON(chix != path->p_idx); in ext4_ext_binsearch_idx()
806 struct ext4_ext_path *path, ext4_lblk_t block) in ext4_ext_binsearch() argument
808 struct ext4_extent_header *eh = path->p_hdr; in ext4_ext_binsearch()
811 if (eh->eh_entries == 0) { in ext4_ext_binsearch()
825 m = l + (r - l) / 2; in ext4_ext_binsearch()
826 if (block < le32_to_cpu(m->ee_block)) in ext4_ext_binsearch()
827 r = m - 1; in ext4_ext_binsearch()
831 le32_to_cpu(l->ee_block), m, le32_to_cpu(m->ee_block), in ext4_ext_binsearch()
832 r, le32_to_cpu(r->ee_block)); in ext4_ext_binsearch()
835 path->p_ext = l - 1; in ext4_ext_binsearch()
836 ext_debug(inode, " -> %d:%llu:[%d]%d ", in ext4_ext_binsearch()
837 le32_to_cpu(path->p_ext->ee_block), in ext4_ext_binsearch()
838 ext4_ext_pblock(path->p_ext), in ext4_ext_binsearch()
839 ext4_ext_is_unwritten(path->p_ext), in ext4_ext_binsearch()
840 ext4_ext_get_actual_len(path->p_ext)); in ext4_ext_binsearch()
848 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) { in ext4_ext_binsearch()
849 BUG_ON(k && le32_to_cpu(ex->ee_block) in ext4_ext_binsearch()
850 <= le32_to_cpu(ex[-1].ee_block)); in ext4_ext_binsearch()
851 if (block < le32_to_cpu(ex->ee_block)) in ext4_ext_binsearch()
855 BUG_ON(chex != path->p_ext); in ext4_ext_binsearch()
866 eh->eh_depth = 0; in ext4_ext_tree_init()
867 eh->eh_entries = 0; in ext4_ext_tree_init()
868 eh->eh_magic = EXT4_EXT_MAGIC; in ext4_ext_tree_init()
869 eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0)); in ext4_ext_tree_init()
870 eh->eh_generation = 0; in ext4_ext_tree_init()
880 struct ext4_ext_path *path = orig_path ? *orig_path : NULL; in ext4_find_extent() local
893 ret = -EFSCORRUPTED; in ext4_find_extent()
897 if (path) { in ext4_find_extent()
898 ext4_ext_drop_refs(path); in ext4_find_extent()
899 if (depth > path[0].p_maxdepth) { in ext4_find_extent()
900 kfree(path); in ext4_find_extent()
901 *orig_path = path = NULL; in ext4_find_extent()
904 if (!path) { in ext4_find_extent()
906 path = kcalloc(depth + 2, sizeof(struct ext4_ext_path), in ext4_find_extent()
908 if (unlikely(!path)) in ext4_find_extent()
909 return ERR_PTR(-ENOMEM); in ext4_find_extent()
910 path[0].p_maxdepth = depth + 1; in ext4_find_extent()
912 path[0].p_hdr = eh; in ext4_find_extent()
913 path[0].p_bh = NULL; in ext4_find_extent()
921 ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max)); in ext4_find_extent()
923 ext4_ext_binsearch_idx(inode, path + ppos, block); in ext4_find_extent()
924 path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx); in ext4_find_extent()
925 path[ppos].p_depth = i; in ext4_find_extent()
926 path[ppos].p_ext = NULL; in ext4_find_extent()
928 bh = read_extent_tree_block(inode, path[ppos].p_idx, --i, flags); in ext4_find_extent()
936 path[ppos].p_bh = bh; in ext4_find_extent()
937 path[ppos].p_hdr = eh; in ext4_find_extent()
940 path[ppos].p_depth = i; in ext4_find_extent()
941 path[ppos].p_ext = NULL; in ext4_find_extent()
942 path[ppos].p_idx = NULL; in ext4_find_extent()
945 ext4_ext_binsearch(inode, path + ppos, block); in ext4_find_extent()
947 if (path[ppos].p_ext) in ext4_find_extent()
948 path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext); in ext4_find_extent()
950 ext4_ext_show_path(inode, path); in ext4_find_extent()
952 return path; in ext4_find_extent()
955 ext4_ext_drop_refs(path); in ext4_find_extent()
956 kfree(path); in ext4_find_extent()
978 if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) { in ext4_ext_insert_index()
981 logical, le32_to_cpu(curp->p_idx->ei_block)); in ext4_ext_insert_index()
982 return -EFSCORRUPTED; in ext4_ext_insert_index()
985 if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries) in ext4_ext_insert_index()
986 >= le16_to_cpu(curp->p_hdr->eh_max))) { in ext4_ext_insert_index()
989 le16_to_cpu(curp->p_hdr->eh_entries), in ext4_ext_insert_index()
990 le16_to_cpu(curp->p_hdr->eh_max)); in ext4_ext_insert_index()
991 return -EFSCORRUPTED; in ext4_ext_insert_index()
994 if (logical > le32_to_cpu(curp->p_idx->ei_block)) { in ext4_ext_insert_index()
998 ix = curp->p_idx + 1; in ext4_ext_insert_index()
1003 ix = curp->p_idx; in ext4_ext_insert_index()
1006 len = EXT_LAST_INDEX(curp->p_hdr) - ix + 1; in ext4_ext_insert_index()
1015 if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) { in ext4_ext_insert_index()
1017 return -EFSCORRUPTED; in ext4_ext_insert_index()
1020 ix->ei_block = cpu_to_le32(logical); in ext4_ext_insert_index()
1022 le16_add_cpu(&curp->p_hdr->eh_entries, 1); in ext4_ext_insert_index()
1024 if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) { in ext4_ext_insert_index()
1026 return -EFSCORRUPTED; in ext4_ext_insert_index()
1030 ext4_std_error(inode->i_sb, err); in ext4_ext_insert_index()
1037 * inserts new subtree into the path, using free index entry
1039 * - allocates all needed blocks (new leaf and all intermediate index blocks)
1040 * - makes decision where to split
1041 * - moves remaining extents and index entries (right to the split point)
1043 * - initializes subtree
1047 struct ext4_ext_path *path, in ext4_ext_split() argument
1070 if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) { in ext4_ext_split()
1072 return -EFSCORRUPTED; in ext4_ext_split()
1074 if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) { in ext4_ext_split()
1075 border = path[depth].p_ext[1].ee_block; in ext4_ext_split()
1080 border = newext->ee_block; in ext4_ext_split()
1088 * and mark filesystem read-only. index won't in ext4_ext_split()
1100 return -ENOMEM; in ext4_ext_split()
1103 ext_debug(inode, "allocate %d blocks for indexes/leaf\n", depth - at); in ext4_ext_split()
1104 for (a = 0; a < depth - at; a++) { in ext4_ext_split()
1105 newblock = ext4_ext_new_meta_block(handle, inode, path, in ext4_ext_split()
1113 newblock = ablocks[--a]; in ext4_ext_split()
1116 err = -EFSCORRUPTED; in ext4_ext_split()
1119 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); in ext4_ext_split()
1121 err = -ENOMEM; in ext4_ext_split()
1131 neh->eh_entries = 0; in ext4_ext_split()
1132 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0)); in ext4_ext_split()
1133 neh->eh_magic = EXT4_EXT_MAGIC; in ext4_ext_split()
1134 neh->eh_depth = 0; in ext4_ext_split()
1135 neh->eh_generation = 0; in ext4_ext_split()
1137 /* move remainder of path[depth] to the new leaf */ in ext4_ext_split()
1138 if (unlikely(path[depth].p_hdr->eh_entries != in ext4_ext_split()
1139 path[depth].p_hdr->eh_max)) { in ext4_ext_split()
1141 path[depth].p_hdr->eh_entries, in ext4_ext_split()
1142 path[depth].p_hdr->eh_max); in ext4_ext_split()
1143 err = -EFSCORRUPTED; in ext4_ext_split()
1147 m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++; in ext4_ext_split()
1148 ext4_ext_show_move(inode, path, newblock, depth); in ext4_ext_split()
1152 memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m); in ext4_ext_split()
1153 le16_add_cpu(&neh->eh_entries, m); in ext4_ext_split()
1158 sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries); in ext4_ext_split()
1159 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size); in ext4_ext_split()
1172 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_split()
1175 le16_add_cpu(&path[depth].p_hdr->eh_entries, -m); in ext4_ext_split()
1176 err = ext4_ext_dirty(handle, inode, path + depth); in ext4_ext_split()
1183 k = depth - at - 1; in ext4_ext_split()
1186 err = -EFSCORRUPTED; in ext4_ext_split()
1193 i = depth - 1; in ext4_ext_split()
1194 while (k--) { in ext4_ext_split()
1196 newblock = ablocks[--a]; in ext4_ext_split()
1197 bh = sb_getblk(inode->i_sb, newblock); in ext4_ext_split()
1199 err = -ENOMEM; in ext4_ext_split()
1209 neh->eh_entries = cpu_to_le16(1); in ext4_ext_split()
1210 neh->eh_magic = EXT4_EXT_MAGIC; in ext4_ext_split()
1211 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0)); in ext4_ext_split()
1212 neh->eh_depth = cpu_to_le16(depth - i); in ext4_ext_split()
1213 neh->eh_generation = 0; in ext4_ext_split()
1215 fidx->ei_block = border; in ext4_ext_split()
1218 ext_debug(inode, "int.index at %d (block %llu): %u -> %llu\n", in ext4_ext_split()
1221 /* move remainder of path[i] to the new index block */ in ext4_ext_split()
1222 if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) != in ext4_ext_split()
1223 EXT_LAST_INDEX(path[i].p_hdr))) { in ext4_ext_split()
1226 le32_to_cpu(path[i].p_ext->ee_block)); in ext4_ext_split()
1227 err = -EFSCORRUPTED; in ext4_ext_split()
1231 m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++; in ext4_ext_split()
1232 ext_debug(inode, "cur 0x%p, last 0x%p\n", path[i].p_idx, in ext4_ext_split()
1233 EXT_MAX_INDEX(path[i].p_hdr)); in ext4_ext_split()
1234 ext4_ext_show_move(inode, path, newblock, i); in ext4_ext_split()
1236 memmove(++fidx, path[i].p_idx, in ext4_ext_split()
1238 le16_add_cpu(&neh->eh_entries, m); in ext4_ext_split()
1242 (sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries)); in ext4_ext_split()
1243 memset(bh->b_data + ext_size, 0, in ext4_ext_split()
1244 inode->i_sb->s_blocksize - ext_size); in ext4_ext_split()
1257 err = ext4_ext_get_access(handle, inode, path + i); in ext4_ext_split()
1260 le16_add_cpu(&path[i].p_hdr->eh_entries, -m); in ext4_ext_split()
1261 err = ext4_ext_dirty(handle, inode, path + i); in ext4_ext_split()
1266 i--; in ext4_ext_split()
1270 err = ext4_ext_insert_index(handle, inode, path + at, in ext4_ext_split()
1297 * - allocates new block
1298 * - moves top-level data (index block or leaf) into the new block
1299 * - initializes new top-level, creating index that points to the
1308 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; in ext4_ext_grow_indepth()
1315 if (goal > le32_to_cpu(es->s_first_data_block)) { in ext4_ext_grow_indepth()
1317 goal--; in ext4_ext_grow_indepth()
1325 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); in ext4_ext_grow_indepth()
1327 return -ENOMEM; in ext4_ext_grow_indepth()
1336 ext_size = sizeof(EXT4_I(inode)->i_data); in ext4_ext_grow_indepth()
1337 /* move top-level index/leaf into new block */ in ext4_ext_grow_indepth()
1338 memmove(bh->b_data, EXT4_I(inode)->i_data, ext_size); in ext4_ext_grow_indepth()
1340 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size); in ext4_ext_grow_indepth()
1347 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0)); in ext4_ext_grow_indepth()
1349 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0)); in ext4_ext_grow_indepth()
1350 neh->eh_magic = EXT4_EXT_MAGIC; in ext4_ext_grow_indepth()
1359 /* Update top-level index: num,max,pointer */ in ext4_ext_grow_indepth()
1361 neh->eh_entries = cpu_to_le16(1); in ext4_ext_grow_indepth()
1363 if (neh->eh_depth == 0) { in ext4_ext_grow_indepth()
1365 neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0)); in ext4_ext_grow_indepth()
1366 EXT_FIRST_INDEX(neh)->ei_block = in ext4_ext_grow_indepth()
1367 EXT_FIRST_EXTENT(neh)->ee_block; in ext4_ext_grow_indepth()
1370 le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max), in ext4_ext_grow_indepth()
1371 le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block), in ext4_ext_grow_indepth()
1374 le16_add_cpu(&neh->eh_depth, 1); in ext4_ext_grow_indepth()
1385 * if no free index is found, then it requests in-depth growing.
1393 struct ext4_ext_path *path = *ppath; in ext4_ext_create_new_leaf() local
1401 curp = path + depth; in ext4_ext_create_new_leaf()
1403 i--; in ext4_ext_create_new_leaf()
1404 curp--; in ext4_ext_create_new_leaf()
1412 err = ext4_ext_split(handle, inode, mb_flags, path, newext, i); in ext4_ext_create_new_leaf()
1416 /* refill path */ in ext4_ext_create_new_leaf()
1417 path = ext4_find_extent(inode, in ext4_ext_create_new_leaf()
1418 (ext4_lblk_t)le32_to_cpu(newext->ee_block), in ext4_ext_create_new_leaf()
1420 if (IS_ERR(path)) in ext4_ext_create_new_leaf()
1421 err = PTR_ERR(path); in ext4_ext_create_new_leaf()
1428 /* refill path */ in ext4_ext_create_new_leaf()
1429 path = ext4_find_extent(inode, in ext4_ext_create_new_leaf()
1430 (ext4_lblk_t)le32_to_cpu(newext->ee_block), in ext4_ext_create_new_leaf()
1432 if (IS_ERR(path)) { in ext4_ext_create_new_leaf()
1433 err = PTR_ERR(path); in ext4_ext_create_new_leaf()
1438 * only first (depth 0 -> 1) produces free space; in ext4_ext_create_new_leaf()
1442 if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) { in ext4_ext_create_new_leaf()
1460 struct ext4_ext_path *path, in ext4_ext_search_left() argument
1467 if (unlikely(path == NULL)) { in ext4_ext_search_left()
1468 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); in ext4_ext_search_left()
1469 return -EFSCORRUPTED; in ext4_ext_search_left()
1471 depth = path->p_depth; in ext4_ext_search_left()
1474 if (depth == 0 && path->p_ext == NULL) in ext4_ext_search_left()
1477 /* usually extent in the path covers blocks smaller in ext4_ext_search_left()
1481 ex = path[depth].p_ext; in ext4_ext_search_left()
1483 if (*logical < le32_to_cpu(ex->ee_block)) { in ext4_ext_search_left()
1484 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) { in ext4_ext_search_left()
1487 *logical, le32_to_cpu(ex->ee_block)); in ext4_ext_search_left()
1488 return -EFSCORRUPTED; in ext4_ext_search_left()
1490 while (--depth >= 0) { in ext4_ext_search_left()
1491 ix = path[depth].p_idx; in ext4_ext_search_left()
1492 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) { in ext4_ext_search_left()
1495 ix != NULL ? le32_to_cpu(ix->ei_block) : 0, in ext4_ext_search_left()
1496 EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ? in ext4_ext_search_left()
1497 le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0, in ext4_ext_search_left()
1499 return -EFSCORRUPTED; in ext4_ext_search_left()
1505 if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) { in ext4_ext_search_left()
1508 *logical, le32_to_cpu(ex->ee_block), ee_len); in ext4_ext_search_left()
1509 return -EFSCORRUPTED; in ext4_ext_search_left()
1512 *logical = le32_to_cpu(ex->ee_block) + ee_len - 1; in ext4_ext_search_left()
1513 *phys = ext4_ext_pblock(ex) + ee_len - 1; in ext4_ext_search_left()
1525 struct ext4_ext_path *path, in ext4_ext_search_right() argument
1536 if (unlikely(path == NULL)) { in ext4_ext_search_right()
1537 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); in ext4_ext_search_right()
1538 return -EFSCORRUPTED; in ext4_ext_search_right()
1540 depth = path->p_depth; in ext4_ext_search_right()
1543 if (depth == 0 && path->p_ext == NULL) in ext4_ext_search_right()
1546 /* usually extent in the path covers blocks smaller in ext4_ext_search_right()
1550 ex = path[depth].p_ext; in ext4_ext_search_right()
1552 if (*logical < le32_to_cpu(ex->ee_block)) { in ext4_ext_search_right()
1553 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) { in ext4_ext_search_right()
1555 "first_extent(path[%d].p_hdr) != ex", in ext4_ext_search_right()
1557 return -EFSCORRUPTED; in ext4_ext_search_right()
1559 while (--depth >= 0) { in ext4_ext_search_right()
1560 ix = path[depth].p_idx; in ext4_ext_search_right()
1561 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) { in ext4_ext_search_right()
1565 return -EFSCORRUPTED; in ext4_ext_search_right()
1571 if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) { in ext4_ext_search_right()
1574 *logical, le32_to_cpu(ex->ee_block), ee_len); in ext4_ext_search_right()
1575 return -EFSCORRUPTED; in ext4_ext_search_right()
1578 if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) { in ext4_ext_search_right()
1585 while (--depth >= 0) { in ext4_ext_search_right()
1586 ix = path[depth].p_idx; in ext4_ext_search_right()
1587 if (ix != EXT_LAST_INDEX(path[depth].p_hdr)) in ext4_ext_search_right()
1599 while (++depth < path->p_depth) { in ext4_ext_search_right()
1601 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0); in ext4_ext_search_right()
1609 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0); in ext4_ext_search_right()
1615 *logical = le32_to_cpu(ex->ee_block); in ext4_ext_search_right()
1632 ext4_ext_next_allocated_block(struct ext4_ext_path *path) in ext4_ext_next_allocated_block() argument
1636 BUG_ON(path == NULL); in ext4_ext_next_allocated_block()
1637 depth = path->p_depth; in ext4_ext_next_allocated_block()
1639 if (depth == 0 && path->p_ext == NULL) in ext4_ext_next_allocated_block()
1643 struct ext4_ext_path *p = &path[depth]; in ext4_ext_next_allocated_block()
1645 if (depth == path->p_depth) { in ext4_ext_next_allocated_block()
1647 if (p->p_ext && p->p_ext != EXT_LAST_EXTENT(p->p_hdr)) in ext4_ext_next_allocated_block()
1648 return le32_to_cpu(p->p_ext[1].ee_block); in ext4_ext_next_allocated_block()
1651 if (p->p_idx != EXT_LAST_INDEX(p->p_hdr)) in ext4_ext_next_allocated_block()
1652 return le32_to_cpu(p->p_idx[1].ei_block); in ext4_ext_next_allocated_block()
1654 depth--; in ext4_ext_next_allocated_block()
1664 static ext4_lblk_t ext4_ext_next_leaf_block(struct ext4_ext_path *path) in ext4_ext_next_leaf_block() argument
1668 BUG_ON(path == NULL); in ext4_ext_next_leaf_block()
1669 depth = path->p_depth; in ext4_ext_next_leaf_block()
1671 /* zero-tree has no leaf blocks at all */ in ext4_ext_next_leaf_block()
1676 depth--; in ext4_ext_next_leaf_block()
1679 if (path[depth].p_idx != in ext4_ext_next_leaf_block()
1680 EXT_LAST_INDEX(path[depth].p_hdr)) in ext4_ext_next_leaf_block()
1682 le32_to_cpu(path[depth].p_idx[1].ei_block); in ext4_ext_next_leaf_block()
1683 depth--; in ext4_ext_next_leaf_block()
1696 struct ext4_ext_path *path) in ext4_ext_correct_indexes() argument
1704 eh = path[depth].p_hdr; in ext4_ext_correct_indexes()
1705 ex = path[depth].p_ext; in ext4_ext_correct_indexes()
1710 return -EFSCORRUPTED; in ext4_ext_correct_indexes()
1726 k = depth - 1; in ext4_ext_correct_indexes()
1727 border = path[depth].p_ext->ee_block; in ext4_ext_correct_indexes()
1728 err = ext4_ext_get_access(handle, inode, path + k); in ext4_ext_correct_indexes()
1731 path[k].p_idx->ei_block = border; in ext4_ext_correct_indexes()
1732 err = ext4_ext_dirty(handle, inode, path + k); in ext4_ext_correct_indexes()
1736 while (k--) { in ext4_ext_correct_indexes()
1737 /* change all left-side indexes */ in ext4_ext_correct_indexes()
1738 if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr)) in ext4_ext_correct_indexes()
1740 err = ext4_ext_get_access(handle, inode, path + k); in ext4_ext_correct_indexes()
1743 path[k].p_idx->ei_block = border; in ext4_ext_correct_indexes()
1744 err = ext4_ext_dirty(handle, inode, path + k); in ext4_ext_correct_indexes()
1764 if (le32_to_cpu(ex1->ee_block) + ext1_ee_len != in ext4_can_extents_be_merged()
1765 le32_to_cpu(ex2->ee_block)) in ext4_can_extents_be_merged()
1787 * left, pass "ex - 1" as argument instead of "ex".
1792 struct ext4_ext_path *path, in ext4_ext_try_to_merge_right() argument
1800 BUG_ON(path[depth].p_hdr == NULL); in ext4_ext_try_to_merge_right()
1801 eh = path[depth].p_hdr; in ext4_ext_try_to_merge_right()
1808 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) in ext4_ext_try_to_merge_right()
1814 len = (EXT_LAST_EXTENT(eh) - ex - 1) in ext4_ext_try_to_merge_right()
1818 le16_add_cpu(&eh->eh_entries, -1); in ext4_ext_try_to_merge_right()
1820 WARN_ON(eh->eh_entries == 0); in ext4_ext_try_to_merge_right()
1821 if (!eh->eh_entries) in ext4_ext_try_to_merge_right()
1822 EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!"); in ext4_ext_try_to_merge_right()
1834 struct ext4_ext_path *path) in ext4_ext_try_to_merge_up() argument
1840 if ((path[0].p_depth != 1) || in ext4_ext_try_to_merge_up()
1841 (le16_to_cpu(path[0].p_hdr->eh_entries) != 1) || in ext4_ext_try_to_merge_up()
1842 (le16_to_cpu(path[1].p_hdr->eh_entries) > max_root)) in ext4_ext_try_to_merge_up()
1851 ext4_free_metadata_revoke_credits(inode->i_sb, 1))) in ext4_ext_try_to_merge_up()
1857 blk = ext4_idx_pblock(path[0].p_idx); in ext4_ext_try_to_merge_up()
1858 s = le16_to_cpu(path[1].p_hdr->eh_entries) * in ext4_ext_try_to_merge_up()
1862 path[1].p_maxdepth = path[0].p_maxdepth; in ext4_ext_try_to_merge_up()
1863 memcpy(path[0].p_hdr, path[1].p_hdr, s); in ext4_ext_try_to_merge_up()
1864 path[0].p_depth = 0; in ext4_ext_try_to_merge_up()
1865 path[0].p_ext = EXT_FIRST_EXTENT(path[0].p_hdr) + in ext4_ext_try_to_merge_up()
1866 (path[1].p_ext - EXT_FIRST_EXTENT(path[1].p_hdr)); in ext4_ext_try_to_merge_up()
1867 path[0].p_hdr->eh_max = cpu_to_le16(max_root); in ext4_ext_try_to_merge_up()
1869 brelse(path[1].p_bh); in ext4_ext_try_to_merge_up()
1880 struct ext4_ext_path *path, in ext4_ext_try_to_merge() argument
1888 BUG_ON(path[depth].p_hdr == NULL); in ext4_ext_try_to_merge()
1889 eh = path[depth].p_hdr; in ext4_ext_try_to_merge()
1892 merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1); in ext4_ext_try_to_merge()
1895 (void) ext4_ext_try_to_merge_right(inode, path, ex); in ext4_ext_try_to_merge()
1897 ext4_ext_try_to_merge_up(handle, inode, path); in ext4_ext_try_to_merge()
1911 struct ext4_ext_path *path) in ext4_ext_check_overlap() argument
1917 b1 = le32_to_cpu(newext->ee_block); in ext4_ext_check_overlap()
1920 if (!path[depth].p_ext) in ext4_ext_check_overlap()
1922 b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block)); in ext4_ext_check_overlap()
1925 * get the next allocated block if the extent in the path in ext4_ext_check_overlap()
1929 b2 = ext4_ext_next_allocated_block(path); in ext4_ext_check_overlap()
1937 len1 = EXT_MAX_BLOCKS - b1; in ext4_ext_check_overlap()
1938 newext->ee_len = cpu_to_le16(len1); in ext4_ext_check_overlap()
1944 newext->ee_len = cpu_to_le16(b2 - b1); in ext4_ext_check_overlap()
1955 * creating new leaf in the no-space case.
1961 struct ext4_ext_path *path = *ppath; in ext4_ext_insert_extent() local
1974 return -EFSCORRUPTED; in ext4_ext_insert_extent()
1977 ex = path[depth].p_ext; in ext4_ext_insert_extent()
1978 eh = path[depth].p_hdr; in ext4_ext_insert_extent()
1979 if (unlikely(path[depth].p_hdr == NULL)) { in ext4_ext_insert_extent()
1980 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); in ext4_ext_insert_extent()
1981 return -EFSCORRUPTED; in ext4_ext_insert_extent()
1995 (le32_to_cpu(ex->ee_block) + in ext4_ext_insert_extent()
1997 le32_to_cpu(newext->ee_block))) { in ext4_ext_insert_extent()
2001 (le32_to_cpu(newext->ee_block) + in ext4_ext_insert_extent()
2003 le32_to_cpu(ex->ee_block))) in ext4_ext_insert_extent()
2004 ex -= 1; in ext4_ext_insert_extent()
2012 le32_to_cpu(ex->ee_block), in ext4_ext_insert_extent()
2017 path + depth); in ext4_ext_insert_extent()
2021 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) in ext4_ext_insert_extent()
2025 eh = path[depth].p_hdr; in ext4_ext_insert_extent()
2035 le32_to_cpu(newext->ee_block), in ext4_ext_insert_extent()
2038 le32_to_cpu(ex->ee_block), in ext4_ext_insert_extent()
2043 path + depth); in ext4_ext_insert_extent()
2048 ex->ee_block = newext->ee_block; in ext4_ext_insert_extent()
2050 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) in ext4_ext_insert_extent()
2054 eh = path[depth].p_hdr; in ext4_ext_insert_extent()
2061 eh = path[depth].p_hdr; in ext4_ext_insert_extent()
2062 if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) in ext4_ext_insert_extent()
2068 if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)) in ext4_ext_insert_extent()
2069 next = ext4_ext_next_leaf_block(path); in ext4_ext_insert_extent()
2071 ext_debug(inode, "next leaf block - %u\n", next); in ext4_ext_insert_extent()
2076 BUG_ON(npath->p_depth != path->p_depth); in ext4_ext_insert_extent()
2078 if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) { in ext4_ext_insert_extent()
2080 le16_to_cpu(eh->eh_entries)); in ext4_ext_insert_extent()
2081 path = npath; in ext4_ext_insert_extent()
2085 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max)); in ext4_ext_insert_extent()
2099 eh = path[depth].p_hdr; in ext4_ext_insert_extent()
2102 nearex = path[depth].p_ext; in ext4_ext_insert_extent()
2104 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_insert_extent()
2111 le32_to_cpu(newext->ee_block), in ext4_ext_insert_extent()
2117 if (le32_to_cpu(newext->ee_block) in ext4_ext_insert_extent()
2118 > le32_to_cpu(nearex->ee_block)) { in ext4_ext_insert_extent()
2122 le32_to_cpu(newext->ee_block), in ext4_ext_insert_extent()
2130 BUG_ON(newext->ee_block == nearex->ee_block); in ext4_ext_insert_extent()
2133 le32_to_cpu(newext->ee_block), in ext4_ext_insert_extent()
2139 len = EXT_LAST_EXTENT(eh) - nearex + 1; in ext4_ext_insert_extent()
2143 le32_to_cpu(newext->ee_block), in ext4_ext_insert_extent()
2153 le16_add_cpu(&eh->eh_entries, 1); in ext4_ext_insert_extent()
2154 path[depth].p_ext = nearex; in ext4_ext_insert_extent()
2155 nearex->ee_block = newext->ee_block; in ext4_ext_insert_extent()
2157 nearex->ee_len = newext->ee_len; in ext4_ext_insert_extent()
2162 ext4_ext_try_to_merge(handle, inode, path, nearex); in ext4_ext_insert_extent()
2166 err = ext4_ext_correct_indexes(handle, inode, path); in ext4_ext_insert_extent()
2170 err = ext4_ext_dirty(handle, inode, path + path->p_depth); in ext4_ext_insert_extent()
2182 ext4_lblk_t next, end = block + num - 1; in ext4_fill_es_cache_info()
2184 unsigned char blksize_bits = inode->i_sb->s_blocksize_bits; in ext4_fill_es_cache_info()
2225 * ext4_ext_determine_hole - determine hole around given block
2227 * @path: path in extent tree to @lblk
2231 * block. We don't try too hard to find the beginning of the hole but @path
2238 struct ext4_ext_path *path, in ext4_ext_determine_hole() argument
2245 ex = path[depth].p_ext; in ext4_ext_determine_hole()
2247 /* there is no extent yet, so gap is [0;-] */ in ext4_ext_determine_hole()
2250 } else if (*lblk < le32_to_cpu(ex->ee_block)) { in ext4_ext_determine_hole()
2251 len = le32_to_cpu(ex->ee_block) - *lblk; in ext4_ext_determine_hole()
2252 } else if (*lblk >= le32_to_cpu(ex->ee_block) in ext4_ext_determine_hole()
2256 *lblk = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex); in ext4_ext_determine_hole()
2257 next = ext4_ext_next_allocated_block(path); in ext4_ext_determine_hole()
2259 len = next - *lblk; in ext4_ext_determine_hole()
2278 hole_start + hole_len - 1, &es); in ext4_ext_put_gap_in_cache()
2283 hole_len = min(es.es_lblk - hole_start, hole_len); in ext4_ext_put_gap_in_cache()
2285 ext_debug(inode, " -> %u:%u\n", hole_start, hole_len); in ext4_ext_put_gap_in_cache()
2295 struct ext4_ext_path *path, int depth) in ext4_ext_rm_idx() argument
2301 depth--; in ext4_ext_rm_idx()
2302 path = path + depth; in ext4_ext_rm_idx()
2303 leaf = ext4_idx_pblock(path->p_idx); in ext4_ext_rm_idx()
2304 if (unlikely(path->p_hdr->eh_entries == 0)) { in ext4_ext_rm_idx()
2305 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0"); in ext4_ext_rm_idx()
2306 return -EFSCORRUPTED; in ext4_ext_rm_idx()
2308 err = ext4_ext_get_access(handle, inode, path); in ext4_ext_rm_idx()
2312 if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) { in ext4_ext_rm_idx()
2313 int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx; in ext4_ext_rm_idx()
2315 memmove(path->p_idx, path->p_idx + 1, len); in ext4_ext_rm_idx()
2318 le16_add_cpu(&path->p_hdr->eh_entries, -1); in ext4_ext_rm_idx()
2319 err = ext4_ext_dirty(handle, inode, path); in ext4_ext_rm_idx()
2328 while (--depth >= 0) { in ext4_ext_rm_idx()
2329 if (path->p_idx != EXT_FIRST_INDEX(path->p_hdr)) in ext4_ext_rm_idx()
2331 path--; in ext4_ext_rm_idx()
2332 err = ext4_ext_get_access(handle, inode, path); in ext4_ext_rm_idx()
2335 path->p_idx->ei_block = (path+1)->p_idx->ei_block; in ext4_ext_rm_idx()
2336 err = ext4_ext_dirty(handle, inode, path); in ext4_ext_rm_idx()
2347 * When pass the actual path, the caller should calculate credits
2351 struct ext4_ext_path *path) in ext4_ext_calc_credits_for_single_extent() argument
2353 if (path) { in ext4_ext_calc_credits_for_single_extent()
2358 if (le16_to_cpu(path[depth].p_hdr->eh_entries) in ext4_ext_calc_credits_for_single_extent()
2359 < le16_to_cpu(path[depth].p_hdr->eh_max)) { in ext4_ext_calc_credits_for_single_extent()
2370 ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb); in ext4_ext_calc_credits_for_single_extent()
2408 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) || in get_default_free_blocks_flags()
2417 * ext4_rereserve_cluster - increment the reserved cluster count when
2420 * @inode - file containing the cluster
2421 * @lblk - logical block in cluster to be reserved
2433 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_rereserve_cluster()
2438 spin_lock(&ei->i_block_reservation_lock); in ext4_rereserve_cluster()
2439 ei->i_reserved_data_blocks++; in ext4_rereserve_cluster()
2440 percpu_counter_add(&sbi->s_dirtyclusters_counter, 1); in ext4_rereserve_cluster()
2441 spin_unlock(&ei->i_block_reservation_lock); in ext4_rereserve_cluster()
2443 percpu_counter_add(&sbi->s_freeclusters_counter, 1); in ext4_rereserve_cluster()
2452 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_remove_blocks()
2459 if (from < le32_to_cpu(ex->ee_block) || in ext4_remove_blocks()
2460 to != le32_to_cpu(ex->ee_block) + ee_len - 1) { in ext4_remove_blocks()
2461 ext4_error(sbi->s_sb, in ext4_remove_blocks()
2462 "strange request: removal(2) %u-%u from %u:%u", in ext4_remove_blocks()
2463 from, to, le32_to_cpu(ex->ee_block), ee_len); in ext4_remove_blocks()
2468 spin_lock(&sbi->s_ext_stats_lock); in ext4_remove_blocks()
2469 sbi->s_ext_blocks += ee_len; in ext4_remove_blocks()
2470 sbi->s_ext_extents++; in ext4_remove_blocks()
2471 if (ee_len < sbi->s_ext_min) in ext4_remove_blocks()
2472 sbi->s_ext_min = ee_len; in ext4_remove_blocks()
2473 if (ee_len > sbi->s_ext_max) in ext4_remove_blocks()
2474 sbi->s_ext_max = ee_len; in ext4_remove_blocks()
2475 if (ext_depth(inode) > sbi->s_depth_max) in ext4_remove_blocks()
2476 sbi->s_depth_max = ext_depth(inode); in ext4_remove_blocks()
2477 spin_unlock(&sbi->s_ext_stats_lock); in ext4_remove_blocks()
2486 last_pblk = ext4_ext_pblock(ex) + ee_len - 1; in ext4_remove_blocks()
2488 if (partial->state != initial && in ext4_remove_blocks()
2489 partial->pclu != EXT4_B2C(sbi, last_pblk)) { in ext4_remove_blocks()
2490 if (partial->state == tofree) { in ext4_remove_blocks()
2492 if (ext4_is_pending(inode, partial->lblk)) in ext4_remove_blocks()
2495 EXT4_C2B(sbi, partial->pclu), in ext4_remove_blocks()
2496 sbi->s_cluster_ratio, flags); in ext4_remove_blocks()
2498 ext4_rereserve_cluster(inode, partial->lblk); in ext4_remove_blocks()
2500 partial->state = initial; in ext4_remove_blocks()
2503 num = le32_to_cpu(ex->ee_block) + ee_len - from; in ext4_remove_blocks()
2504 pblk = ext4_ext_pblock(ex) + ee_len - num; in ext4_remove_blocks()
2515 if ((EXT4_LBLK_COFF(sbi, to) != sbi->s_cluster_ratio - 1) && in ext4_remove_blocks()
2517 (partial->state != nofree)) { in ext4_remove_blocks()
2522 sbi->s_cluster_ratio, flags); in ext4_remove_blocks()
2525 partial->state = initial; in ext4_remove_blocks()
2541 if (partial->state != initial && partial->pclu != EXT4_B2C(sbi, pblk)) in ext4_remove_blocks()
2542 partial->state = initial; in ext4_remove_blocks()
2551 * cluster - we're either done freeing or the beginning of the in ext4_remove_blocks()
2555 if (partial->state == initial) { in ext4_remove_blocks()
2556 partial->pclu = EXT4_B2C(sbi, pblk); in ext4_remove_blocks()
2557 partial->lblk = from; in ext4_remove_blocks()
2558 partial->state = tofree; in ext4_remove_blocks()
2561 partial->state = initial; in ext4_remove_blocks()
2574 * @path: The path to the leaf
2584 struct ext4_ext_path *path, in ext4_ext_rm_leaf() argument
2588 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_ext_rm_leaf()
2602 if (!path[depth].p_hdr) in ext4_ext_rm_leaf()
2603 path[depth].p_hdr = ext_block_hdr(path[depth].p_bh); in ext4_ext_rm_leaf()
2604 eh = path[depth].p_hdr; in ext4_ext_rm_leaf()
2605 if (unlikely(path[depth].p_hdr == NULL)) { in ext4_ext_rm_leaf()
2606 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); in ext4_ext_rm_leaf()
2607 return -EFSCORRUPTED; in ext4_ext_rm_leaf()
2610 ex = path[depth].p_ext; in ext4_ext_rm_leaf()
2614 ex_ee_block = le32_to_cpu(ex->ee_block); in ext4_ext_rm_leaf()
2629 path[depth].p_ext = ex; in ext4_ext_rm_leaf()
2632 b = ex_ee_block+ex_ee_len - 1 < end ? in ext4_ext_rm_leaf()
2633 ex_ee_block+ex_ee_len - 1 : end; in ext4_ext_rm_leaf()
2646 if (sbi->s_cluster_ratio > 1) { in ext4_ext_rm_leaf()
2648 partial->pclu = EXT4_B2C(sbi, pblk); in ext4_ext_rm_leaf()
2649 partial->state = nofree; in ext4_ext_rm_leaf()
2651 ex--; in ext4_ext_rm_leaf()
2652 ex_ee_block = le32_to_cpu(ex->ee_block); in ext4_ext_rm_leaf()
2655 } else if (b != ex_ee_block + ex_ee_len - 1) { in ext4_ext_rm_leaf()
2660 ex_ee_block + ex_ee_len - 1); in ext4_ext_rm_leaf()
2661 err = -EFSCORRUPTED; in ext4_ext_rm_leaf()
2665 num = a - ex_ee_block; in ext4_ext_rm_leaf()
2676 credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb)); in ext4_ext_rm_leaf()
2681 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); in ext4_ext_rm_leaf()
2688 ext4_free_metadata_revoke_credits(inode->i_sb, in ext4_ext_rm_leaf()
2690 ext4_free_data_revoke_credits(inode, b - a + 1); in ext4_ext_rm_leaf()
2696 err = -EAGAIN; in ext4_ext_rm_leaf()
2700 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_rm_leaf()
2712 ex->ee_len = cpu_to_le16(num); in ext4_ext_rm_leaf()
2724 if (end != EXT_MAX_BLOCKS - 1) { in ext4_ext_rm_leaf()
2730 memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) * in ext4_ext_rm_leaf()
2737 le16_add_cpu(&eh->eh_entries, -1); in ext4_ext_rm_leaf()
2740 err = ext4_ext_dirty(handle, inode, path + depth); in ext4_ext_rm_leaf()
2746 ex--; in ext4_ext_rm_leaf()
2747 ex_ee_block = le32_to_cpu(ex->ee_block); in ext4_ext_rm_leaf()
2751 if (correct_index && eh->eh_entries) in ext4_ext_rm_leaf()
2752 err = ext4_ext_correct_indexes(handle, inode, path); in ext4_ext_rm_leaf()
2761 if (partial->state == tofree && ex >= EXT_FIRST_EXTENT(eh)) { in ext4_ext_rm_leaf()
2762 pblk = ext4_ext_pblock(ex) + ex_ee_len - 1; in ext4_ext_rm_leaf()
2763 if (partial->pclu != EXT4_B2C(sbi, pblk)) { in ext4_ext_rm_leaf()
2766 if (ext4_is_pending(inode, partial->lblk)) in ext4_ext_rm_leaf()
2769 EXT4_C2B(sbi, partial->pclu), in ext4_ext_rm_leaf()
2770 sbi->s_cluster_ratio, flags); in ext4_ext_rm_leaf()
2772 ext4_rereserve_cluster(inode, partial->lblk); in ext4_ext_rm_leaf()
2774 partial->state = initial; in ext4_ext_rm_leaf()
2779 if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL) in ext4_ext_rm_leaf()
2780 err = ext4_ext_rm_idx(handle, inode, path, depth); in ext4_ext_rm_leaf()
2791 ext4_ext_more_to_rm(struct ext4_ext_path *path) in ext4_ext_more_to_rm() argument
2793 BUG_ON(path->p_idx == NULL); in ext4_ext_more_to_rm()
2795 if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr)) in ext4_ext_more_to_rm()
2802 if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block) in ext4_ext_more_to_rm()
2810 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_ext_remove_space()
2812 struct ext4_ext_path *path = NULL; in ext4_ext_remove_space() local
2826 ext4_free_metadata_revoke_credits(inode->i_sb, depth)); in ext4_ext_remove_space()
2840 if (end < EXT_MAX_BLOCKS - 1) { in ext4_ext_remove_space()
2846 path = ext4_find_extent(inode, end, NULL, in ext4_ext_remove_space()
2848 if (IS_ERR(path)) { in ext4_ext_remove_space()
2850 return PTR_ERR(path); in ext4_ext_remove_space()
2854 ex = path[depth].p_ext; in ext4_ext_remove_space()
2858 "path[%d].p_hdr == NULL", in ext4_ext_remove_space()
2860 err = -EFSCORRUPTED; in ext4_ext_remove_space()
2865 ee_block = le32_to_cpu(ex->ee_block); in ext4_ext_remove_space()
2866 ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1; in ext4_ext_remove_space()
2881 if (sbi->s_cluster_ratio > 1) { in ext4_ext_remove_space()
2882 pblk = ext4_ext_pblock(ex) + end - ee_block + 1; in ext4_ext_remove_space()
2893 err = ext4_force_split_extent_at(handle, inode, &path, in ext4_ext_remove_space()
2898 } else if (sbi->s_cluster_ratio > 1 && end >= ex_end && in ext4_ext_remove_space()
2911 err = ext4_ext_search_right(inode, path, &lblk, &pblk, in ext4_ext_remove_space()
2923 * after i_size and walking into the tree depth-wise. in ext4_ext_remove_space()
2926 if (path) { in ext4_ext_remove_space()
2928 while (--k > 0) in ext4_ext_remove_space()
2929 path[k].p_block = in ext4_ext_remove_space()
2930 le16_to_cpu(path[k].p_hdr->eh_entries)+1; in ext4_ext_remove_space()
2932 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path), in ext4_ext_remove_space()
2934 if (path == NULL) { in ext4_ext_remove_space()
2936 return -ENOMEM; in ext4_ext_remove_space()
2938 path[0].p_maxdepth = path[0].p_depth = depth; in ext4_ext_remove_space()
2939 path[0].p_hdr = ext_inode_hdr(inode); in ext4_ext_remove_space()
2942 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) { in ext4_ext_remove_space()
2943 err = -EFSCORRUPTED; in ext4_ext_remove_space()
2952 err = ext4_ext_rm_leaf(handle, inode, path, in ext4_ext_remove_space()
2955 brelse(path[i].p_bh); in ext4_ext_remove_space()
2956 path[i].p_bh = NULL; in ext4_ext_remove_space()
2957 i--; in ext4_ext_remove_space()
2962 if (!path[i].p_hdr) { in ext4_ext_remove_space()
2964 path[i].p_hdr = ext_block_hdr(path[i].p_bh); in ext4_ext_remove_space()
2967 if (!path[i].p_idx) { in ext4_ext_remove_space()
2969 path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr); in ext4_ext_remove_space()
2970 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1; in ext4_ext_remove_space()
2972 path[i].p_hdr, in ext4_ext_remove_space()
2973 le16_to_cpu(path[i].p_hdr->eh_entries)); in ext4_ext_remove_space()
2976 path[i].p_idx--; in ext4_ext_remove_space()
2979 ext_debug(inode, "level %d - index, first 0x%p, cur 0x%p\n", in ext4_ext_remove_space()
2980 i, EXT_FIRST_INDEX(path[i].p_hdr), in ext4_ext_remove_space()
2981 path[i].p_idx); in ext4_ext_remove_space()
2982 if (ext4_ext_more_to_rm(path + i)) { in ext4_ext_remove_space()
2986 i + 1, ext4_idx_pblock(path[i].p_idx)); in ext4_ext_remove_space()
2987 memset(path + i + 1, 0, sizeof(*path)); in ext4_ext_remove_space()
2988 bh = read_extent_tree_block(inode, path[i].p_idx, in ext4_ext_remove_space()
2989 depth - i - 1, in ext4_ext_remove_space()
2997 * Should be a no-op if we did IO above. */ in ext4_ext_remove_space()
3000 err = -EFSCORRUPTED; in ext4_ext_remove_space()
3003 path[i + 1].p_bh = bh; in ext4_ext_remove_space()
3007 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries); in ext4_ext_remove_space()
3011 if (path[i].p_hdr->eh_entries == 0 && i > 0) { in ext4_ext_remove_space()
3015 err = ext4_ext_rm_idx(handle, inode, path, i); in ext4_ext_remove_space()
3018 brelse(path[i].p_bh); in ext4_ext_remove_space()
3019 path[i].p_bh = NULL; in ext4_ext_remove_space()
3020 i--; in ext4_ext_remove_space()
3026 path->p_hdr->eh_entries); in ext4_ext_remove_space()
3039 sbi->s_cluster_ratio, flags); in ext4_ext_remove_space()
3046 if (path->p_hdr->eh_entries == 0) { in ext4_ext_remove_space()
3051 err = ext4_ext_get_access(handle, inode, path); in ext4_ext_remove_space()
3053 ext_inode_hdr(inode)->eh_depth = 0; in ext4_ext_remove_space()
3054 ext_inode_hdr(inode)->eh_max = in ext4_ext_remove_space()
3056 err = ext4_ext_dirty(handle, inode, path); in ext4_ext_remove_space()
3060 ext4_ext_drop_refs(path); in ext4_ext_remove_space()
3061 kfree(path); in ext4_ext_remove_space()
3062 path = NULL; in ext4_ext_remove_space()
3063 if (err == -EAGAIN) in ext4_ext_remove_space()
3081 printk(KERN_INFO "EXT4-fs: file extents enabled" in ext4_ext_init()
3094 spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock); in ext4_ext_init()
3095 EXT4_SB(sb)->s_ext_min = 1 << 30; in ext4_ext_init()
3096 EXT4_SB(sb)->s_ext_max = 0; in ext4_ext_init()
3110 if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) { in ext4_ext_release()
3112 printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n", in ext4_ext_release()
3113 sbi->s_ext_blocks, sbi->s_ext_extents, in ext4_ext_release()
3114 sbi->s_ext_blocks / sbi->s_ext_extents); in ext4_ext_release()
3115 printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n", in ext4_ext_release()
3116 sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max); in ext4_ext_release()
3127 ee_block = le32_to_cpu(ex->ee_block); in ext4_zeroout_es()
3138 /* FIXME!! we need to try to merge to left or right after zero-out */
3146 return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock, in ext4_ext_zeroout()
3155 * @path: the path to the extent
3178 struct ext4_ext_path *path = *ppath; in ext4_split_extent_at() local
3191 ext4_ext_show_leaf(inode, path); in ext4_split_extent_at()
3194 ex = path[depth].p_ext; in ext4_split_extent_at()
3195 ee_block = le32_to_cpu(ex->ee_block); in ext4_split_extent_at()
3197 newblock = split - ee_block + ext4_ext_pblock(ex); in ext4_split_extent_at()
3205 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_split_extent_at()
3221 ext4_ext_try_to_merge(handle, inode, path, ex); in ext4_split_extent_at()
3223 err = ext4_ext_dirty(handle, inode, path + path->p_depth); in ext4_split_extent_at()
3229 ex->ee_len = cpu_to_le16(split - ee_block); in ext4_split_extent_at()
3234 * path may lead to new leaf, not to original leaf any more in ext4_split_extent_at()
3237 err = ext4_ext_dirty(handle, inode, path + depth); in ext4_split_extent_at()
3242 ex2->ee_block = cpu_to_le32(split); in ext4_split_extent_at()
3243 ex2->ee_len = cpu_to_le16(ee_len - (split - ee_block)); in ext4_split_extent_at()
3249 if (err != -ENOSPC && err != -EDQUOT) in ext4_split_extent_at()
3256 zero_ex.ee_block = ex2->ee_block; in ext4_split_extent_at()
3263 zero_ex.ee_block = ex->ee_block; in ext4_split_extent_at()
3280 ex->ee_len = cpu_to_le16(ee_len); in ext4_split_extent_at()
3281 ext4_ext_try_to_merge(handle, inode, path, ex); in ext4_split_extent_at()
3282 err = ext4_ext_dirty(handle, inode, path + path->p_depth); in ext4_split_extent_at()
3296 ex->ee_len = orig_ex.ee_len; in ext4_split_extent_at()
3298 * Ignore ext4_ext_dirty return value since we are already in error path in ext4_split_extent_at()
3299 * and err is a non-zero error code. in ext4_split_extent_at()
3301 ext4_ext_dirty(handle, inode, path + path->p_depth); in ext4_split_extent_at()
3304 ext4_ext_show_leaf(inode, path); in ext4_split_extent_at()
3310 * by @map as split_flags indicates
3322 struct ext4_map_blocks *map, in ext4_split_extent() argument
3326 struct ext4_ext_path *path = *ppath; in ext4_split_extent() local
3333 int allocated = map->m_len; in ext4_split_extent()
3336 ex = path[depth].p_ext; in ext4_split_extent()
3337 ee_block = le32_to_cpu(ex->ee_block); in ext4_split_extent()
3341 if (map->m_lblk + map->m_len < ee_block + ee_len) { in ext4_split_extent()
3350 map->m_lblk + map->m_len, split_flag1, flags1); in ext4_split_extent()
3354 allocated = ee_len - (map->m_lblk - ee_block); in ext4_split_extent()
3357 * Update path is required because previous ext4_split_extent_at() may in ext4_split_extent()
3360 path = ext4_find_extent(inode, map->m_lblk, ppath, flags); in ext4_split_extent()
3361 if (IS_ERR(path)) in ext4_split_extent()
3362 return PTR_ERR(path); in ext4_split_extent()
3364 ex = path[depth].p_ext; in ext4_split_extent()
3367 (unsigned long) map->m_lblk); in ext4_split_extent()
3368 return -EFSCORRUPTED; in ext4_split_extent()
3373 if (map->m_lblk >= ee_block) { in ext4_split_extent()
3381 map->m_lblk, split_flag1, flags); in ext4_split_extent()
3386 ext4_ext_show_leaf(inode, path); in ext4_split_extent()
3394 * extent into multiple extents (up to three - one initialized and two
3401 * Pre-conditions:
3402 * - The extent pointed to by 'path' is unwritten.
3403 * - The extent pointed to by 'path' contains a superset
3404 * of the logical span [map->m_lblk, map->m_lblk + map->m_len).
3406 * Post-conditions on success:
3407 * - the returned value is the number of blocks beyond map->l_lblk
3409 * It is guaranteed to be >= map->m_len.
3413 struct ext4_map_blocks *map, in ext4_ext_convert_to_initialized() argument
3417 struct ext4_ext_path *path = *ppath; in ext4_ext_convert_to_initialized() local
3424 unsigned int ee_len, depth, map_len = map->m_len; in ext4_ext_convert_to_initialized()
3430 (unsigned long long)map->m_lblk, map_len); in ext4_ext_convert_to_initialized()
3432 sbi = EXT4_SB(inode->i_sb); in ext4_ext_convert_to_initialized()
3433 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1) in ext4_ext_convert_to_initialized()
3434 >> inode->i_sb->s_blocksize_bits; in ext4_ext_convert_to_initialized()
3435 if (eof_block < map->m_lblk + map_len) in ext4_ext_convert_to_initialized()
3436 eof_block = map->m_lblk + map_len; in ext4_ext_convert_to_initialized()
3439 eh = path[depth].p_hdr; in ext4_ext_convert_to_initialized()
3440 ex = path[depth].p_ext; in ext4_ext_convert_to_initialized()
3441 ee_block = le32_to_cpu(ex->ee_block); in ext4_ext_convert_to_initialized()
3446 trace_ext4_ext_convert_to_initialized_enter(inode, map, ex); in ext4_ext_convert_to_initialized()
3448 /* Pre-conditions */ in ext4_ext_convert_to_initialized()
3450 BUG_ON(!in_range(map->m_lblk, ee_block, ee_len)); in ext4_ext_convert_to_initialized()
3461 * - L1: we do not deal with writes covering the whole extent. in ext4_ext_convert_to_initialized()
3464 * - L2: we only attempt to merge with an extent stored in the in ext4_ext_convert_to_initialized()
3467 if ((map->m_lblk == ee_block) && in ext4_ext_convert_to_initialized()
3475 abut_ex = ex - 1; in ext4_ext_convert_to_initialized()
3476 prev_lblk = le32_to_cpu(abut_ex->ee_block); in ext4_ext_convert_to_initialized()
3484 * - C1: abut_ex is initialized, in ext4_ext_convert_to_initialized()
3485 * - C2: abut_ex is logically abutting ex, in ext4_ext_convert_to_initialized()
3486 * - C3: abut_ex is physically abutting ex, in ext4_ext_convert_to_initialized()
3487 * - C4: abut_ex can receive the additional blocks without in ext4_ext_convert_to_initialized()
3493 (prev_len < (EXT_INIT_MAX_LEN - map_len))) { /*C4*/ in ext4_ext_convert_to_initialized()
3494 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_convert_to_initialized()
3499 map, ex, abut_ex); in ext4_ext_convert_to_initialized()
3502 ex->ee_block = cpu_to_le32(ee_block + map_len); in ext4_ext_convert_to_initialized()
3504 ex->ee_len = cpu_to_le16(ee_len - map_len); in ext4_ext_convert_to_initialized()
3508 abut_ex->ee_len = cpu_to_le16(prev_len + map_len); in ext4_ext_convert_to_initialized()
3513 } else if (((map->m_lblk + map_len) == (ee_block + ee_len)) && in ext4_ext_convert_to_initialized()
3522 next_lblk = le32_to_cpu(abut_ex->ee_block); in ext4_ext_convert_to_initialized()
3530 * - C1: abut_ex is initialized, in ext4_ext_convert_to_initialized()
3531 * - C2: abut_ex is logically abutting ex, in ext4_ext_convert_to_initialized()
3532 * - C3: abut_ex is physically abutting ex, in ext4_ext_convert_to_initialized()
3533 * - C4: abut_ex can receive the additional blocks without in ext4_ext_convert_to_initialized()
3537 ((map->m_lblk + map_len) == next_lblk) && /*C2*/ in ext4_ext_convert_to_initialized()
3539 (next_len < (EXT_INIT_MAX_LEN - map_len))) { /*C4*/ in ext4_ext_convert_to_initialized()
3540 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_convert_to_initialized()
3545 map, ex, abut_ex); in ext4_ext_convert_to_initialized()
3548 abut_ex->ee_block = cpu_to_le32(next_lblk - map_len); in ext4_ext_convert_to_initialized()
3549 ext4_ext_store_pblock(abut_ex, next_pblk - map_len); in ext4_ext_convert_to_initialized()
3550 ex->ee_len = cpu_to_le16(ee_len - map_len); in ext4_ext_convert_to_initialized()
3554 abut_ex->ee_len = cpu_to_le16(next_len + map_len); in ext4_ext_convert_to_initialized()
3562 err = ext4_ext_dirty(handle, inode, path + depth); in ext4_ext_convert_to_initialized()
3564 /* Update path to point to the right extent */ in ext4_ext_convert_to_initialized()
3565 path[depth].p_ext = abut_ex; in ext4_ext_convert_to_initialized()
3568 allocated = ee_len - (map->m_lblk - ee_block); in ext4_ext_convert_to_initialized()
3570 WARN_ON(map->m_lblk < ee_block); in ext4_ext_convert_to_initialized()
3578 max_zeroout = sbi->s_extent_max_zeroout_kb >> in ext4_ext_convert_to_initialized()
3579 (inode->i_sb->s_blocksize_bits - 10); in ext4_ext_convert_to_initialized()
3592 split_map.m_lblk = map->m_lblk; in ext4_ext_convert_to_initialized()
3593 split_map.m_len = map->m_len; in ext4_ext_convert_to_initialized()
3602 cpu_to_le16(allocated - split_map.m_len); in ext4_ext_convert_to_initialized()
3605 split_map.m_len - ee_block); in ext4_ext_convert_to_initialized()
3611 if (split_map.m_lblk - ee_block + split_map.m_len < in ext4_ext_convert_to_initialized()
3615 zero_ex2.ee_block = ex->ee_block; in ext4_ext_convert_to_initialized()
3616 zero_ex2.ee_len = cpu_to_le16(split_map.m_lblk - in ext4_ext_convert_to_initialized()
3625 split_map.m_len += split_map.m_lblk - ee_block; in ext4_ext_convert_to_initialized()
3627 allocated = map->m_len; in ext4_ext_convert_to_initialized()
3657 * This works the same way in the case of initialized -> unwritten conversion.
3671 struct ext4_map_blocks *map, in ext4_split_convert_extents() argument
3675 struct ext4_ext_path *path = *ppath; in ext4_split_convert_extents() local
3683 (unsigned long long)map->m_lblk, map->m_len); in ext4_split_convert_extents()
3685 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1) in ext4_split_convert_extents()
3686 >> inode->i_sb->s_blocksize_bits; in ext4_split_convert_extents()
3687 if (eof_block < map->m_lblk + map->m_len) in ext4_split_convert_extents()
3688 eof_block = map->m_lblk + map->m_len; in ext4_split_convert_extents()
3694 ex = path[depth].p_ext; in ext4_split_convert_extents()
3695 ee_block = le32_to_cpu(ex->ee_block); in ext4_split_convert_extents()
3708 return ext4_split_extent(handle, inode, ppath, map, split_flag, flags); in ext4_split_convert_extents()
3713 struct ext4_map_blocks *map, in ext4_convert_unwritten_extents_endio() argument
3716 struct ext4_ext_path *path = *ppath; in ext4_convert_unwritten_extents_endio() local
3724 ex = path[depth].p_ext; in ext4_convert_unwritten_extents_endio()
3725 ee_block = le32_to_cpu(ex->ee_block); in ext4_convert_unwritten_extents_endio()
3737 if (ee_block != map->m_lblk || ee_len > map->m_len) { in ext4_convert_unwritten_extents_endio()
3739 ext4_warning(inode->i_sb, "Inode (%ld) finished: extent logical block %llu," in ext4_convert_unwritten_extents_endio()
3741 inode->i_ino, (unsigned long long)ee_block, ee_len, in ext4_convert_unwritten_extents_endio()
3742 (unsigned long long)map->m_lblk, map->m_len); in ext4_convert_unwritten_extents_endio()
3744 err = ext4_split_convert_extents(handle, inode, map, ppath, in ext4_convert_unwritten_extents_endio()
3748 path = ext4_find_extent(inode, map->m_lblk, ppath, 0); in ext4_convert_unwritten_extents_endio()
3749 if (IS_ERR(path)) in ext4_convert_unwritten_extents_endio()
3750 return PTR_ERR(path); in ext4_convert_unwritten_extents_endio()
3752 ex = path[depth].p_ext; in ext4_convert_unwritten_extents_endio()
3755 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_convert_unwritten_extents_endio()
3764 ext4_ext_try_to_merge(handle, inode, path, ex); in ext4_convert_unwritten_extents_endio()
3767 err = ext4_ext_dirty(handle, inode, path + path->p_depth); in ext4_convert_unwritten_extents_endio()
3769 ext4_ext_show_leaf(inode, path); in ext4_convert_unwritten_extents_endio()
3775 struct ext4_map_blocks *map, in convert_initialized_extent() argument
3779 struct ext4_ext_path *path = *ppath; in convert_initialized_extent() local
3790 if (map->m_len > EXT_UNWRITTEN_MAX_LEN) in convert_initialized_extent()
3791 map->m_len = EXT_UNWRITTEN_MAX_LEN / 2; in convert_initialized_extent()
3794 ex = path[depth].p_ext; in convert_initialized_extent()
3795 ee_block = le32_to_cpu(ex->ee_block); in convert_initialized_extent()
3801 if (ee_block != map->m_lblk || ee_len > map->m_len) { in convert_initialized_extent()
3802 err = ext4_split_convert_extents(handle, inode, map, ppath, in convert_initialized_extent()
3806 path = ext4_find_extent(inode, map->m_lblk, ppath, 0); in convert_initialized_extent()
3807 if (IS_ERR(path)) in convert_initialized_extent()
3808 return PTR_ERR(path); in convert_initialized_extent()
3810 ex = path[depth].p_ext; in convert_initialized_extent()
3813 (unsigned long) map->m_lblk); in convert_initialized_extent()
3814 return -EFSCORRUPTED; in convert_initialized_extent()
3818 err = ext4_ext_get_access(handle, inode, path + depth); in convert_initialized_extent()
3827 ext4_ext_try_to_merge(handle, inode, path, ex); in convert_initialized_extent()
3830 err = ext4_ext_dirty(handle, inode, path + path->p_depth); in convert_initialized_extent()
3833 ext4_ext_show_leaf(inode, path); in convert_initialized_extent()
3837 map->m_flags |= EXT4_MAP_UNWRITTEN; in convert_initialized_extent()
3838 if (*allocated > map->m_len) in convert_initialized_extent()
3839 *allocated = map->m_len; in convert_initialized_extent()
3840 map->m_len = *allocated; in convert_initialized_extent()
3846 struct ext4_map_blocks *map, in ext4_ext_handle_unwritten_extents() argument
3850 struct ext4_ext_path __maybe_unused *path = *ppath; in ext4_ext_handle_unwritten_extents() local
3855 (unsigned long long)map->m_lblk, map->m_len, flags, in ext4_ext_handle_unwritten_extents()
3857 ext4_ext_show_leaf(inode, path); in ext4_ext_handle_unwritten_extents()
3865 trace_ext4_ext_handle_unwritten_extents(inode, map, flags, in ext4_ext_handle_unwritten_extents()
3870 ret = ext4_split_convert_extents(handle, inode, map, ppath, in ext4_ext_handle_unwritten_extents()
3883 map->m_len); in ext4_ext_handle_unwritten_extents()
3884 err = -EFSCORRUPTED; in ext4_ext_handle_unwritten_extents()
3887 map->m_flags |= EXT4_MAP_UNWRITTEN; in ext4_ext_handle_unwritten_extents()
3892 err = ext4_convert_unwritten_extents_endio(handle, inode, map, in ext4_ext_handle_unwritten_extents()
3905 map->m_flags |= EXT4_MAP_UNWRITTEN; in ext4_ext_handle_unwritten_extents()
3918 map->m_flags |= EXT4_MAP_UNWRITTEN; in ext4_ext_handle_unwritten_extents()
3927 ret = ext4_ext_convert_to_initialized(handle, inode, map, ppath, flags); in ext4_ext_handle_unwritten_extents()
3939 map->m_len); in ext4_ext_handle_unwritten_extents()
3940 err = -EFSCORRUPTED; in ext4_ext_handle_unwritten_extents()
3946 map->m_flags |= EXT4_MAP_NEW; in ext4_ext_handle_unwritten_extents()
3948 map->m_flags |= EXT4_MAP_MAPPED; in ext4_ext_handle_unwritten_extents()
3950 map->m_pblk = newblock; in ext4_ext_handle_unwritten_extents()
3951 if (allocated > map->m_len) in ext4_ext_handle_unwritten_extents()
3952 allocated = map->m_len; in ext4_ext_handle_unwritten_extents()
3953 map->m_len = allocated; in ext4_ext_handle_unwritten_extents()
3954 ext4_ext_show_leaf(inode, path); in ext4_ext_handle_unwritten_extents()
3960 * get_implied_cluster_alloc - check to see if the requested
3961 * allocation (in the map structure) overlaps with a cluster already
3964 * @map The requested lblk->pblk mapping
3974 * |--- cluster # N--|
3975 * |--- extent ---| |---- requested region ---|
3980 * |--------- cluster # N ----------------|
3981 * |--- requested region --| |------- extent ----|
3986 * |------------- cluster # N-------------|
3987 * |----- ex -----| |---- ex_right ----|
3988 * |------ requested region ------|
3991 * In each of the above cases, we need to set the map->m_pblk and
3992 * map->m_len so it corresponds to the return the extent labelled as
3994 * cluster EXT4_B2C(sbi, map->m_lblk). We will then return 1 to
3995 * signal to ext4_ext_map_blocks() that map->m_pblk should be treated
4001 struct ext4_map_blocks *map, in get_implied_cluster_alloc() argument
4003 struct ext4_ext_path *path) in get_implied_cluster_alloc() argument
4006 ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk); in get_implied_cluster_alloc()
4009 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); in get_implied_cluster_alloc()
4015 ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1); in get_implied_cluster_alloc()
4018 rr_cluster_start = EXT4_B2C(sbi, map->m_lblk); in get_implied_cluster_alloc()
4023 ee_start += ee_len - 1; in get_implied_cluster_alloc()
4024 map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset; in get_implied_cluster_alloc()
4025 map->m_len = min(map->m_len, in get_implied_cluster_alloc()
4026 (unsigned) sbi->s_cluster_ratio - c_offset); in get_implied_cluster_alloc()
4030 * |--------- cluster # N-------------| in get_implied_cluster_alloc()
4031 * |------- extent ----| in get_implied_cluster_alloc()
4032 * |--- requested region ---| in get_implied_cluster_alloc()
4036 if (map->m_lblk < ee_block) in get_implied_cluster_alloc()
4037 map->m_len = min(map->m_len, ee_block - map->m_lblk); in get_implied_cluster_alloc()
4043 * |------------- cluster # N-------------| in get_implied_cluster_alloc()
4044 * |----- ex -----| |---- ex_right ----| in get_implied_cluster_alloc()
4045 * |------ requested region ------| in get_implied_cluster_alloc()
4048 if (map->m_lblk > ee_block) { in get_implied_cluster_alloc()
4049 ext4_lblk_t next = ext4_ext_next_allocated_block(path); in get_implied_cluster_alloc()
4050 map->m_len = min(map->m_len, next - map->m_lblk); in get_implied_cluster_alloc()
4053 trace_ext4_get_implied_cluster_alloc_exit(sb, map, 1); in get_implied_cluster_alloc()
4057 trace_ext4_get_implied_cluster_alloc_exit(sb, map, 0); in get_implied_cluster_alloc()
4063 * Block allocation/map/preallocation routine for extents based files
4067 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
4068 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
4071 * if create == 0 and these are pre-allocated blocks
4081 struct ext4_map_blocks *map, int flags) in ext4_ext_map_blocks() argument
4083 struct ext4_ext_path *path = NULL; in ext4_ext_map_blocks() local
4085 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_ext_map_blocks()
4093 ext_debug(inode, "blocks %u/%u requested\n", map->m_lblk, map->m_len); in ext4_ext_map_blocks()
4094 trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags); in ext4_ext_map_blocks()
4097 path = ext4_find_extent(inode, map->m_lblk, NULL, 0); in ext4_ext_map_blocks()
4098 if (IS_ERR(path)) { in ext4_ext_map_blocks()
4099 err = PTR_ERR(path); in ext4_ext_map_blocks()
4100 path = NULL; in ext4_ext_map_blocks()
4111 if (unlikely(path[depth].p_ext == NULL && depth != 0)) { in ext4_ext_map_blocks()
4114 (unsigned long) map->m_lblk, depth, in ext4_ext_map_blocks()
4115 path[depth].p_block); in ext4_ext_map_blocks()
4116 err = -EFSCORRUPTED; in ext4_ext_map_blocks()
4120 ex = path[depth].p_ext; in ext4_ext_map_blocks()
4122 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); in ext4_ext_map_blocks()
4136 if (in_range(map->m_lblk, ee_block, ee_len)) { in ext4_ext_map_blocks()
4137 newblock = map->m_lblk - ee_block + ee_start; in ext4_ext_map_blocks()
4139 allocated = ee_len - (map->m_lblk - ee_block); in ext4_ext_map_blocks()
4140 ext_debug(inode, "%u fit into %u:%d -> %llu\n", in ext4_ext_map_blocks()
4141 map->m_lblk, ee_block, ee_len, newblock); in ext4_ext_map_blocks()
4150 inode, map, &path, &allocated); in ext4_ext_map_blocks()
4153 map->m_flags |= EXT4_MAP_MAPPED; in ext4_ext_map_blocks()
4154 map->m_pblk = newblock; in ext4_ext_map_blocks()
4155 if (allocated > map->m_len) in ext4_ext_map_blocks()
4156 allocated = map->m_len; in ext4_ext_map_blocks()
4157 map->m_len = allocated; in ext4_ext_map_blocks()
4158 ext4_ext_show_leaf(inode, path); in ext4_ext_map_blocks()
4163 handle, inode, map, &path, flags, in ext4_ext_map_blocks()
4180 hole_start = map->m_lblk; in ext4_ext_map_blocks()
4181 hole_len = ext4_ext_determine_hole(inode, path, &hole_start); in ext4_ext_map_blocks()
4188 /* Update hole_len to reflect hole size after map->m_lblk */ in ext4_ext_map_blocks()
4189 if (hole_start != map->m_lblk) in ext4_ext_map_blocks()
4190 hole_len -= map->m_lblk - hole_start; in ext4_ext_map_blocks()
4191 map->m_pblk = 0; in ext4_ext_map_blocks()
4192 map->m_len = min_t(unsigned int, map->m_len, hole_len); in ext4_ext_map_blocks()
4200 newex.ee_block = cpu_to_le32(map->m_lblk); in ext4_ext_map_blocks()
4201 cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk); in ext4_ext_map_blocks()
4208 get_implied_cluster_alloc(inode->i_sb, map, ex, path)) { in ext4_ext_map_blocks()
4209 ar.len = allocated = map->m_len; in ext4_ext_map_blocks()
4210 newblock = map->m_pblk; in ext4_ext_map_blocks()
4215 ar.lleft = map->m_lblk; in ext4_ext_map_blocks()
4216 err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft); in ext4_ext_map_blocks()
4219 ar.lright = map->m_lblk; in ext4_ext_map_blocks()
4220 err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2); in ext4_ext_map_blocks()
4226 if ((sbi->s_cluster_ratio > 1) && err && in ext4_ext_map_blocks()
4227 get_implied_cluster_alloc(inode->i_sb, map, &ex2, path)) { in ext4_ext_map_blocks()
4228 ar.len = allocated = map->m_len; in ext4_ext_map_blocks()
4229 newblock = map->m_pblk; in ext4_ext_map_blocks()
4239 if (map->m_len > EXT_INIT_MAX_LEN && in ext4_ext_map_blocks()
4241 map->m_len = EXT_INIT_MAX_LEN; in ext4_ext_map_blocks()
4242 else if (map->m_len > EXT_UNWRITTEN_MAX_LEN && in ext4_ext_map_blocks()
4244 map->m_len = EXT_UNWRITTEN_MAX_LEN; in ext4_ext_map_blocks()
4247 newex.ee_len = cpu_to_le16(map->m_len); in ext4_ext_map_blocks()
4248 err = ext4_ext_check_overlap(sbi, inode, &newex, path); in ext4_ext_map_blocks()
4252 allocated = map->m_len; in ext4_ext_map_blocks()
4256 ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk); in ext4_ext_map_blocks()
4257 ar.logical = map->m_lblk; in ext4_ext_map_blocks()
4266 offset = EXT4_LBLK_COFF(sbi, map->m_lblk); in ext4_ext_map_blocks()
4268 ar.goal -= offset; in ext4_ext_map_blocks()
4269 ar.logical -= offset; in ext4_ext_map_blocks()
4270 if (S_ISREG(inode->i_mode)) in ext4_ext_map_blocks()
4273 /* disable in-core preallocation for non-regular files */ in ext4_ext_map_blocks()
4285 ar.len = EXT4_C2B(sbi, ar.len) - offset; in ext4_ext_map_blocks()
4299 map->m_flags |= EXT4_MAP_UNWRITTEN; in ext4_ext_map_blocks()
4302 err = ext4_ext_insert_extent(handle, inode, &path, &newex, flags); in ext4_ext_map_blocks()
4328 if (test_opt(inode->i_sb, DELALLOC) && allocated_clusters) { in ext4_ext_map_blocks()
4341 * When allocating non-delayed allocated clusters in ext4_ext_map_blocks()
4351 lblk = EXT4_LBLK_CMASK(sbi, map->m_lblk); in ext4_ext_map_blocks()
4352 len = allocated_clusters << sbi->s_cluster_bits; in ext4_ext_map_blocks()
4368 map->m_flags |= (EXT4_MAP_NEW | EXT4_MAP_MAPPED); in ext4_ext_map_blocks()
4369 map->m_pblk = pblk; in ext4_ext_map_blocks()
4370 map->m_len = ar.len; in ext4_ext_map_blocks()
4371 allocated = map->m_len; in ext4_ext_map_blocks()
4372 ext4_ext_show_leaf(inode, path); in ext4_ext_map_blocks()
4374 ext4_ext_drop_refs(path); in ext4_ext_map_blocks()
4375 kfree(path); in ext4_ext_map_blocks()
4377 trace_ext4_ext_map_blocks_exit(inode, flags, map, in ext4_ext_map_blocks()
4384 struct super_block *sb = inode->i_sb; in ext4_ext_truncate()
4395 EXT4_I(inode)->i_disksize = inode->i_size; in ext4_ext_truncate()
4400 last_block = (inode->i_size + sb->s_blocksize - 1) in ext4_ext_truncate()
4404 EXT_MAX_BLOCKS - last_block); in ext4_ext_truncate()
4405 if (err == -ENOMEM) { in ext4_ext_truncate()
4413 err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1); in ext4_ext_truncate()
4414 if (err == -ENOMEM) { in ext4_ext_truncate()
4432 struct ext4_map_blocks map; in ext4_alloc_file_blocks() local
4437 map.m_lblk = offset; in ext4_alloc_file_blocks()
4438 map.m_len = len; in ext4_alloc_file_blocks()
4469 ret = ext4_map_blocks(handle, inode, &map, flags); in ext4_alloc_file_blocks()
4473 inode->i_ino, map.m_lblk, in ext4_alloc_file_blocks()
4474 map.m_len, ret); in ext4_alloc_file_blocks()
4479 map.m_lblk += ret; in ext4_alloc_file_blocks()
4480 map.m_len = len = len - ret; in ext4_alloc_file_blocks()
4481 epos = (loff_t)map.m_lblk << inode->i_blkbits; in ext4_alloc_file_blocks()
4482 inode->i_ctime = current_time(inode); in ext4_alloc_file_blocks()
4487 inode->i_mtime = inode->i_ctime; in ext4_alloc_file_blocks()
4496 if (ret == -ENOSPC && in ext4_alloc_file_blocks()
4497 ext4_should_retry_alloc(inode->i_sb, &retries)) { in ext4_alloc_file_blocks()
4522 unsigned int blkbits = inode->i_blkbits; in ext4_zero_range()
4528 ret = ext4_force_commit(inode->i_sb); in ext4_zero_range()
4543 return -EINVAL; in ext4_zero_range()
4544 partial_begin = offset & ((1 << blkbits) - 1); in ext4_zero_range()
4545 partial_end = (offset + len) & ((1 << blkbits) - 1); in ext4_zero_range()
4552 max_blocks -= lblk; in ext4_zero_range()
4560 ret = -EOPNOTSUPP; in ext4_zero_range()
4565 (offset + len > inode->i_size || in ext4_zero_range()
4566 offset + len > EXT4_I(inode)->i_disksize)) { in ext4_zero_range()
4586 (round_up((offset + len), 1 << blkbits) - in ext4_zero_range()
4603 down_write(&EXT4_I(inode)->i_mmap_sem); in ext4_zero_range()
4607 up_write(&EXT4_I(inode)->i_mmap_sem); in ext4_zero_range()
4613 up_write(&EXT4_I(inode)->i_mmap_sem); in ext4_zero_range()
4617 truncate_pagecache_range(inode, start, end - 1); in ext4_zero_range()
4618 inode->i_mtime = inode->i_ctime = current_time(inode); in ext4_zero_range()
4622 up_write(&EXT4_I(inode)->i_mmap_sem); in ext4_zero_range()
4639 ext4_std_error(inode->i_sb, ret); in ext4_zero_range()
4643 inode->i_mtime = inode->i_ctime = current_time(inode); in ext4_zero_range()
4654 if (file->f_flags & O_SYNC) in ext4_zero_range()
4667 * For block-mapped files, posix_fallocate should fall back to the method
4679 unsigned int blkbits = inode->i_blkbits; in ext4_fallocate()
4683 * range since we would need to re-encrypt blocks with a in ext4_fallocate()
4689 return -EOPNOTSUPP; in ext4_fallocate()
4695 return -EOPNOTSUPP; in ext4_fallocate()
4732 * We only support preallocation for extent-based files only in ext4_fallocate()
4735 ret = -EOPNOTSUPP; in ext4_fallocate()
4740 (offset + len > inode->i_size || in ext4_fallocate()
4741 offset + len > EXT4_I(inode)->i_disksize)) { in ext4_fallocate()
4759 if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) { in ext4_fallocate()
4760 ret = ext4_fc_commit(EXT4_SB(inode->i_sb)->s_journal, in ext4_fallocate()
4761 EXT4_I(inode)->i_sync_tid); in ext4_fallocate()
4786 struct ext4_map_blocks map; in ext4_convert_unwritten_extents() local
4787 unsigned int blkbits = inode->i_blkbits; in ext4_convert_unwritten_extents()
4790 map.m_lblk = offset >> blkbits; in ext4_convert_unwritten_extents()
4800 map.m_lblk += ret; in ext4_convert_unwritten_extents()
4801 map.m_len = (max_blocks -= ret); in ext4_convert_unwritten_extents()
4810 ret = ext4_map_blocks(handle, inode, &map, in ext4_convert_unwritten_extents()
4813 ext4_warning(inode->i_sb, in ext4_convert_unwritten_extents()
4816 inode->i_ino, map.m_lblk, in ext4_convert_unwritten_extents()
4817 map.m_len, ret); in ext4_convert_unwritten_extents()
4848 list_for_each_entry(io_end_vec, &io_end->list_vec, list) { in ext4_convert_unwritten_io_end_vec()
4849 ret = ext4_convert_unwritten_extents(handle, io_end->inode, in ext4_convert_unwritten_io_end_vec()
4850 io_end_vec->offset, in ext4_convert_unwritten_io_end_vec()
4851 io_end_vec->size); in ext4_convert_unwritten_io_end_vec()
4866 int blockbits = inode->i_sb->s_blocksize_bits; in ext4_iomap_xattr_fiemap()
4870 /* in-inode? */ in ext4_iomap_xattr_fiemap()
4878 physical = (__u64)iloc.bh->b_blocknr << blockbits; in ext4_iomap_xattr_fiemap()
4880 EXT4_I(inode)->i_extra_isize; in ext4_iomap_xattr_fiemap()
4882 length = EXT4_SB(inode->i_sb)->s_inode_size - offset; in ext4_iomap_xattr_fiemap()
4885 } else if (EXT4_I(inode)->i_file_acl) { /* external block */ in ext4_iomap_xattr_fiemap()
4886 physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits; in ext4_iomap_xattr_fiemap()
4887 length = inode->i_sb->s_blocksize; in ext4_iomap_xattr_fiemap()
4890 /* no in-inode or external block for xattr, so return -ENOENT */ in ext4_iomap_xattr_fiemap()
4891 error = -ENOENT; in ext4_iomap_xattr_fiemap()
4895 iomap->addr = physical; in ext4_iomap_xattr_fiemap()
4896 iomap->offset = 0; in ext4_iomap_xattr_fiemap()
4897 iomap->length = length; in ext4_iomap_xattr_fiemap()
4898 iomap->type = iomap_type; in ext4_iomap_xattr_fiemap()
4899 iomap->flags = 0; in ext4_iomap_xattr_fiemap()
4911 if (error == 0 && (offset >= iomap->length)) in ext4_iomap_xattr_begin()
4912 error = -ENOENT; in ext4_iomap_xattr_begin()
4925 maxbytes = inode->i_sb->s_maxbytes; in ext4_fiemap_check_ranges()
4927 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; in ext4_fiemap_check_ranges()
4930 return -EINVAL; in ext4_fiemap_check_ranges()
4932 return -EFBIG; in ext4_fiemap_check_ranges()
4937 if (*len > maxbytes || (maxbytes - *len) < start) in ext4_fiemap_check_ranges()
4938 *len = maxbytes - start; in ext4_fiemap_check_ranges()
4947 if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) { in ext4_fiemap()
4951 fieinfo->fi_flags &= ~FIEMAP_FLAG_CACHE; in ext4_fiemap()
4963 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) { in ext4_fiemap()
4964 fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR; in ext4_fiemap()
4982 down_read(&EXT4_I(inode)->xattr_sem); in ext4_get_es_cache()
4984 up_read(&EXT4_I(inode)->xattr_sem); in ext4_get_es_cache()
4989 if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) { in ext4_get_es_cache()
4993 fieinfo->fi_flags &= ~FIEMAP_FLAG_CACHE; in ext4_get_es_cache()
5004 start_blk = start >> inode->i_sb->s_blocksize_bits; in ext4_get_es_cache()
5005 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits; in ext4_get_es_cache()
5007 last_blk = EXT_MAX_BLOCKS-1; in ext4_get_es_cache()
5008 len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1; in ext4_get_es_cache()
5019 * Shift the extents of a path structure lying between path[depth].p_ext
5020 * and EXT_LAST_EXTENT(path[depth].p_hdr), by @shift blocks. @SHIFT tells
5024 ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift, in ext4_ext_shift_path_extents() argument
5032 depth = path->p_depth; in ext4_ext_shift_path_extents()
5035 if (depth == path->p_depth) { in ext4_ext_shift_path_extents()
5036 ex_start = path[depth].p_ext; in ext4_ext_shift_path_extents()
5038 return -EFSCORRUPTED; in ext4_ext_shift_path_extents()
5040 ex_last = EXT_LAST_EXTENT(path[depth].p_hdr); in ext4_ext_shift_path_extents()
5043 if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr)) { in ext4_ext_shift_path_extents()
5054 err = -EAGAIN; in ext4_ext_shift_path_extents()
5058 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_shift_path_extents()
5064 le32_add_cpu(&ex_start->ee_block, in ext4_ext_shift_path_extents()
5065 -shift); in ext4_ext_shift_path_extents()
5068 EXT_FIRST_EXTENT(path[depth].p_hdr)) in ext4_ext_shift_path_extents()
5071 path, ex_start - 1)) in ext4_ext_shift_path_extents()
5072 ex_last--; in ext4_ext_shift_path_extents()
5076 le32_add_cpu(&ex_last->ee_block, shift); in ext4_ext_shift_path_extents()
5077 ext4_ext_try_to_merge_right(inode, path, in ext4_ext_shift_path_extents()
5079 ex_last--; in ext4_ext_shift_path_extents()
5082 err = ext4_ext_dirty(handle, inode, path + depth); in ext4_ext_shift_path_extents()
5086 if (--depth < 0 || !update) in ext4_ext_shift_path_extents()
5091 err = ext4_ext_get_access(handle, inode, path + depth); in ext4_ext_shift_path_extents()
5096 le32_add_cpu(&path[depth].p_idx->ei_block, -shift); in ext4_ext_shift_path_extents()
5098 le32_add_cpu(&path[depth].p_idx->ei_block, shift); in ext4_ext_shift_path_extents()
5099 err = ext4_ext_dirty(handle, inode, path + depth); in ext4_ext_shift_path_extents()
5104 if (path[depth].p_idx != EXT_FIRST_INDEX(path[depth].p_hdr)) in ext4_ext_shift_path_extents()
5107 depth--; in ext4_ext_shift_path_extents()
5126 struct ext4_ext_path *path; in ext4_ext_shift_extents() local
5132 /* Let path point to the last extent */ in ext4_ext_shift_extents()
5133 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL, in ext4_ext_shift_extents()
5135 if (IS_ERR(path)) in ext4_ext_shift_extents()
5136 return PTR_ERR(path); in ext4_ext_shift_extents()
5138 depth = path->p_depth; in ext4_ext_shift_extents()
5139 extent = path[depth].p_ext; in ext4_ext_shift_extents()
5143 stop = le32_to_cpu(extent->ee_block); in ext4_ext_shift_extents()
5151 path = ext4_find_extent(inode, start - 1, &path, in ext4_ext_shift_extents()
5153 if (IS_ERR(path)) in ext4_ext_shift_extents()
5154 return PTR_ERR(path); in ext4_ext_shift_extents()
5155 depth = path->p_depth; in ext4_ext_shift_extents()
5156 extent = path[depth].p_ext; in ext4_ext_shift_extents()
5158 ex_start = le32_to_cpu(extent->ee_block); in ext4_ext_shift_extents()
5159 ex_end = le32_to_cpu(extent->ee_block) + in ext4_ext_shift_extents()
5167 (shift > start - ex_end)) { in ext4_ext_shift_extents()
5168 ret = -EINVAL; in ext4_ext_shift_extents()
5172 if (shift > EXT_MAX_BLOCKS - in ext4_ext_shift_extents()
5174 ret = -EINVAL; in ext4_ext_shift_extents()
5200 path = ext4_find_extent(inode, *iterator, &path, in ext4_ext_shift_extents()
5202 if (IS_ERR(path)) in ext4_ext_shift_extents()
5203 return PTR_ERR(path); in ext4_ext_shift_extents()
5204 depth = path->p_depth; in ext4_ext_shift_extents()
5205 extent = path[depth].p_ext; in ext4_ext_shift_extents()
5209 return -EFSCORRUPTED; in ext4_ext_shift_extents()
5212 le32_to_cpu(extent->ee_block)) { in ext4_ext_shift_extents()
5214 if (extent < EXT_LAST_EXTENT(path[depth].p_hdr)) { in ext4_ext_shift_extents()
5215 path[depth].p_ext++; in ext4_ext_shift_extents()
5217 *iterator = ext4_ext_next_allocated_block(path); in ext4_ext_shift_extents()
5224 extent = EXT_LAST_EXTENT(path[depth].p_hdr); in ext4_ext_shift_extents()
5225 *iterator = le32_to_cpu(extent->ee_block) + in ext4_ext_shift_extents()
5228 extent = EXT_FIRST_EXTENT(path[depth].p_hdr); in ext4_ext_shift_extents()
5229 if (le32_to_cpu(extent->ee_block) > start) in ext4_ext_shift_extents()
5230 *iterator = le32_to_cpu(extent->ee_block) - 1; in ext4_ext_shift_extents()
5231 else if (le32_to_cpu(extent->ee_block) == start) in ext4_ext_shift_extents()
5234 extent = EXT_LAST_EXTENT(path[depth].p_hdr); in ext4_ext_shift_extents()
5235 while (le32_to_cpu(extent->ee_block) >= start) in ext4_ext_shift_extents()
5236 extent--; in ext4_ext_shift_extents()
5238 if (extent == EXT_LAST_EXTENT(path[depth].p_hdr)) in ext4_ext_shift_extents()
5244 path[depth].p_ext = extent; in ext4_ext_shift_extents()
5246 ret = ext4_ext_shift_path_extents(path, shift, inode, in ext4_ext_shift_extents()
5249 if (ret == -EAGAIN) in ext4_ext_shift_extents()
5255 ext4_ext_drop_refs(path); in ext4_ext_shift_extents()
5256 kfree(path); in ext4_ext_shift_extents()
5263 * Returns: 0 and non-zero on error.
5268 struct super_block *sb = inode->i_sb; in ext4_collapse_range()
5281 return -EOPNOTSUPP; in ext4_collapse_range()
5285 return -EINVAL; in ext4_collapse_range()
5294 ret = ext4_force_commit(inode->i_sb); in ext4_collapse_range()
5304 if (offset + len >= inode->i_size) { in ext4_collapse_range()
5305 ret = -EINVAL; in ext4_collapse_range()
5311 ret = -EOPNOTSUPP; in ext4_collapse_range()
5326 down_write(&EXT4_I(inode)->i_mmap_sem); in ext4_collapse_range()
5341 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset); in ext4_collapse_range()
5349 ret = filemap_write_and_wait_range(inode->i_mapping, offset + len, in ext4_collapse_range()
5363 down_write(&EXT4_I(inode)->i_data_sem); in ext4_collapse_range()
5367 EXT_MAX_BLOCKS - punch_start); in ext4_collapse_range()
5369 up_write(&EXT4_I(inode)->i_data_sem); in ext4_collapse_range()
5373 ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1); in ext4_collapse_range()
5375 up_write(&EXT4_I(inode)->i_data_sem); in ext4_collapse_range()
5381 punch_stop - punch_start, SHIFT_LEFT); in ext4_collapse_range()
5383 up_write(&EXT4_I(inode)->i_data_sem); in ext4_collapse_range()
5387 new_size = inode->i_size - len; in ext4_collapse_range()
5389 EXT4_I(inode)->i_disksize = new_size; in ext4_collapse_range()
5391 up_write(&EXT4_I(inode)->i_data_sem); in ext4_collapse_range()
5394 inode->i_mtime = inode->i_ctime = current_time(inode); in ext4_collapse_range()
5402 up_write(&EXT4_I(inode)->i_mmap_sem); in ext4_collapse_range()
5419 struct super_block *sb = inode->i_sb; in ext4_insert_range()
5421 struct ext4_ext_path *path; in ext4_insert_range() local
5434 return -EOPNOTSUPP; in ext4_insert_range()
5438 return -EINVAL; in ext4_insert_range()
5447 ret = ext4_force_commit(inode->i_sb); in ext4_insert_range()
5455 ret = -EOPNOTSUPP; in ext4_insert_range()
5460 if (len > inode->i_sb->s_maxbytes - inode->i_size) { in ext4_insert_range()
5461 ret = -EFBIG; in ext4_insert_range()
5466 if (offset >= inode->i_size) { in ext4_insert_range()
5467 ret = -EINVAL; in ext4_insert_range()
5482 down_write(&EXT4_I(inode)->i_mmap_sem); in ext4_insert_range()
5494 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, in ext4_insert_range()
5509 inode->i_size += len; in ext4_insert_range()
5510 EXT4_I(inode)->i_disksize += len; in ext4_insert_range()
5511 inode->i_mtime = inode->i_ctime = current_time(inode); in ext4_insert_range()
5516 down_write(&EXT4_I(inode)->i_data_sem); in ext4_insert_range()
5519 path = ext4_find_extent(inode, offset_lblk, NULL, 0); in ext4_insert_range()
5520 if (IS_ERR(path)) { in ext4_insert_range()
5521 up_write(&EXT4_I(inode)->i_data_sem); in ext4_insert_range()
5526 extent = path[depth].p_ext; in ext4_insert_range()
5528 ee_start_lblk = le32_to_cpu(extent->ee_block); in ext4_insert_range()
5540 ret = ext4_split_extent_at(handle, inode, &path, in ext4_insert_range()
5547 ext4_ext_drop_refs(path); in ext4_insert_range()
5548 kfree(path); in ext4_insert_range()
5550 up_write(&EXT4_I(inode)->i_data_sem); in ext4_insert_range()
5554 ext4_ext_drop_refs(path); in ext4_insert_range()
5555 kfree(path); in ext4_insert_range()
5559 EXT_MAX_BLOCKS - offset_lblk); in ext4_insert_range()
5561 up_write(&EXT4_I(inode)->i_data_sem); in ext4_insert_range()
5573 up_write(&EXT4_I(inode)->i_data_sem); in ext4_insert_range()
5583 up_write(&EXT4_I(inode)->i_mmap_sem); in ext4_insert_range()
5590 * ext4_swap_extents() - Swap extents between two inodes
5601 * stuff such as page-cache locking consistency, bh mapping consistency or
5618 BUG_ON(!rwsem_is_locked(&EXT4_I(inode1)->i_data_sem)); in ext4_swap_extents()
5619 BUG_ON(!rwsem_is_locked(&EXT4_I(inode2)->i_data_sem)); in ext4_swap_extents()
5650 ex1 = path1[path1->p_depth].p_ext; in ext4_swap_extents()
5651 ex2 = path2[path2->p_depth].p_ext; in ext4_swap_extents()
5656 e1_blk = le32_to_cpu(ex1->ee_block); in ext4_swap_extents()
5657 e2_blk = le32_to_cpu(ex2->ee_block); in ext4_swap_extents()
5678 len = next1 - lblk1; in ext4_swap_extents()
5679 if (len < next2 - lblk2) in ext4_swap_extents()
5680 len = next2 - lblk2; in ext4_swap_extents()
5685 count -= len; in ext4_swap_extents()
5705 * path must to be revalidated. */ in ext4_swap_extents()
5711 if (len > e1_blk + e1_len - lblk1) in ext4_swap_extents()
5712 len = e1_blk + e1_len - lblk1; in ext4_swap_extents()
5713 if (len > e2_blk + e2_len - lblk2) in ext4_swap_extents()
5714 len = e2_blk + e2_len - lblk2; in ext4_swap_extents()
5731 * path must to be revalidated. */ in ext4_swap_extents()
5736 *erp = ext4_ext_get_access(handle, inode1, path1 + path1->p_depth); in ext4_swap_extents()
5739 *erp = ext4_ext_get_access(handle, inode2, path2 + path2->p_depth); in ext4_swap_extents()
5747 ex1->ee_len = cpu_to_le16(e2_len); in ext4_swap_extents()
5748 ex2->ee_len = cpu_to_le16(e1_len); in ext4_swap_extents()
5757 path2->p_depth); in ext4_swap_extents()
5761 path1->p_depth); in ext4_swap_extents()
5773 count -= len; in ext4_swap_extents()
5786 * ext4_clu_mapped - determine whether any block in a logical cluster has
5789 * @inode - file containing the logical cluster
5790 * @lclu - logical cluster of interest
5799 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); in ext4_clu_mapped()
5800 struct ext4_ext_path *path; in ext4_clu_mapped() local
5806 path = ext4_find_extent(inode, EXT4_C2B(sbi, lclu), NULL, 0); in ext4_clu_mapped()
5807 if (IS_ERR(path)) { in ext4_clu_mapped()
5808 err = PTR_ERR(path); in ext4_clu_mapped()
5809 path = NULL; in ext4_clu_mapped()
5820 if (unlikely(path[depth].p_ext == NULL && depth != 0)) { in ext4_clu_mapped()
5822 "bad extent address - lblock: %lu, depth: %d, pblock: %lld", in ext4_clu_mapped()
5824 depth, path[depth].p_block); in ext4_clu_mapped()
5825 err = -EFSCORRUPTED; in ext4_clu_mapped()
5829 extent = path[depth].p_ext; in ext4_clu_mapped()
5835 first_lblk = le32_to_cpu(extent->ee_block); in ext4_clu_mapped()
5839 * Three possible outcomes at this point - found extent spanning in ext4_clu_mapped()
5846 ext4_ext_get_actual_len(extent) - 1); in ext4_clu_mapped()
5850 first_lblk = ext4_ext_next_allocated_block(path); in ext4_clu_mapped()
5858 ext4_ext_drop_refs(path); in ext4_clu_mapped()
5859 kfree(path); in ext4_clu_mapped()
5869 * replay path. Returns 0 on success and error on failure.
5874 struct ext4_ext_path *path = NULL, *ppath; in ext4_ext_replay_update_ex() local
5878 path = ext4_find_extent(inode, start, NULL, 0); in ext4_ext_replay_update_ex()
5879 if (IS_ERR(path)) in ext4_ext_replay_update_ex()
5880 return PTR_ERR(path); in ext4_ext_replay_update_ex()
5881 ex = path[path->p_depth].p_ext; in ext4_ext_replay_update_ex()
5883 ret = -EFSCORRUPTED; in ext4_ext_replay_update_ex()
5887 if (le32_to_cpu(ex->ee_block) != start || in ext4_ext_replay_update_ex()
5890 ppath = path; in ext4_ext_replay_update_ex()
5891 down_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_update_ex()
5893 up_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_update_ex()
5896 kfree(path); in ext4_ext_replay_update_ex()
5897 path = ext4_find_extent(inode, start, NULL, 0); in ext4_ext_replay_update_ex()
5898 if (IS_ERR(path)) in ext4_ext_replay_update_ex()
5899 return -1; in ext4_ext_replay_update_ex()
5900 ppath = path; in ext4_ext_replay_update_ex()
5901 ex = path[path->p_depth].p_ext; in ext4_ext_replay_update_ex()
5902 WARN_ON(le32_to_cpu(ex->ee_block) != start); in ext4_ext_replay_update_ex()
5904 down_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_update_ex()
5907 up_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_update_ex()
5910 kfree(path); in ext4_ext_replay_update_ex()
5911 path = ext4_find_extent(inode, start, NULL, 0); in ext4_ext_replay_update_ex()
5912 if (IS_ERR(path)) in ext4_ext_replay_update_ex()
5913 return -EINVAL; in ext4_ext_replay_update_ex()
5914 ex = path[path->p_depth].p_ext; in ext4_ext_replay_update_ex()
5922 down_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_update_ex()
5923 ret = ext4_ext_dirty(NULL, inode, &path[path->p_depth]); in ext4_ext_replay_update_ex()
5924 up_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_update_ex()
5926 ext4_ext_drop_refs(path); in ext4_ext_replay_update_ex()
5927 kfree(path); in ext4_ext_replay_update_ex()
5935 struct ext4_ext_path *path = NULL; in ext4_ext_replay_shrink_inode() local
5940 path = ext4_find_extent(inode, cur, NULL, 0); in ext4_ext_replay_shrink_inode()
5941 if (IS_ERR(path)) in ext4_ext_replay_shrink_inode()
5943 ex = path[path->p_depth].p_ext; in ext4_ext_replay_shrink_inode()
5945 ext4_ext_drop_refs(path); in ext4_ext_replay_shrink_inode()
5946 kfree(path); in ext4_ext_replay_shrink_inode()
5951 cur = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex); in ext4_ext_replay_shrink_inode()
5954 ext4_ext_try_to_merge(NULL, inode, path, ex); in ext4_ext_replay_shrink_inode()
5955 down_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_shrink_inode()
5956 ext4_ext_dirty(NULL, inode, &path[path->p_depth]); in ext4_ext_replay_shrink_inode()
5957 up_write(&EXT4_I(inode)->i_data_sem); in ext4_ext_replay_shrink_inode()
5959 ext4_ext_drop_refs(path); in ext4_ext_replay_shrink_inode()
5960 kfree(path); in ext4_ext_replay_shrink_inode()
5968 struct ext4_map_blocks map; in skip_hole() local
5970 map.m_lblk = *cur; in skip_hole()
5971 map.m_len = ((inode->i_size) >> inode->i_sb->s_blocksize_bits) - *cur; in skip_hole()
5973 ret = ext4_map_blocks(NULL, inode, &map, 0); in skip_hole()
5978 *cur = *cur + map.m_len; in skip_hole()
5985 struct ext4_ext_path *path = NULL, *path2 = NULL; in ext4_ext_replay_set_iblocks() local
5990 struct ext4_map_blocks map; in ext4_ext_replay_set_iblocks() local
5993 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL, in ext4_ext_replay_set_iblocks()
5995 if (IS_ERR(path)) in ext4_ext_replay_set_iblocks()
5996 return PTR_ERR(path); in ext4_ext_replay_set_iblocks()
5997 ex = path[path->p_depth].p_ext; in ext4_ext_replay_set_iblocks()
5999 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6000 kfree(path); in ext4_ext_replay_set_iblocks()
6003 end = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex); in ext4_ext_replay_set_iblocks()
6004 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6005 kfree(path); in ext4_ext_replay_set_iblocks()
6010 map.m_lblk = cur; in ext4_ext_replay_set_iblocks()
6011 map.m_len = end - cur; in ext4_ext_replay_set_iblocks()
6012 ret = ext4_map_blocks(NULL, inode, &map, 0); in ext4_ext_replay_set_iblocks()
6017 cur = cur + map.m_len; in ext4_ext_replay_set_iblocks()
6023 * their paths. When path is different for 2 successive extents in ext4_ext_replay_set_iblocks()
6024 * we compare the blocks in the path at each level and increment in ext4_ext_replay_set_iblocks()
6031 path = ext4_find_extent(inode, cur, NULL, 0); in ext4_ext_replay_set_iblocks()
6032 if (IS_ERR(path)) in ext4_ext_replay_set_iblocks()
6034 numblks += path->p_depth; in ext4_ext_replay_set_iblocks()
6035 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6036 kfree(path); in ext4_ext_replay_set_iblocks()
6038 path = ext4_find_extent(inode, cur, NULL, 0); in ext4_ext_replay_set_iblocks()
6039 if (IS_ERR(path)) in ext4_ext_replay_set_iblocks()
6041 ex = path[path->p_depth].p_ext; in ext4_ext_replay_set_iblocks()
6043 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6044 kfree(path); in ext4_ext_replay_set_iblocks()
6047 cur = max(cur + 1, le32_to_cpu(ex->ee_block) + in ext4_ext_replay_set_iblocks()
6051 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6052 kfree(path); in ext4_ext_replay_set_iblocks()
6057 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6058 kfree(path); in ext4_ext_replay_set_iblocks()
6061 ex = path2[path2->p_depth].p_ext; in ext4_ext_replay_set_iblocks()
6062 for (i = 0; i <= max(path->p_depth, path2->p_depth); i++) { in ext4_ext_replay_set_iblocks()
6064 if (i <= path->p_depth) in ext4_ext_replay_set_iblocks()
6065 cmp1 = path[i].p_bh ? in ext4_ext_replay_set_iblocks()
6066 path[i].p_bh->b_blocknr : 0; in ext4_ext_replay_set_iblocks()
6067 if (i <= path2->p_depth) in ext4_ext_replay_set_iblocks()
6069 path2[i].p_bh->b_blocknr : 0; in ext4_ext_replay_set_iblocks()
6073 ext4_ext_drop_refs(path); in ext4_ext_replay_set_iblocks()
6075 kfree(path); in ext4_ext_replay_set_iblocks()
6080 inode->i_blocks = numblks << (inode->i_sb->s_blocksize_bits - 9); in ext4_ext_replay_set_iblocks()
6087 struct ext4_ext_path *path = NULL; in ext4_ext_clear_bb() local
6091 struct ext4_map_blocks map; in ext4_ext_clear_bb() local
6094 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL, in ext4_ext_clear_bb()
6096 if (IS_ERR(path)) in ext4_ext_clear_bb()
6097 return PTR_ERR(path); in ext4_ext_clear_bb()
6098 ex = path[path->p_depth].p_ext; in ext4_ext_clear_bb()
6100 ext4_ext_drop_refs(path); in ext4_ext_clear_bb()
6101 kfree(path); in ext4_ext_clear_bb()
6104 end = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex); in ext4_ext_clear_bb()
6105 ext4_ext_drop_refs(path); in ext4_ext_clear_bb()
6106 kfree(path); in ext4_ext_clear_bb()
6110 map.m_lblk = cur; in ext4_ext_clear_bb()
6111 map.m_len = end - cur; in ext4_ext_clear_bb()
6112 ret = ext4_map_blocks(NULL, inode, &map, 0); in ext4_ext_clear_bb()
6116 path = ext4_find_extent(inode, map.m_lblk, NULL, 0); in ext4_ext_clear_bb()
6117 if (!IS_ERR_OR_NULL(path)) { in ext4_ext_clear_bb()
6118 for (j = 0; j < path->p_depth; j++) { in ext4_ext_clear_bb()
6120 ext4_mb_mark_bb(inode->i_sb, in ext4_ext_clear_bb()
6121 path[j].p_block, 1, 0); in ext4_ext_clear_bb()
6122 ext4_fc_record_regions(inode->i_sb, inode->i_ino, in ext4_ext_clear_bb()
6123 0, path[j].p_block, 1, 1); in ext4_ext_clear_bb()
6125 ext4_ext_drop_refs(path); in ext4_ext_clear_bb()
6126 kfree(path); in ext4_ext_clear_bb()
6128 ext4_mb_mark_bb(inode->i_sb, map.m_pblk, map.m_len, 0); in ext4_ext_clear_bb()
6129 ext4_fc_record_regions(inode->i_sb, inode->i_ino, in ext4_ext_clear_bb()
6130 map.m_lblk, map.m_pblk, map.m_len, 1); in ext4_ext_clear_bb()
6132 cur = cur + map.m_len; in ext4_ext_clear_bb()