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>
52 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_extent_block_csum()
55 	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh,  in ext4_extent_block_csum()
65 	if (!ext4_has_metadata_csum(inode->i_sb))  in ext4_extent_block_csum_verify()
69 	if (et->et_checksum != ext4_extent_block_csum(inode, eh))  in ext4_extent_block_csum_verify()
79 	if (!ext4_has_metadata_csum(inode->i_sb))  in ext4_extent_block_csum_set()
83 	et->et_checksum = ext4_extent_block_csum(inode, eh);  in ext4_extent_block_csum_set()
111 	if (handle->h_buffer_credits >= needed)  in ext4_ext_truncate_extend_restart()
118 	err = ext4_journal_extend(handle, needed - handle->h_buffer_credits);  in ext4_ext_truncate_extend_restart()
123 		err = -EAGAIN;  in ext4_ext_truncate_extend_restart()
130  *  - EROFS
131  *  - ENOMEM
136 	if (path->p_bh) {  in ext4_ext_get_access()
138 		BUFFER_TRACE(path->p_bh, "get_write_access");  in ext4_ext_get_access()
139 		return ext4_journal_get_write_access(handle, path->p_bh);  in ext4_ext_get_access()
142 	/* we use in-core data, no need to protect them */  in ext4_ext_get_access()
148  *  - EROFS
149  *  - ENOMEM
150  *  - EIO
157 	WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem));  in __ext4_ext_dirty()
158 	if (path->p_bh) {  in __ext4_ext_dirty()
159 		ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh));  in __ext4_ext_dirty()
162 						   inode, path->p_bh);  in __ext4_ext_dirty()
175 		int depth = path->p_depth;  in ext4_ext_find_goal()  local
181 		 * non-sparse --- i.e., in the case of libbfd writing  in ext4_ext_find_goal()
182 		 * an ELF object sections out-of-order but in a way  in ext4_ext_find_goal()
186 		 * non-ideal if we are writing a sparse file such as  in ext4_ext_find_goal()
195 		ex = path[depth].p_ext;  in ext4_ext_find_goal()
198 			ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block);  in ext4_ext_find_goal()
201 				return ext_pblk + (block - ext_block);  in ext4_ext_find_goal()
203 				return ext_pblk - (ext_block - block);  in ext4_ext_find_goal()
208 		if (path[depth].p_bh)  in ext4_ext_find_goal()
209 			return path[depth].p_bh->b_blocknr;  in ext4_ext_find_goal()
226 	goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));  in ext4_ext_new_meta_block()
236 	size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))  in ext4_ext_space_block()
249 	size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))  in ext4_ext_space_block_idx()
262 	size = sizeof(EXT4_I(inode)->i_data);  in ext4_ext_space_root()
263 	size -= sizeof(struct ext4_extent_header);  in ext4_ext_space_root()
276 	size = sizeof(EXT4_I(inode)->i_data);  in ext4_ext_space_root_idx()
277 	size -= sizeof(struct ext4_extent_header);  in ext4_ext_space_root_idx()
292 	int unwritten = ext4_ext_is_unwritten(path[path->p_depth].p_ext);  in ext4_force_split_extent_at()
310 	idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))  in ext4_ext_calc_metadata_amount()
321 	if (ei->i_da_metadata_calc_len &&  in ext4_ext_calc_metadata_amount()
322 	    ei->i_da_metadata_calc_last_lblock+1 == lblock) {  in ext4_ext_calc_metadata_amount()
325 		if ((ei->i_da_metadata_calc_len % idxs) == 0)  in ext4_ext_calc_metadata_amount()
327 		if ((ei->i_da_metadata_calc_len % (idxs*idxs)) == 0)  in ext4_ext_calc_metadata_amount()
329 		if ((ei->i_da_metadata_calc_len % (idxs*idxs*idxs)) == 0) {  in ext4_ext_calc_metadata_amount()
331 			ei->i_da_metadata_calc_len = 0;  in ext4_ext_calc_metadata_amount()
333 			ei->i_da_metadata_calc_len++;  in ext4_ext_calc_metadata_amount()
334 		ei->i_da_metadata_calc_last_lblock++;  in ext4_ext_calc_metadata_amount()
342 	ei->i_da_metadata_calc_len = 1;  in ext4_ext_calc_metadata_amount()
343 	ei->i_da_metadata_calc_last_lblock = lblock;  in ext4_ext_calc_metadata_amount()
348 ext4_ext_max_entries(struct inode *inode, int depth)  in ext4_ext_max_entries()  argument
352 	if (depth == ext_depth(inode)) {  in ext4_ext_max_entries()
353 		if (depth == 0)  in ext4_ext_max_entries()
358 		if (depth == 0)  in ext4_ext_max_entries()
371 	ext4_lblk_t lblock = le32_to_cpu(ext->ee_block);  in ext4_valid_extent()
375 	 *  - zero length  in ext4_valid_extent()
376 	 *  - overflow/wrap-around  in ext4_valid_extent()
380 	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);  in ext4_valid_extent()
388 	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);  in ext4_valid_extent_idx()
393 				int depth)  in ext4_valid_extent_entries()  argument
396 	if (eh->eh_entries == 0)  in ext4_valid_extent_entries()
399 	entries = le16_to_cpu(eh->eh_entries);  in ext4_valid_extent_entries()
401 	if (depth == 0) {  in ext4_valid_extent_entries()
404 		struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;  in ext4_valid_extent_entries()
414 			lblock = le32_to_cpu(ext->ee_block);  in ext4_valid_extent_entries()
418 				es->s_last_error_block = cpu_to_le64(pblock);  in ext4_valid_extent_entries()
422 			entries--;  in ext4_valid_extent_entries()
423 			prev = lblock + len - 1;  in ext4_valid_extent_entries()
431 			entries--;  in ext4_valid_extent_entries()
439 			    int depth, ext4_fsblk_t pblk)  in __ext4_ext_check()  argument
442 	int max = 0, err = -EFSCORRUPTED;  in __ext4_ext_check()
444 	if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) {  in __ext4_ext_check()
448 	if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {  in __ext4_ext_check()
452 	if (unlikely(eh->eh_max == 0)) {  in __ext4_ext_check()
456 	max = ext4_ext_max_entries(inode, depth);  in __ext4_ext_check()
457 	if (unlikely(le16_to_cpu(eh->eh_max) > max)) {  in __ext4_ext_check()
461 	if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) {  in __ext4_ext_check()
465 	if (!ext4_valid_extent_entries(inode, eh, depth)) {  in __ext4_ext_check()
469 	if (unlikely(depth > 32)) {  in __ext4_ext_check()
473 	/* Verify checksum on non-root extent tree nodes */  in __ext4_ext_check()
474 	if (ext_depth(inode) != depth &&  in __ext4_ext_check()
477 		err = -EFSBADCRC;  in __ext4_ext_check()
484 			 "pblk %llu bad header/extent: %s - magic %x, "  in __ext4_ext_check()
485 			 "entries %u, max %u(%u), depth %u(%u)",  in __ext4_ext_check()
487 			 le16_to_cpu(eh->eh_magic),  in __ext4_ext_check()
488 			 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max),  in __ext4_ext_check()
489 			 max, le16_to_cpu(eh->eh_depth), depth);  in __ext4_ext_check()
493 #define ext4_ext_check(inode, eh, depth, pblk)			\  argument
494 	__ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk))
508 	for (i = le16_to_cpu(eh->eh_entries); i > 0; i--, ex++) {  in ext4_cache_extents()
510 		ext4_lblk_t lblk = le32_to_cpu(ex->ee_block);  in ext4_cache_extents()
514 			ext4_es_cache_extent(inode, prev, lblk - prev, ~0,  in ext4_cache_extents()
527 			 struct inode *inode, ext4_fsblk_t pblk, int depth,  in __read_extent_tree_block()  argument
533 	bh = sb_getblk_gfp(inode->i_sb, pblk, __GFP_MOVABLE | GFP_NOFS);  in __read_extent_tree_block()
535 		return ERR_PTR(-ENOMEM);  in __read_extent_tree_block()
545 	if (!ext4_has_feature_journal(inode->i_sb) ||  in __read_extent_tree_block()
546 	    (inode->i_ino !=  in __read_extent_tree_block()
547 	     le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum))) {  in __read_extent_tree_block()
549 				       ext_block_hdr(bh), depth, pblk);  in __read_extent_tree_block()
557 	if (!(flags & EXT4_EX_NOCACHE) && depth == 0) {  in __read_extent_tree_block()
568 #define read_extent_tree_block(inode, pblk, depth, flags)		\  argument
570 				 (depth), (flags))
581 	int i = 0, depth, ret = 0;  in ext4_ext_precache()  local
584 		return 0;	/* not an extent-mapped inode */  in ext4_ext_precache()
586 	down_read(&ei->i_data_sem);  in ext4_ext_precache()
587 	depth = ext_depth(inode);  in ext4_ext_precache()
589 	path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),  in ext4_ext_precache()
592 		up_read(&ei->i_data_sem);  in ext4_ext_precache()
593 		return -ENOMEM;  in ext4_ext_precache()
597 	if (depth == 0)  in ext4_ext_precache()
600 	ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0);  in ext4_ext_precache()
609 		if ((i == depth) ||  in ext4_ext_precache()
613 			i--;  in ext4_ext_precache()
618 					    depth - i - 1,  in ext4_ext_precache()
631 	up_read(&ei->i_data_sem);  in ext4_ext_precache()
640 	int k, l = path->p_depth;  in ext4_ext_show_path()
644 		if (path->p_idx) {  in ext4_ext_show_path()
645 		  ext_debug("  %d->%llu", le32_to_cpu(path->p_idx->ei_block),  in ext4_ext_show_path()
646 			    ext4_idx_pblock(path->p_idx));  in ext4_ext_show_path()
647 		} else if (path->p_ext) {  in ext4_ext_show_path()
649 				  le32_to_cpu(path->p_ext->ee_block),  in ext4_ext_show_path()
650 				  ext4_ext_is_unwritten(path->p_ext),  in ext4_ext_show_path()
651 				  ext4_ext_get_actual_len(path->p_ext),  in ext4_ext_show_path()
652 				  ext4_ext_pblock(path->p_ext));  in ext4_ext_show_path()
661 	int depth = ext_depth(inode);  in ext4_ext_show_leaf()  local
669 	eh = path[depth].p_hdr;  in ext4_ext_show_leaf()
672 	ext_debug("Displaying leaf extents for inode %lu\n", inode->i_ino);  in ext4_ext_show_leaf()
674 	for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) {  in ext4_ext_show_leaf()
675 		ext_debug("%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),  in ext4_ext_show_leaf()
685 	int depth = ext_depth(inode);  in ext4_ext_show_move()  local
688 	if (depth != level) {  in ext4_ext_show_move()
693 					le32_to_cpu(idx->ei_block),  in ext4_ext_show_move()
702 	ex = path[depth].p_ext;  in ext4_ext_show_move()
703 	while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) {  in ext4_ext_show_move()
705 				le32_to_cpu(ex->ee_block),  in ext4_ext_show_move()
722 	int depth, i;  in ext4_ext_drop_refs()  local
726 	depth = path->p_depth;  in ext4_ext_drop_refs()
727 	for (i = 0; i <= depth; i++, path++)  in ext4_ext_drop_refs()
728 		if (path->p_bh) {  in ext4_ext_drop_refs()
729 			brelse(path->p_bh);  in ext4_ext_drop_refs()
730 			path->p_bh = NULL;  in ext4_ext_drop_refs()
743 	struct ext4_extent_header *eh = path->p_hdr;  in ext4_ext_binsearch_idx()
752 		m = l + (r - l) / 2;  in ext4_ext_binsearch_idx()
753 		if (block < le32_to_cpu(m->ei_block))  in ext4_ext_binsearch_idx()
754 			r = m - 1;  in ext4_ext_binsearch_idx()
757 		ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ei_block),  in ext4_ext_binsearch_idx()
758 				m, le32_to_cpu(m->ei_block),  in ext4_ext_binsearch_idx()
759 				r, le32_to_cpu(r->ei_block));  in ext4_ext_binsearch_idx()
762 	path->p_idx = l - 1;  in ext4_ext_binsearch_idx()
763 	ext_debug("  -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block),  in ext4_ext_binsearch_idx()
764 		  ext4_idx_pblock(path->p_idx));  in ext4_ext_binsearch_idx()
772 		for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {  in ext4_ext_binsearch_idx()
774 		      le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) {  in ext4_ext_binsearch_idx()
779 				       le32_to_cpu(ix->ei_block),  in ext4_ext_binsearch_idx()
780 				       le32_to_cpu(ix[-1].ei_block));  in ext4_ext_binsearch_idx()
782 			BUG_ON(k && le32_to_cpu(ix->ei_block)  in ext4_ext_binsearch_idx()
783 					   <= le32_to_cpu(ix[-1].ei_block));  in ext4_ext_binsearch_idx()
784 			if (block < le32_to_cpu(ix->ei_block))  in ext4_ext_binsearch_idx()
788 		BUG_ON(chix != path->p_idx);  in ext4_ext_binsearch_idx()
803 	struct ext4_extent_header *eh = path->p_hdr;  in ext4_ext_binsearch()
806 	if (eh->eh_entries == 0) {  in ext4_ext_binsearch()
820 		m = l + (r - l) / 2;  in ext4_ext_binsearch()
821 		if (block < le32_to_cpu(m->ee_block))  in ext4_ext_binsearch()
822 			r = m - 1;  in ext4_ext_binsearch()
825 		ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ee_block),  in ext4_ext_binsearch()
826 				m, le32_to_cpu(m->ee_block),  in ext4_ext_binsearch()
827 				r, le32_to_cpu(r->ee_block));  in ext4_ext_binsearch()
830 	path->p_ext = l - 1;  in ext4_ext_binsearch()
831 	ext_debug("  -> %d:%llu:[%d]%d ",  in ext4_ext_binsearch()
832 			le32_to_cpu(path->p_ext->ee_block),  in ext4_ext_binsearch()
833 			ext4_ext_pblock(path->p_ext),  in ext4_ext_binsearch()
834 			ext4_ext_is_unwritten(path->p_ext),  in ext4_ext_binsearch()
835 			ext4_ext_get_actual_len(path->p_ext));  in ext4_ext_binsearch()
843 		for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) {  in ext4_ext_binsearch()
844 			BUG_ON(k && le32_to_cpu(ex->ee_block)  in ext4_ext_binsearch()
845 					  <= le32_to_cpu(ex[-1].ee_block));  in ext4_ext_binsearch()
846 			if (block < le32_to_cpu(ex->ee_block))  in ext4_ext_binsearch()
850 		BUG_ON(chex != path->p_ext);  in ext4_ext_binsearch()
861 	eh->eh_depth = 0;  in ext4_ext_tree_init()
862 	eh->eh_entries = 0;  in ext4_ext_tree_init()
863 	eh->eh_magic = EXT4_EXT_MAGIC;  in ext4_ext_tree_init()
864 	eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));  in ext4_ext_tree_init()
876 	short int depth, i, ppos = 0;  in ext4_find_extent()  local
880 	depth = ext_depth(inode);  in ext4_find_extent()
881 	if (depth < 0 || depth > EXT4_MAX_EXTENT_DEPTH) {  in ext4_find_extent()
882 		EXT4_ERROR_INODE(inode, "inode has invalid extent depth: %d",  in ext4_find_extent()
883 				 depth);  in ext4_find_extent()
884 		ret = -EFSCORRUPTED;  in ext4_find_extent()
890 		if (depth > path[0].p_maxdepth) {  in ext4_find_extent()
896 		/* account possible depth increase */  in ext4_find_extent()
897 		path = kcalloc(depth + 2, sizeof(struct ext4_ext_path),  in ext4_find_extent()
900 			return ERR_PTR(-ENOMEM);  in ext4_find_extent()
901 		path[0].p_maxdepth = depth + 1;  in ext4_find_extent()
906 	i = depth;  in ext4_find_extent()
907 	if (!(flags & EXT4_EX_NOCACHE) && depth == 0)  in ext4_find_extent()
911 		ext_debug("depth %d: num %d, max %d\n",  in ext4_find_extent()
912 			  ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));  in ext4_find_extent()
919 		bh = read_extent_tree_block(inode, path[ppos].p_block, --i,  in ext4_find_extent()
970 	if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) {  in ext4_ext_insert_index()
973 				 logical, le32_to_cpu(curp->p_idx->ei_block));  in ext4_ext_insert_index()
974 		return -EFSCORRUPTED;  in ext4_ext_insert_index()
977 	if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries)  in ext4_ext_insert_index()
978 			     >= le16_to_cpu(curp->p_hdr->eh_max))) {  in ext4_ext_insert_index()
981 				 le16_to_cpu(curp->p_hdr->eh_entries),  in ext4_ext_insert_index()
982 				 le16_to_cpu(curp->p_hdr->eh_max));  in ext4_ext_insert_index()
983 		return -EFSCORRUPTED;  in ext4_ext_insert_index()
986 	if (logical > le32_to_cpu(curp->p_idx->ei_block)) {  in ext4_ext_insert_index()
989 		ix = curp->p_idx + 1;  in ext4_ext_insert_index()
993 		ix = curp->p_idx;  in ext4_ext_insert_index()
996 	len = EXT_LAST_INDEX(curp->p_hdr) - ix + 1;  in ext4_ext_insert_index()
1005 	if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) {  in ext4_ext_insert_index()
1007 		return -EFSCORRUPTED;  in ext4_ext_insert_index()
1010 	ix->ei_block = cpu_to_le32(logical);  in ext4_ext_insert_index()
1012 	le16_add_cpu(&curp->p_hdr->eh_entries, 1);  in ext4_ext_insert_index()
1014 	if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) {  in ext4_ext_insert_index()
1016 		return -EFSCORRUPTED;  in ext4_ext_insert_index()
1020 	ext4_std_error(inode->i_sb, err);  in ext4_ext_insert_index()
1028  * at depth @at:
1029  * - allocates all needed blocks (new leaf and all intermediate index blocks)
1030  * - makes decision where to split
1031  * - moves remaining extents and index entries (right to the split point)
1033  * - initializes subtree
1041 	int depth = ext_depth(inode);  in ext4_ext_split()  local
1056 	if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {  in ext4_ext_split()
1058 		return -EFSCORRUPTED;  in ext4_ext_split()
1060 	if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {  in ext4_ext_split()
1061 		border = path[depth].p_ext[1].ee_block;  in ext4_ext_split()
1066 		border = newext->ee_block;  in ext4_ext_split()
1074 	 * and mark filesystem read-only. index won't  in ext4_ext_split()
1084 	ablocks = kcalloc(depth, sizeof(ext4_fsblk_t), GFP_NOFS);  in ext4_ext_split()
1086 		return -ENOMEM;  in ext4_ext_split()
1089 	ext_debug("allocate %d blocks for indexes/leaf\n", depth - at);  in ext4_ext_split()
1090 	for (a = 0; a < depth - at; a++) {  in ext4_ext_split()
1099 	newblock = ablocks[--a];  in ext4_ext_split()
1102 		err = -EFSCORRUPTED;  in ext4_ext_split()
1105 	bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);  in ext4_ext_split()
1107 		err = -ENOMEM;  in ext4_ext_split()
1117 	neh->eh_entries = 0;  in ext4_ext_split()
1118 	neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));  in ext4_ext_split()
1119 	neh->eh_magic = EXT4_EXT_MAGIC;  in ext4_ext_split()
1120 	neh->eh_depth = 0;  in ext4_ext_split()
1122 	/* move remainder of path[depth] to the new leaf */  in ext4_ext_split()
1123 	if (unlikely(path[depth].p_hdr->eh_entries !=  in ext4_ext_split()
1124 		     path[depth].p_hdr->eh_max)) {  in ext4_ext_split()
1126 				 path[depth].p_hdr->eh_entries,  in ext4_ext_split()
1127 				 path[depth].p_hdr->eh_max);  in ext4_ext_split()
1128 		err = -EFSCORRUPTED;  in ext4_ext_split()
1132 	m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++;  in ext4_ext_split()
1133 	ext4_ext_show_move(inode, path, newblock, depth);  in ext4_ext_split()
1137 		memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m);  in ext4_ext_split()
1138 		le16_add_cpu(&neh->eh_entries, m);  in ext4_ext_split()
1143 		sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries);  in ext4_ext_split()
1144 	memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);  in ext4_ext_split()
1157 		err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_ext_split()
1160 		le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);  in ext4_ext_split()
1161 		err = ext4_ext_dirty(handle, inode, path + depth);  in ext4_ext_split()
1168 	k = depth - at - 1;  in ext4_ext_split()
1171 		err = -EFSCORRUPTED;  in ext4_ext_split()
1177 	/* current depth stored in i var */  in ext4_ext_split()
1178 	i = depth - 1;  in ext4_ext_split()
1179 	while (k--) {  in ext4_ext_split()
1181 		newblock = ablocks[--a];  in ext4_ext_split()
1182 		bh = sb_getblk(inode->i_sb, newblock);  in ext4_ext_split()
1184 			err = -ENOMEM;  in ext4_ext_split()
1194 		neh->eh_entries = cpu_to_le16(1);  in ext4_ext_split()
1195 		neh->eh_magic = EXT4_EXT_MAGIC;  in ext4_ext_split()
1196 		neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));  in ext4_ext_split()
1197 		neh->eh_depth = cpu_to_le16(depth - i);  in ext4_ext_split()
1199 		fidx->ei_block = border;  in ext4_ext_split()
1202 		ext_debug("int.index at %d (block %llu): %u -> %llu\n",  in ext4_ext_split()
1210 					 le32_to_cpu(path[i].p_ext->ee_block));  in ext4_ext_split()
1211 			err = -EFSCORRUPTED;  in ext4_ext_split()
1215 		m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++;  in ext4_ext_split()
1222 			le16_add_cpu(&neh->eh_entries, m);  in ext4_ext_split()
1226 		   (sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries));  in ext4_ext_split()
1227 		memset(bh->b_data + ext_size, 0,  in ext4_ext_split()
1228 			inode->i_sb->s_blocksize - ext_size);  in ext4_ext_split()
1244 			le16_add_cpu(&path[i].p_hdr->eh_entries, -m);  in ext4_ext_split()
1250 		i--;  in ext4_ext_split()
1266 		for (i = 0; i < depth; i++) {  in ext4_ext_split()
1281  * - allocates new block
1282  * - moves top-level data (index block or leaf) into the new block
1283  * - initializes new top-level, creating index that points to the
1292 	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;  in ext4_ext_grow_indepth()
1299 	if (goal > le32_to_cpu(es->s_first_data_block)) {  in ext4_ext_grow_indepth()
1301 		goal--;  in ext4_ext_grow_indepth()
1309 	bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);  in ext4_ext_grow_indepth()
1311 		return -ENOMEM;  in ext4_ext_grow_indepth()
1320 	ext_size = sizeof(EXT4_I(inode)->i_data);  in ext4_ext_grow_indepth()
1321 	/* move top-level index/leaf into new block */  in ext4_ext_grow_indepth()
1322 	memmove(bh->b_data, EXT4_I(inode)->i_data, ext_size);  in ext4_ext_grow_indepth()
1324 	memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);  in ext4_ext_grow_indepth()
1331 		neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));  in ext4_ext_grow_indepth()
1333 		neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));  in ext4_ext_grow_indepth()
1334 	neh->eh_magic = EXT4_EXT_MAGIC;  in ext4_ext_grow_indepth()
1343 	/* Update top-level index: num,max,pointer */  in ext4_ext_grow_indepth()
1345 	neh->eh_entries = cpu_to_le16(1);  in ext4_ext_grow_indepth()
1347 	if (neh->eh_depth == 0) {  in ext4_ext_grow_indepth()
1349 		neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));  in ext4_ext_grow_indepth()
1350 		EXT_FIRST_INDEX(neh)->ei_block =  in ext4_ext_grow_indepth()
1351 			EXT_FIRST_EXTENT(neh)->ee_block;  in ext4_ext_grow_indepth()
1354 		  le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),  in ext4_ext_grow_indepth()
1355 		  le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block),  in ext4_ext_grow_indepth()
1358 	le16_add_cpu(&neh->eh_depth, 1);  in ext4_ext_grow_indepth()
1369  * if no free index is found, then it requests in-depth growing.
1379 	int depth, i, err = 0;  in ext4_ext_create_new_leaf()  local
1382 	i = depth = ext_depth(inode);  in ext4_ext_create_new_leaf()
1385 	curp = path + depth;  in ext4_ext_create_new_leaf()
1387 		i--;  in ext4_ext_create_new_leaf()
1388 		curp--;  in ext4_ext_create_new_leaf()
1402 				    (ext4_lblk_t)le32_to_cpu(newext->ee_block),  in ext4_ext_create_new_leaf()
1407 		/* tree is full, time to grow in depth */  in ext4_ext_create_new_leaf()
1414 				   (ext4_lblk_t)le32_to_cpu(newext->ee_block),  in ext4_ext_create_new_leaf()
1422 		 * only first (depth 0 -> 1) produces free space;  in ext4_ext_create_new_leaf()
1425 		depth = ext_depth(inode);  in ext4_ext_create_new_leaf()
1426 		if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {  in ext4_ext_create_new_leaf()
1449 	int depth, ee_len;  in ext4_ext_search_left()  local
1453 		return -EFSCORRUPTED;  in ext4_ext_search_left()
1455 	depth = path->p_depth;  in ext4_ext_search_left()
1458 	if (depth == 0 && path->p_ext == NULL)  in ext4_ext_search_left()
1465 	ex = path[depth].p_ext;  in ext4_ext_search_left()
1467 	if (*logical < le32_to_cpu(ex->ee_block)) {  in ext4_ext_search_left()
1468 		if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {  in ext4_ext_search_left()
1471 					 *logical, le32_to_cpu(ex->ee_block));  in ext4_ext_search_left()
1472 			return -EFSCORRUPTED;  in ext4_ext_search_left()
1474 		while (--depth >= 0) {  in ext4_ext_search_left()
1475 			ix = path[depth].p_idx;  in ext4_ext_search_left()
1476 			if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {  in ext4_ext_search_left()
1478 				  "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!",  in ext4_ext_search_left()
1479 				  ix != NULL ? le32_to_cpu(ix->ei_block) : 0,  in ext4_ext_search_left()
1480 				  EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?  in ext4_ext_search_left()
1481 		le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0,  in ext4_ext_search_left()
1482 				  depth);  in ext4_ext_search_left()
1483 				return -EFSCORRUPTED;  in ext4_ext_search_left()
1489 	if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {  in ext4_ext_search_left()
1492 				 *logical, le32_to_cpu(ex->ee_block), ee_len);  in ext4_ext_search_left()
1493 		return -EFSCORRUPTED;  in ext4_ext_search_left()
1496 	*logical = le32_to_cpu(ex->ee_block) + ee_len - 1;  in ext4_ext_search_left()
1497 	*phys = ext4_ext_pblock(ex) + ee_len - 1;  in ext4_ext_search_left()
1518 	int depth;	/* Note, NOT eh_depth; depth from top of tree */  in ext4_ext_search_right()  local
1523 		return -EFSCORRUPTED;  in ext4_ext_search_right()
1525 	depth = path->p_depth;  in ext4_ext_search_right()
1528 	if (depth == 0 && path->p_ext == NULL)  in ext4_ext_search_right()
1535 	ex = path[depth].p_ext;  in ext4_ext_search_right()
1537 	if (*logical < le32_to_cpu(ex->ee_block)) {  in ext4_ext_search_right()
1538 		if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {  in ext4_ext_search_right()
1541 					 depth);  in ext4_ext_search_right()
1542 			return -EFSCORRUPTED;  in ext4_ext_search_right()
1544 		while (--depth >= 0) {  in ext4_ext_search_right()
1545 			ix = path[depth].p_idx;  in ext4_ext_search_right()
1546 			if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {  in ext4_ext_search_right()
1550 				return -EFSCORRUPTED;  in ext4_ext_search_right()
1556 	if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {  in ext4_ext_search_right()
1559 				 *logical, le32_to_cpu(ex->ee_block), ee_len);  in ext4_ext_search_right()
1560 		return -EFSCORRUPTED;  in ext4_ext_search_right()
1563 	if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {  in ext4_ext_search_right()
1570 	while (--depth >= 0) {  in ext4_ext_search_right()
1571 		ix = path[depth].p_idx;  in ext4_ext_search_right()
1572 		if (ix != EXT_LAST_INDEX(path[depth].p_hdr))  in ext4_ext_search_right()
1585 	while (++depth < path->p_depth) {  in ext4_ext_search_right()
1588 					    path->p_depth - depth, 0);  in ext4_ext_search_right()
1597 	bh = read_extent_tree_block(inode, block, path->p_depth - depth, 0);  in ext4_ext_search_right()
1603 	*logical = le32_to_cpu(ex->ee_block);  in ext4_ext_search_right()
1621 	int depth;  in ext4_ext_next_allocated_block()  local
1624 	depth = path->p_depth;  in ext4_ext_next_allocated_block()
1626 	if (depth == 0 && path->p_ext == NULL)  in ext4_ext_next_allocated_block()
1629 	while (depth >= 0) {  in ext4_ext_next_allocated_block()
1630 		if (depth == path->p_depth) {  in ext4_ext_next_allocated_block()
1632 			if (path[depth].p_ext &&  in ext4_ext_next_allocated_block()
1633 				path[depth].p_ext !=  in ext4_ext_next_allocated_block()
1634 					EXT_LAST_EXTENT(path[depth].p_hdr))  in ext4_ext_next_allocated_block()
1635 			  return le32_to_cpu(path[depth].p_ext[1].ee_block);  in ext4_ext_next_allocated_block()
1638 			if (path[depth].p_idx !=  in ext4_ext_next_allocated_block()
1639 					EXT_LAST_INDEX(path[depth].p_hdr))  in ext4_ext_next_allocated_block()
1640 			  return le32_to_cpu(path[depth].p_idx[1].ei_block);  in ext4_ext_next_allocated_block()
1642 		depth--;  in ext4_ext_next_allocated_block()
1654 	int depth;  in ext4_ext_next_leaf_block()  local
1657 	depth = path->p_depth;  in ext4_ext_next_leaf_block()
1659 	/* zero-tree has no leaf blocks at all */  in ext4_ext_next_leaf_block()
1660 	if (depth == 0)  in ext4_ext_next_leaf_block()
1664 	depth--;  in ext4_ext_next_leaf_block()
1666 	while (depth >= 0) {  in ext4_ext_next_leaf_block()
1667 		if (path[depth].p_idx !=  in ext4_ext_next_leaf_block()
1668 				EXT_LAST_INDEX(path[depth].p_hdr))  in ext4_ext_next_leaf_block()
1670 				le32_to_cpu(path[depth].p_idx[1].ei_block);  in ext4_ext_next_leaf_block()
1671 		depth--;  in ext4_ext_next_leaf_block()
1687 	int depth = ext_depth(inode);  in ext4_ext_correct_indexes()  local
1692 	eh = path[depth].p_hdr;  in ext4_ext_correct_indexes()
1693 	ex = path[depth].p_ext;  in ext4_ext_correct_indexes()
1698 		return -EFSCORRUPTED;  in ext4_ext_correct_indexes()
1701 	if (depth == 0) {  in ext4_ext_correct_indexes()
1714 	k = depth - 1;  in ext4_ext_correct_indexes()
1715 	border = path[depth].p_ext->ee_block;  in ext4_ext_correct_indexes()
1719 	path[k].p_idx->ei_block = border;  in ext4_ext_correct_indexes()
1724 	while (k--) {  in ext4_ext_correct_indexes()
1725 		/* change all left-side indexes */  in ext4_ext_correct_indexes()
1731 		path[k].p_idx->ei_block = border;  in ext4_ext_correct_indexes()
1752 	if (le32_to_cpu(ex1->ee_block) + ext1_ee_len !=  in ext4_can_extents_be_merged()
1753 			le32_to_cpu(ex2->ee_block))  in ext4_can_extents_be_merged()
1771 	     atomic_read(&EXT4_I(inode)->i_unwritten) ||  in ext4_can_extents_be_merged()
1787  * left, pass "ex - 1" as argument instead of "ex".
1796 	unsigned int depth, len;  in ext4_ext_try_to_merge_right()  local
1799 	depth = ext_depth(inode);  in ext4_ext_try_to_merge_right()
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()
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()
1857 	s = le16_to_cpu(path[1].p_hdr->eh_entries) *  in ext4_ext_try_to_merge_up()
1865 		(path[1].p_ext - EXT_FIRST_EXTENT(path[1].p_hdr));  in ext4_ext_try_to_merge_up()
1866 	path[0].p_hdr->eh_max = cpu_to_le16(max_root);  in ext4_ext_try_to_merge_up()
1882 	unsigned int depth;  in ext4_ext_try_to_merge()  local
1885 	depth = ext_depth(inode);  in ext4_ext_try_to_merge()
1886 	BUG_ON(path[depth].p_hdr == NULL);  in ext4_ext_try_to_merge()
1887 	eh = path[depth].p_hdr;  in ext4_ext_try_to_merge()
1890 		merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1);  in ext4_ext_try_to_merge()
1912 	unsigned int depth, len1;  in ext4_ext_check_overlap()  local
1915 	b1 = le32_to_cpu(newext->ee_block);  in ext4_ext_check_overlap()
1917 	depth = ext_depth(inode);  in ext4_ext_check_overlap()
1918 	if (!path[depth].p_ext)  in ext4_ext_check_overlap()
1920 	b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block));  in ext4_ext_check_overlap()
1935 		len1 = EXT_MAX_BLOCKS - b1;  in ext4_ext_check_overlap()
1936 		newext->ee_len = cpu_to_le16(len1);  in ext4_ext_check_overlap()
1942 		newext->ee_len = cpu_to_le16(b2 - b1);  in ext4_ext_check_overlap()
1953  * creating new leaf in the no-space case.
1964 	int depth, len, err;  in ext4_ext_insert_extent()  local
1972 		return -EFSCORRUPTED;  in ext4_ext_insert_extent()
1974 	depth = ext_depth(inode);  in ext4_ext_insert_extent()
1975 	ex = path[depth].p_ext;  in ext4_ext_insert_extent()
1976 	eh = path[depth].p_hdr;  in ext4_ext_insert_extent()
1977 	if (unlikely(path[depth].p_hdr == NULL)) {  in ext4_ext_insert_extent()
1978 		EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);  in ext4_ext_insert_extent()
1979 		return -EFSCORRUPTED;  in ext4_ext_insert_extent()
1993 		    (le32_to_cpu(ex->ee_block) +  in ext4_ext_insert_extent()
1995 		    le32_to_cpu(newext->ee_block))) {  in ext4_ext_insert_extent()
1999 			   (le32_to_cpu(newext->ee_block) +  in ext4_ext_insert_extent()
2001 			   le32_to_cpu(ex->ee_block)))  in ext4_ext_insert_extent()
2002 			ex -= 1;  in ext4_ext_insert_extent()
2010 				  le32_to_cpu(ex->ee_block),  in ext4_ext_insert_extent()
2015 						  path + depth);  in ext4_ext_insert_extent()
2019 			ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)  in ext4_ext_insert_extent()
2023 			eh = path[depth].p_hdr;  in ext4_ext_insert_extent()
2033 				  le32_to_cpu(newext->ee_block),  in ext4_ext_insert_extent()
2036 				  le32_to_cpu(ex->ee_block),  in ext4_ext_insert_extent()
2041 						  path + depth);  in ext4_ext_insert_extent()
2046 			ex->ee_block = newext->ee_block;  in ext4_ext_insert_extent()
2048 			ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)  in ext4_ext_insert_extent()
2052 			eh = path[depth].p_hdr;  in ext4_ext_insert_extent()
2058 	depth = ext_depth(inode);  in ext4_ext_insert_extent()
2059 	eh = path[depth].p_hdr;  in ext4_ext_insert_extent()
2060 	if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max))  in ext4_ext_insert_extent()
2066 	if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block))  in ext4_ext_insert_extent()
2069 		ext_debug("next leaf block - %u\n", next);  in ext4_ext_insert_extent()
2074 		BUG_ON(npath->p_depth != path->p_depth);  in ext4_ext_insert_extent()
2075 		eh = npath[depth].p_hdr;  in ext4_ext_insert_extent()
2076 		if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) {  in ext4_ext_insert_extent()
2078 				  le16_to_cpu(eh->eh_entries));  in ext4_ext_insert_extent()
2083 			  le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));  in ext4_ext_insert_extent()
2096 	depth = ext_depth(inode);  in ext4_ext_insert_extent()
2097 	eh = path[depth].p_hdr;  in ext4_ext_insert_extent()
2100 	nearex = path[depth].p_ext;  in ext4_ext_insert_extent()
2102 	err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_ext_insert_extent()
2109 				le32_to_cpu(newext->ee_block),  in ext4_ext_insert_extent()
2115 		if (le32_to_cpu(newext->ee_block)  in ext4_ext_insert_extent()
2116 			   > le32_to_cpu(nearex->ee_block)) {  in ext4_ext_insert_extent()
2120 					le32_to_cpu(newext->ee_block),  in ext4_ext_insert_extent()
2128 			BUG_ON(newext->ee_block == nearex->ee_block);  in ext4_ext_insert_extent()
2131 					le32_to_cpu(newext->ee_block),  in ext4_ext_insert_extent()
2137 		len = EXT_LAST_EXTENT(eh) - nearex + 1;  in ext4_ext_insert_extent()
2141 					le32_to_cpu(newext->ee_block),  in ext4_ext_insert_extent()
2151 	le16_add_cpu(&eh->eh_entries, 1);  in ext4_ext_insert_extent()
2152 	path[depth].p_ext = nearex;  in ext4_ext_insert_extent()
2153 	nearex->ee_block = newext->ee_block;  in ext4_ext_insert_extent()
2155 	nearex->ee_len = newext->ee_len;  in ext4_ext_insert_extent()
2168 	err = ext4_ext_dirty(handle, inode, path + path->p_depth);  in ext4_ext_insert_extent()
2185 	int exists, depth = 0, err = 0;  in ext4_fill_fiemap_extents()  local
2187 	unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;  in ext4_fill_fiemap_extents()
2190 		num = last - block;  in ext4_fill_fiemap_extents()
2192 		down_read(&EXT4_I(inode)->i_data_sem);  in ext4_fill_fiemap_extents()
2196 			up_read(&EXT4_I(inode)->i_data_sem);  in ext4_fill_fiemap_extents()
2202 		depth = ext_depth(inode);  in ext4_fill_fiemap_extents()
2203 		if (unlikely(path[depth].p_hdr == NULL)) {  in ext4_fill_fiemap_extents()
2204 			up_read(&EXT4_I(inode)->i_data_sem);  in ext4_fill_fiemap_extents()
2205 			EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);  in ext4_fill_fiemap_extents()
2206 			err = -EFSCORRUPTED;  in ext4_fill_fiemap_extents()
2209 		ex = path[depth].p_ext;  in ext4_fill_fiemap_extents()
2219 		} else if (le32_to_cpu(ex->ee_block) > block) {  in ext4_fill_fiemap_extents()
2222 			end = le32_to_cpu(ex->ee_block);  in ext4_fill_fiemap_extents()
2225 		} else if (block >= le32_to_cpu(ex->ee_block)  in ext4_fill_fiemap_extents()
2232 		} else if (block >= le32_to_cpu(ex->ee_block)) {  in ext4_fill_fiemap_extents()
2238 			end = le32_to_cpu(ex->ee_block)  in ext4_fill_fiemap_extents()
2250 			es.es_len = end - start;  in ext4_fill_fiemap_extents()
2253 			es.es_lblk = le32_to_cpu(ex->ee_block);  in ext4_fill_fiemap_extents()
2271 		up_read(&EXT4_I(inode)->i_data_sem);  in ext4_fill_fiemap_extents()
2275 			err = -EFSCORRUPTED;  in ext4_fill_fiemap_extents()
2298 				err = -EFSCORRUPTED;  in ext4_fill_fiemap_extents()
2326  * ext4_ext_determine_hole - determine hole around given block
2342 	int depth = ext_depth(inode);  in ext4_ext_determine_hole()  local
2346 	ex = path[depth].p_ext;  in ext4_ext_determine_hole()
2348 		/* there is no extent yet, so gap is [0;-] */  in ext4_ext_determine_hole()
2351 	} else if (*lblk < le32_to_cpu(ex->ee_block)) {  in ext4_ext_determine_hole()
2352 		len = le32_to_cpu(ex->ee_block) - *lblk;  in ext4_ext_determine_hole()
2353 	} else if (*lblk >= le32_to_cpu(ex->ee_block)  in ext4_ext_determine_hole()
2357 		*lblk = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex);  in ext4_ext_determine_hole()
2360 		len = next - *lblk;  in ext4_ext_determine_hole()
2379 					  hole_start + hole_len - 1, &es);  in ext4_ext_put_gap_in_cache()
2384 		hole_len = min(es.es_lblk - hole_start, hole_len);  in ext4_ext_put_gap_in_cache()
2386 	ext_debug(" -> %u:%u\n", hole_start, hole_len);  in ext4_ext_put_gap_in_cache()
2396 			struct ext4_ext_path *path, int depth)  in ext4_ext_rm_idx()  argument
2402 	depth--;  in ext4_ext_rm_idx()
2403 	path = path + depth;  in ext4_ext_rm_idx()
2404 	leaf = ext4_idx_pblock(path->p_idx);  in ext4_ext_rm_idx()
2405 	if (unlikely(path->p_hdr->eh_entries == 0)) {  in ext4_ext_rm_idx()
2406 		EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");  in ext4_ext_rm_idx()
2407 		return -EFSCORRUPTED;  in ext4_ext_rm_idx()
2413 	if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) {  in ext4_ext_rm_idx()
2414 		int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx;  in ext4_ext_rm_idx()
2416 		memmove(path->p_idx, path->p_idx + 1, len);  in ext4_ext_rm_idx()
2419 	le16_add_cpu(&path->p_hdr->eh_entries, -1);  in ext4_ext_rm_idx()
2429 	while (--depth >= 0) {  in ext4_ext_rm_idx()
2430 		if (path->p_idx != EXT_FIRST_INDEX(path->p_hdr))  in ext4_ext_rm_idx()
2432 		path--;  in ext4_ext_rm_idx()
2436 		path->p_idx->ei_block = (path+1)->p_idx->ei_block;  in ext4_ext_rm_idx()
2455 		int depth = ext_depth(inode);  in ext4_ext_calc_credits_for_single_extent()  local
2459 		if (le16_to_cpu(path[depth].p_hdr->eh_entries)  in ext4_ext_calc_credits_for_single_extent()
2460 				< le16_to_cpu(path[depth].p_hdr->eh_max)) {  in ext4_ext_calc_credits_for_single_extent()
2471 			ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);  in ext4_ext_calc_credits_for_single_extent()
2491 	int depth;  in ext4_ext_index_trans_blocks()  local
2497 	depth = ext_depth(inode);  in ext4_ext_index_trans_blocks()
2500 		index = depth * 2;  in ext4_ext_index_trans_blocks()
2502 		index = depth * 3;  in ext4_ext_index_trans_blocks()
2509 	if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) ||  in get_default_free_blocks_flags()
2522 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_remove_blocks()
2542 	pblk = ext4_ext_pblock(ex) + ee_len - 1;  in ext4_remove_blocks()
2547 				 sbi->s_cluster_ratio, flags);  in ext4_remove_blocks()
2553 		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_remove_blocks()
2554 		spin_lock(&sbi->s_ext_stats_lock);  in ext4_remove_blocks()
2555 		sbi->s_ext_blocks += ee_len;  in ext4_remove_blocks()
2556 		sbi->s_ext_extents++;  in ext4_remove_blocks()
2557 		if (ee_len < sbi->s_ext_min)  in ext4_remove_blocks()
2558 			sbi->s_ext_min = ee_len;  in ext4_remove_blocks()
2559 		if (ee_len > sbi->s_ext_max)  in ext4_remove_blocks()
2560 			sbi->s_ext_max = ee_len;  in ext4_remove_blocks()
2561 		if (ext_depth(inode) > sbi->s_depth_max)  in ext4_remove_blocks()
2562 			sbi->s_depth_max = ext_depth(inode);  in ext4_remove_blocks()
2563 		spin_unlock(&sbi->s_ext_stats_lock);  in ext4_remove_blocks()
2566 	if (from >= le32_to_cpu(ex->ee_block)  in ext4_remove_blocks()
2567 	    && to == le32_to_cpu(ex->ee_block) + ee_len - 1) {  in ext4_remove_blocks()
2572 		num = le32_to_cpu(ex->ee_block) + ee_len - from;  in ext4_remove_blocks()
2573 		pblk = ext4_ext_pblock(ex) + ee_len - num;  in ext4_remove_blocks()
2580 		    *partial_cluster == -(long long) EXT4_B2C(sbi, pblk+num-1))  in ext4_remove_blocks()
2604 			if (first_cluster != -*partial_cluster)  in ext4_remove_blocks()
2610 		ext4_error(sbi->s_sb, "strange request: removal(2) "  in ext4_remove_blocks()
2611 			   "%u-%u from %u:%u",  in ext4_remove_blocks()
2612 			   from, to, le32_to_cpu(ex->ee_block), ee_len);  in ext4_remove_blocks()
2638 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_ext_rm_leaf()
2640 	int depth = ext_depth(inode), credits;  in ext4_ext_rm_leaf()  local
2652 	if (!path[depth].p_hdr)  in ext4_ext_rm_leaf()
2653 		path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);  in ext4_ext_rm_leaf()
2654 	eh = path[depth].p_hdr;  in ext4_ext_rm_leaf()
2655 	if (unlikely(path[depth].p_hdr == NULL)) {  in ext4_ext_rm_leaf()
2656 		EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);  in ext4_ext_rm_leaf()
2657 		return -EFSCORRUPTED;  in ext4_ext_rm_leaf()
2660 	ex = path[depth].p_ext;  in ext4_ext_rm_leaf()
2664 	ex_ee_block = le32_to_cpu(ex->ee_block);  in ext4_ext_rm_leaf()
2679 		path[depth].p_ext = ex;  in ext4_ext_rm_leaf()
2682 		b = ex_ee_block+ex_ee_len - 1 < end ?  in ext4_ext_rm_leaf()
2683 			ex_ee_block+ex_ee_len - 1 : end;  in ext4_ext_rm_leaf()
2696 			if (sbi->s_cluster_ratio > 1) {  in ext4_ext_rm_leaf()
2699 					-(long long) EXT4_B2C(sbi, pblk);  in ext4_ext_rm_leaf()
2701 			ex--;  in ext4_ext_rm_leaf()
2702 			ex_ee_block = le32_to_cpu(ex->ee_block);  in ext4_ext_rm_leaf()
2705 		} else if (b != ex_ee_block + ex_ee_len - 1) {  in ext4_ext_rm_leaf()
2710 					 ex_ee_block + ex_ee_len - 1);  in ext4_ext_rm_leaf()
2711 			err = -EFSCORRUPTED;  in ext4_ext_rm_leaf()
2715 			num = a - ex_ee_block;  in ext4_ext_rm_leaf()
2726 		credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));  in ext4_ext_rm_leaf()
2731 		credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);  in ext4_ext_rm_leaf()
2737 		err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_ext_rm_leaf()
2750 		ex->ee_len = cpu_to_le16(num);  in ext4_ext_rm_leaf()
2762 			if (end != EXT_MAX_BLOCKS - 1) {  in ext4_ext_rm_leaf()
2768 				memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) *  in ext4_ext_rm_leaf()
2775 			le16_add_cpu(&eh->eh_entries, -1);  in ext4_ext_rm_leaf()
2778 		err = ext4_ext_dirty(handle, inode, path + depth);  in ext4_ext_rm_leaf()
2784 		ex--;  in ext4_ext_rm_leaf()
2785 		ex_ee_block = le32_to_cpu(ex->ee_block);  in ext4_ext_rm_leaf()
2789 	if (correct_index && eh->eh_entries)  in ext4_ext_rm_leaf()
2800 		pblk = ext4_ext_pblock(ex) + ex_ee_len - 1;  in ext4_ext_rm_leaf()
2804 					 sbi->s_cluster_ratio,  in ext4_ext_rm_leaf()
2812 	if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)  in ext4_ext_rm_leaf()
2813 		err = ext4_ext_rm_idx(handle, inode, path, depth);  in ext4_ext_rm_leaf()
2826 	BUG_ON(path->p_idx == NULL);  in ext4_ext_more_to_rm()
2828 	if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr))  in ext4_ext_more_to_rm()
2835 	if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)  in ext4_ext_more_to_rm()
2843 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_ext_remove_space()
2844 	int depth = ext_depth(inode);  in ext4_ext_remove_space()  local
2853 	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, depth + 1);  in ext4_ext_remove_space()
2858 	trace_ext4_ext_remove_space(inode, start, end, depth);  in ext4_ext_remove_space()
2867 	if (end < EXT_MAX_BLOCKS - 1) {  in ext4_ext_remove_space()
2878 		depth = ext_depth(inode);  in ext4_ext_remove_space()
2880 		ex = path[depth].p_ext;  in ext4_ext_remove_space()
2882 			if (depth) {  in ext4_ext_remove_space()
2885 						 depth);  in ext4_ext_remove_space()
2886 				err = -EFSCORRUPTED;  in ext4_ext_remove_space()
2891 		ee_block = le32_to_cpu(ex->ee_block);  in ext4_ext_remove_space()
2892 		ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1;  in ext4_ext_remove_space()
2907 			if (sbi->s_cluster_ratio > 1) {  in ext4_ext_remove_space()
2908 				pblk = ext4_ext_pblock(ex) + end - ee_block + 1;  in ext4_ext_remove_space()
2910 					-(long long) EXT4_B2C(sbi, pblk);  in ext4_ext_remove_space()
2924 		} else if (sbi->s_cluster_ratio > 1 && end >= ex_end) {  in ext4_ext_remove_space()
2940 					-(long long) EXT4_B2C(sbi, pblk);  in ext4_ext_remove_space()
2945 	 * after i_size and walking into the tree depth-wise.  in ext4_ext_remove_space()
2947 	depth = ext_depth(inode);  in ext4_ext_remove_space()
2949 		int k = i = depth;  in ext4_ext_remove_space()
2950 		while (--k > 0)  in ext4_ext_remove_space()
2952 				le16_to_cpu(path[k].p_hdr->eh_entries)+1;  in ext4_ext_remove_space()
2954 		path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),  in ext4_ext_remove_space()
2958 			return -ENOMEM;  in ext4_ext_remove_space()
2960 		path[0].p_maxdepth = path[0].p_depth = depth;  in ext4_ext_remove_space()
2964 		if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {  in ext4_ext_remove_space()
2965 			err = -EFSCORRUPTED;  in ext4_ext_remove_space()
2972 		if (i == depth) {  in ext4_ext_remove_space()
2980 			i--;  in ext4_ext_remove_space()
2993 			path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;  in ext4_ext_remove_space()
2996 				  le16_to_cpu(path[i].p_hdr->eh_entries));  in ext4_ext_remove_space()
2999 			path[i].p_idx--;  in ext4_ext_remove_space()
3002 		ext_debug("level %d - index, first 0x%p, cur 0x%p\n",  in ext4_ext_remove_space()
3012 				ext4_idx_pblock(path[i].p_idx), depth - i - 1,  in ext4_ext_remove_space()
3020 			 * Should be a no-op if we did IO above. */  in ext4_ext_remove_space()
3022 			if (WARN_ON(i + 1 > depth)) {  in ext4_ext_remove_space()
3023 				err = -EFSCORRUPTED;  in ext4_ext_remove_space()
3030 			path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);  in ext4_ext_remove_space()
3034 			if (path[i].p_hdr->eh_entries == 0 && i > 0) {  in ext4_ext_remove_space()
3043 			i--;  in ext4_ext_remove_space()
3048 	trace_ext4_ext_remove_space_done(inode, start, end, depth,  in ext4_ext_remove_space()
3049 			partial_cluster, path->p_hdr->eh_entries);  in ext4_ext_remove_space()
3061 				 sbi->s_cluster_ratio,  in ext4_ext_remove_space()
3066 	if (path->p_hdr->eh_entries == 0) {  in ext4_ext_remove_space()
3073 			ext_inode_hdr(inode)->eh_depth = 0;  in ext4_ext_remove_space()
3074 			ext_inode_hdr(inode)->eh_max =  in ext4_ext_remove_space()
3083 	if (err == -EAGAIN)  in ext4_ext_remove_space()
3101 		printk(KERN_INFO "EXT4-fs: file extents enabled"  in ext4_ext_init()
3114 		spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock);  in ext4_ext_init()
3115 		EXT4_SB(sb)->s_ext_min = 1 << 30;  in ext4_ext_init()
3116 		EXT4_SB(sb)->s_ext_max = 0;  in ext4_ext_init()
3130 	if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) {  in ext4_ext_release()
3132 		printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n",  in ext4_ext_release()
3133 			sbi->s_ext_blocks, sbi->s_ext_extents,  in ext4_ext_release()
3134 			sbi->s_ext_blocks / sbi->s_ext_extents);  in ext4_ext_release()
3135 		printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n",  in ext4_ext_release()
3136 			sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max);  in ext4_ext_release()
3147 	ee_block  = le32_to_cpu(ex->ee_block);  in ext4_zeroout_es()
3158 /* FIXME!! we need to try to merge to left or right after zero-out  */
3166 	return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,  in ext4_ext_zeroout()
3203 	unsigned int ee_len, depth;  in ext4_split_extent_at()  local
3210 		"block %llu\n", inode->i_ino, (unsigned long long)split);  in ext4_split_extent_at()
3214 	depth = ext_depth(inode);  in ext4_split_extent_at()
3215 	ex = path[depth].p_ext;  in ext4_split_extent_at()
3216 	ee_block = le32_to_cpu(ex->ee_block);  in ext4_split_extent_at()
3218 	newblock = split - ee_block + ext4_ext_pblock(ex);  in ext4_split_extent_at()
3226 	err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_split_extent_at()
3244 		err = ext4_ext_dirty(handle, inode, path + path->p_depth);  in ext4_split_extent_at()
3250 	ex->ee_len = cpu_to_le16(split - ee_block);  in ext4_split_extent_at()
3258 	err = ext4_ext_dirty(handle, inode, path + depth);  in ext4_split_extent_at()
3263 	ex2->ee_block = cpu_to_le32(split);  in ext4_split_extent_at()
3264 	ex2->ee_len   = cpu_to_le16(ee_len - (split - ee_block));  in ext4_split_extent_at()
3270 	if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) {  in ext4_split_extent_at()
3274 				zero_ex.ee_block = ex2->ee_block;  in ext4_split_extent_at()
3281 				zero_ex.ee_block = ex->ee_block;  in ext4_split_extent_at()
3299 		ex->ee_len = cpu_to_le16(ee_len);  in ext4_split_extent_at()
3301 		err = ext4_ext_dirty(handle, inode, path + path->p_depth);  in ext4_split_extent_at()
3317 	ex->ee_len = orig_ex.ee_len;  in ext4_split_extent_at()
3318 	ext4_ext_dirty(handle, inode, path + path->p_depth);  in ext4_split_extent_at()
3343 	unsigned int ee_len, depth;  in ext4_split_extent()  local
3347 	int allocated = map->m_len;  in ext4_split_extent()
3349 	depth = ext_depth(inode);  in ext4_split_extent()
3350 	ex = path[depth].p_ext;  in ext4_split_extent()
3351 	ee_block = le32_to_cpu(ex->ee_block);  in ext4_split_extent()
3355 	if (map->m_lblk + map->m_len < ee_block + ee_len) {  in ext4_split_extent()
3364 				map->m_lblk + map->m_len, split_flag1, flags1);  in ext4_split_extent()
3368 		allocated = ee_len - (map->m_lblk - ee_block);  in ext4_split_extent()
3374 	path = ext4_find_extent(inode, map->m_lblk, ppath, 0);  in ext4_split_extent()
3377 	depth = ext_depth(inode);  in ext4_split_extent()
3378 	ex = path[depth].p_ext;  in ext4_split_extent()
3381 				 (unsigned long) map->m_lblk);  in ext4_split_extent()
3382 		return -EFSCORRUPTED;  in ext4_split_extent()
3387 	if (map->m_lblk >= ee_block) {  in ext4_split_extent()
3395 				map->m_lblk, split_flag1, flags);  in ext4_split_extent()
3408  * extent into multiple extents (up to three - one initialized and two
3415  * Pre-conditions:
3416  *  - The extent pointed to by 'path' is unwritten.
3417  *  - The extent pointed to by 'path' contains a superset
3418  *    of the logical span [map->m_lblk, map->m_lblk + map->m_len).
3420  * Post-conditions on success:
3421  *  - the returned value is the number of blocks beyond map->l_lblk
3423  *    It is guaranteed to be >= map->m_len.
3438 	unsigned int ee_len, depth, map_len = map->m_len;  in ext4_ext_convert_to_initialized()  local
3444 		"block %llu, max_blocks %u\n", inode->i_ino,  in ext4_ext_convert_to_initialized()
3445 		(unsigned long long)map->m_lblk, map_len);  in ext4_ext_convert_to_initialized()
3447 	sbi = EXT4_SB(inode->i_sb);  in ext4_ext_convert_to_initialized()
3448 	eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)  in ext4_ext_convert_to_initialized()
3449 			>> inode->i_sb->s_blocksize_bits;  in ext4_ext_convert_to_initialized()
3450 	if (eof_block < map->m_lblk + map_len)  in ext4_ext_convert_to_initialized()
3451 		eof_block = map->m_lblk + map_len;  in ext4_ext_convert_to_initialized()
3453 	depth = ext_depth(inode);  in ext4_ext_convert_to_initialized()
3454 	eh = path[depth].p_hdr;  in ext4_ext_convert_to_initialized()
3455 	ex = path[depth].p_ext;  in ext4_ext_convert_to_initialized()
3456 	ee_block = le32_to_cpu(ex->ee_block);  in ext4_ext_convert_to_initialized()
3463 	/* Pre-conditions */  in ext4_ext_convert_to_initialized()
3465 	BUG_ON(!in_range(map->m_lblk, ee_block, ee_len));  in ext4_ext_convert_to_initialized()
3476 	 *  - L1: we do not deal with writes covering the whole extent.  in ext4_ext_convert_to_initialized()
3479 	 *  - L2: we only attempt to merge with an extent stored in the  in ext4_ext_convert_to_initialized()
3482 	if ((map->m_lblk == ee_block) &&  in ext4_ext_convert_to_initialized()
3490 		abut_ex = ex - 1;  in ext4_ext_convert_to_initialized()
3491 		prev_lblk = le32_to_cpu(abut_ex->ee_block);  in ext4_ext_convert_to_initialized()
3499 		 * - C1: abut_ex is initialized,  in ext4_ext_convert_to_initialized()
3500 		 * - C2: abut_ex is logically abutting ex,  in ext4_ext_convert_to_initialized()
3501 		 * - C3: abut_ex is physically abutting ex,  in ext4_ext_convert_to_initialized()
3502 		 * - C4: abut_ex can receive the additional blocks without  in ext4_ext_convert_to_initialized()
3508 			(prev_len < (EXT_INIT_MAX_LEN - map_len))) {	/*C4*/  in ext4_ext_convert_to_initialized()
3509 			err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_ext_convert_to_initialized()
3517 			ex->ee_block = cpu_to_le32(ee_block + map_len);  in ext4_ext_convert_to_initialized()
3519 			ex->ee_len = cpu_to_le16(ee_len - map_len);  in ext4_ext_convert_to_initialized()
3523 			abut_ex->ee_len = cpu_to_le16(prev_len + map_len);  in ext4_ext_convert_to_initialized()
3528 	} else if (((map->m_lblk + map_len) == (ee_block + ee_len)) &&  in ext4_ext_convert_to_initialized()
3537 		next_lblk = le32_to_cpu(abut_ex->ee_block);  in ext4_ext_convert_to_initialized()
3545 		 * - C1: abut_ex is initialized,  in ext4_ext_convert_to_initialized()
3546 		 * - C2: abut_ex is logically abutting ex,  in ext4_ext_convert_to_initialized()
3547 		 * - C3: abut_ex is physically abutting ex,  in ext4_ext_convert_to_initialized()
3548 		 * - C4: abut_ex can receive the additional blocks without  in ext4_ext_convert_to_initialized()
3552 		    ((map->m_lblk + map_len) == next_lblk) &&		/*C2*/  in ext4_ext_convert_to_initialized()
3554 		    (next_len < (EXT_INIT_MAX_LEN - map_len))) {	/*C4*/  in ext4_ext_convert_to_initialized()
3555 			err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_ext_convert_to_initialized()
3563 			abut_ex->ee_block = cpu_to_le32(next_lblk - map_len);  in ext4_ext_convert_to_initialized()
3564 			ext4_ext_store_pblock(abut_ex, next_pblk - map_len);  in ext4_ext_convert_to_initialized()
3565 			ex->ee_len = cpu_to_le16(ee_len - map_len);  in ext4_ext_convert_to_initialized()
3569 			abut_ex->ee_len = cpu_to_le16(next_len + map_len);  in ext4_ext_convert_to_initialized()
3577 		ext4_ext_dirty(handle, inode, path + depth);  in ext4_ext_convert_to_initialized()
3580 		path[depth].p_ext = abut_ex;  in ext4_ext_convert_to_initialized()
3583 		allocated = ee_len - (map->m_lblk - ee_block);  in ext4_ext_convert_to_initialized()
3585 	WARN_ON(map->m_lblk < ee_block);  in ext4_ext_convert_to_initialized()
3593 		max_zeroout = sbi->s_extent_max_zeroout_kb >>  in ext4_ext_convert_to_initialized()
3594 			(inode->i_sb->s_blocksize_bits - 10);  in ext4_ext_convert_to_initialized()
3610 	split_map.m_lblk = map->m_lblk;  in ext4_ext_convert_to_initialized()
3611 	split_map.m_len = map->m_len;  in ext4_ext_convert_to_initialized()
3620 				cpu_to_le16(allocated - split_map.m_len);  in ext4_ext_convert_to_initialized()
3623 				split_map.m_len - ee_block);  in ext4_ext_convert_to_initialized()
3629 		if (split_map.m_lblk - ee_block + split_map.m_len <  in ext4_ext_convert_to_initialized()
3633 				zero_ex2.ee_block = ex->ee_block;  in ext4_ext_convert_to_initialized()
3634 				zero_ex2.ee_len = cpu_to_le16(split_map.m_lblk -  in ext4_ext_convert_to_initialized()
3643 			split_map.m_len += split_map.m_lblk - ee_block;  in ext4_ext_convert_to_initialized()
3645 			allocated = map->m_len;  in ext4_ext_convert_to_initialized()
3675  * This works the same way in the case of initialized -> unwritten conversion.
3698 	int split_flag = 0, depth;  in ext4_split_convert_extents()  local
3701 		  __func__, inode->i_ino,  in ext4_split_convert_extents()
3702 		  (unsigned long long)map->m_lblk, map->m_len);  in ext4_split_convert_extents()
3704 	eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)  in ext4_split_convert_extents()
3705 			>> inode->i_sb->s_blocksize_bits;  in ext4_split_convert_extents()
3706 	if (eof_block < map->m_lblk + map->m_len)  in ext4_split_convert_extents()
3707 		eof_block = map->m_lblk + map->m_len;  in ext4_split_convert_extents()
3712 	depth = ext_depth(inode);  in ext4_split_convert_extents()
3713 	ex = path[depth].p_ext;  in ext4_split_convert_extents()
3714 	ee_block = le32_to_cpu(ex->ee_block);  in ext4_split_convert_extents()
3739 	int depth;  in ext4_convert_unwritten_extents_endio()  local
3742 	depth = ext_depth(inode);  in ext4_convert_unwritten_extents_endio()
3743 	ex = path[depth].p_ext;  in ext4_convert_unwritten_extents_endio()
3744 	ee_block = le32_to_cpu(ex->ee_block);  in ext4_convert_unwritten_extents_endio()
3748 		"block %llu, max_blocks %u\n", inode->i_ino,  in ext4_convert_unwritten_extents_endio()
3757 	if (ee_block != map->m_lblk || ee_len > map->m_len) {  in ext4_convert_unwritten_extents_endio()
3759 		ext4_warning(inode->i_sb, "Inode (%ld) finished: extent logical block %llu,"  in ext4_convert_unwritten_extents_endio()
3761 			     inode->i_ino, (unsigned long long)ee_block, ee_len,  in ext4_convert_unwritten_extents_endio()
3762 			     (unsigned long long)map->m_lblk, map->m_len);  in ext4_convert_unwritten_extents_endio()
3768 		path = ext4_find_extent(inode, map->m_lblk, ppath, 0);  in ext4_convert_unwritten_extents_endio()
3771 		depth = ext_depth(inode);  in ext4_convert_unwritten_extents_endio()
3772 		ex = path[depth].p_ext;  in ext4_convert_unwritten_extents_endio()
3775 	err = ext4_ext_get_access(handle, inode, path + depth);  in ext4_convert_unwritten_extents_endio()
3787 	err = ext4_ext_dirty(handle, inode, path + path->p_depth);  in ext4_convert_unwritten_extents_endio()
3801 	int i, depth;  in check_eofblocks_fl()  local
3808 	depth = ext_depth(inode);  in check_eofblocks_fl()
3809 	eh = path[depth].p_hdr;  in check_eofblocks_fl()
3816 	if (unlikely(!eh->eh_entries))  in check_eofblocks_fl()
3828 	if (lblk + len < le32_to_cpu(last_ex->ee_block) +  in check_eofblocks_fl()
3838 	for (i = depth-1; i >= 0; i--)  in check_eofblocks_fl()
3871 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_find_delalloc_cluster()
3874 	lblk_end = lblk_start + sbi->s_cluster_ratio - 1;  in ext4_find_delalloc_cluster()
3887  *  '-' indicates non-delayed allocated blocks)
3891  *	|----c---=|====c====|====c====|===-c----|
3899  *	|----====c========|========c========|
3911  * In the non-bigalloc case, this function will just end up returning num_blks
3918 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in get_reserved_cluster_alloc()
3924 	alloc_cluster_end = EXT4_B2C(sbi, lblk_start + num_blks - 1);  in get_reserved_cluster_alloc()
3927 	allocated_clusters = alloc_cluster_end - alloc_cluster_start + 1;  in get_reserved_cluster_alloc()
3935 		lblk_to = lblk_from + c_offset - 1;  in get_reserved_cluster_alloc()
3938 			allocated_clusters--;  in get_reserved_cluster_alloc()
3945 		lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1;  in get_reserved_cluster_alloc()
3948 			allocated_clusters--;  in get_reserved_cluster_alloc()
3964 	int depth;  in convert_initialized_extent()  local
3971 	if (map->m_len > EXT_UNWRITTEN_MAX_LEN)  in convert_initialized_extent()
3972 		map->m_len = EXT_UNWRITTEN_MAX_LEN / 2;  in convert_initialized_extent()
3974 	depth = ext_depth(inode);  in convert_initialized_extent()
3975 	ex = path[depth].p_ext;  in convert_initialized_extent()
3976 	ee_block = le32_to_cpu(ex->ee_block);  in convert_initialized_extent()
3980 		"block %llu, max_blocks %u\n", __func__, inode->i_ino,  in convert_initialized_extent()
3983 	if (ee_block != map->m_lblk || ee_len > map->m_len) {  in convert_initialized_extent()
3988 		path = ext4_find_extent(inode, map->m_lblk, ppath, 0);  in convert_initialized_extent()
3991 		depth = ext_depth(inode);  in convert_initialized_extent()
3992 		ex = path[depth].p_ext;  in convert_initialized_extent()
3995 					 (unsigned long) map->m_lblk);  in convert_initialized_extent()
3996 			return -EFSCORRUPTED;  in convert_initialized_extent()
4000 	err = ext4_ext_get_access(handle, inode, path + depth);  in convert_initialized_extent()
4012 	err = ext4_ext_dirty(handle, inode, path + path->p_depth);  in convert_initialized_extent()
4018 	err = check_eofblocks_fl(handle, inode, map->m_lblk, path, map->m_len);  in convert_initialized_extent()
4021 	map->m_flags |= EXT4_MAP_UNWRITTEN;  in convert_initialized_extent()
4022 	if (allocated > map->m_len)  in convert_initialized_extent()
4023 		allocated = map->m_len;  in convert_initialized_extent()
4024 	map->m_len = allocated;  in convert_initialized_extent()
4040 		  inode->i_ino, (unsigned long long)map->m_lblk, map->m_len,  in ext4_ext_handle_unwritten_extents()
4059 		map->m_flags |= EXT4_MAP_UNWRITTEN;  in ext4_ext_handle_unwritten_extents()
4065 			if (allocated > map->m_len)  in ext4_ext_handle_unwritten_extents()
4066 				allocated = map->m_len;  in ext4_ext_handle_unwritten_extents()
4067 			err = ext4_issue_zeroout(inode, map->m_lblk, newblock,  in ext4_ext_handle_unwritten_extents()
4076 			err = check_eofblocks_fl(handle, inode, map->m_lblk,  in ext4_ext_handle_unwritten_extents()
4077 						 path, map->m_len);  in ext4_ext_handle_unwritten_extents()
4080 		map->m_flags |= EXT4_MAP_MAPPED;  in ext4_ext_handle_unwritten_extents()
4081 		map->m_pblk = newblock;  in ext4_ext_handle_unwritten_extents()
4082 		if (allocated > map->m_len)  in ext4_ext_handle_unwritten_extents()
4083 			allocated = map->m_len;  in ext4_ext_handle_unwritten_extents()
4084 		map->m_len = allocated;  in ext4_ext_handle_unwritten_extents()
4093 		map->m_flags |= EXT4_MAP_UNWRITTEN;  in ext4_ext_handle_unwritten_extents()
4106 		map->m_flags |= EXT4_MAP_UNWRITTEN;  in ext4_ext_handle_unwritten_extents()
4120 	map->m_flags |= EXT4_MAP_NEW;  in ext4_ext_handle_unwritten_extents()
4128 	if (allocated > map->m_len) {  in ext4_ext_handle_unwritten_extents()
4129 		clean_bdev_aliases(inode->i_sb->s_bdev, newblock + map->m_len,  in ext4_ext_handle_unwritten_extents()
4130 				   allocated - map->m_len);  in ext4_ext_handle_unwritten_extents()
4131 		allocated = map->m_len;  in ext4_ext_handle_unwritten_extents()
4133 	map->m_len = allocated;  in ext4_ext_handle_unwritten_extents()
4145 				map->m_lblk, map->m_len);  in ext4_ext_handle_unwritten_extents()
4153 	map->m_flags |= EXT4_MAP_MAPPED;  in ext4_ext_handle_unwritten_extents()
4155 		err = check_eofblocks_fl(handle, inode, map->m_lblk, path,  in ext4_ext_handle_unwritten_extents()
4156 					 map->m_len);  in ext4_ext_handle_unwritten_extents()
4161 	if (allocated > map->m_len)  in ext4_ext_handle_unwritten_extents()
4162 		allocated = map->m_len;  in ext4_ext_handle_unwritten_extents()
4164 	map->m_pblk = newblock;  in ext4_ext_handle_unwritten_extents()
4165 	map->m_len = allocated;  in ext4_ext_handle_unwritten_extents()
4171  * get_implied_cluster_alloc - check to see if the requested
4175  *	@map	The requested lblk->pblk mapping
4185  *		 |--- cluster # N--|
4186  *    |--- extent ---|	|---- requested region ---|
4191  *   |--------- cluster # N ----------------|
4192  *	   |--- requested region --|   |------- extent ----|
4197  *          |------------- cluster # N-------------|
4198  * |----- ex -----|                  |---- ex_right ----|
4199  *                  |------ requested region ------|
4202  * In each of the above cases, we need to set the map->m_pblk and
4203  * map->m_len so it corresponds to the return the extent labelled as
4205  * cluster EXT4_B2C(sbi, map->m_lblk).	We will then return 1 to
4206  * signal to ext4_ext_map_blocks() that map->m_pblk should be treated
4217 	ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);  in get_implied_cluster_alloc()
4220 	ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);  in get_implied_cluster_alloc()
4226 	ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1);  in get_implied_cluster_alloc()
4229 	rr_cluster_start = EXT4_B2C(sbi, map->m_lblk);  in get_implied_cluster_alloc()
4234 			ee_start += ee_len - 1;  in get_implied_cluster_alloc()
4235 		map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset;  in get_implied_cluster_alloc()
4236 		map->m_len = min(map->m_len,  in get_implied_cluster_alloc()
4237 				 (unsigned) sbi->s_cluster_ratio - c_offset);  in get_implied_cluster_alloc()
4241 		 *   |--------- cluster # N-------------|  in get_implied_cluster_alloc()
4242 		 *		       |------- extent ----|  in get_implied_cluster_alloc()
4243 		 *	   |--- requested region ---|  in get_implied_cluster_alloc()
4247 		if (map->m_lblk < ee_block)  in get_implied_cluster_alloc()
4248 			map->m_len = min(map->m_len, ee_block - map->m_lblk);  in get_implied_cluster_alloc()
4254 		 *          |------------- cluster # N-------------|  in get_implied_cluster_alloc()
4255 		 * |----- ex -----|                  |---- ex_right ----|  in get_implied_cluster_alloc()
4256 		 *                  |------ requested region ------|  in get_implied_cluster_alloc()
4259 		if (map->m_lblk > ee_block) {  in get_implied_cluster_alloc()
4261 			map->m_len = min(map->m_len, next - map->m_lblk);  in get_implied_cluster_alloc()
4278  * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
4279  * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
4282  *          if create == 0 and these are pre-allocated blocks
4296 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);  in ext4_ext_map_blocks()
4298 	int free_on_err = 0, err = 0, depth, ret;  in ext4_ext_map_blocks()  local
4306 		  map->m_lblk, map->m_len, inode->i_ino);  in ext4_ext_map_blocks()
4307 	trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);  in ext4_ext_map_blocks()
4310 	path = ext4_find_extent(inode, map->m_lblk, NULL, 0);  in ext4_ext_map_blocks()
4317 	depth = ext_depth(inode);  in ext4_ext_map_blocks()
4324 	if (unlikely(path[depth].p_ext == NULL && depth != 0)) {  in ext4_ext_map_blocks()
4326 				 "lblock: %lu, depth: %d pblock %lld",  in ext4_ext_map_blocks()
4327 				 (unsigned long) map->m_lblk, depth,  in ext4_ext_map_blocks()
4328 				 path[depth].p_block);  in ext4_ext_map_blocks()
4329 		err = -EFSCORRUPTED;  in ext4_ext_map_blocks()
4333 	ex = path[depth].p_ext;  in ext4_ext_map_blocks()
4335 		ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);  in ext4_ext_map_blocks()
4349 		if (in_range(map->m_lblk, ee_block, ee_len)) {  in ext4_ext_map_blocks()
4350 			newblock = map->m_lblk - ee_block + ee_start;  in ext4_ext_map_blocks()
4352 			allocated = ee_len - (map->m_lblk - ee_block);  in ext4_ext_map_blocks()
4353 			ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk,  in ext4_ext_map_blocks()
4387 		hole_start = map->m_lblk;  in ext4_ext_map_blocks()
4395 		/* Update hole_len to reflect hole size after map->m_lblk */  in ext4_ext_map_blocks()
4396 		if (hole_start != map->m_lblk)  in ext4_ext_map_blocks()
4397 			hole_len -= map->m_lblk - hole_start;  in ext4_ext_map_blocks()
4398 		map->m_pblk = 0;  in ext4_ext_map_blocks()
4399 		map->m_len = min_t(unsigned int, map->m_len, hole_len);  in ext4_ext_map_blocks()
4407 	newex.ee_block = cpu_to_le32(map->m_lblk);  in ext4_ext_map_blocks()
4408 	cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);  in ext4_ext_map_blocks()
4415 	    get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {  in ext4_ext_map_blocks()
4416 		ar.len = allocated = map->m_len;  in ext4_ext_map_blocks()
4417 		newblock = map->m_pblk;  in ext4_ext_map_blocks()
4423 	ar.lleft = map->m_lblk;  in ext4_ext_map_blocks()
4427 	ar.lright = map->m_lblk;  in ext4_ext_map_blocks()
4435 	if ((sbi->s_cluster_ratio > 1) && ex2 &&  in ext4_ext_map_blocks()
4436 	    get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) {  in ext4_ext_map_blocks()
4437 		ar.len = allocated = map->m_len;  in ext4_ext_map_blocks()
4438 		newblock = map->m_pblk;  in ext4_ext_map_blocks()
4449 	if (map->m_len > EXT_INIT_MAX_LEN &&  in ext4_ext_map_blocks()
4451 		map->m_len = EXT_INIT_MAX_LEN;  in ext4_ext_map_blocks()
4452 	else if (map->m_len > EXT_UNWRITTEN_MAX_LEN &&  in ext4_ext_map_blocks()
4454 		map->m_len = EXT_UNWRITTEN_MAX_LEN;  in ext4_ext_map_blocks()
4457 	newex.ee_len = cpu_to_le16(map->m_len);  in ext4_ext_map_blocks()
4462 		allocated = map->m_len;  in ext4_ext_map_blocks()
4466 	ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);  in ext4_ext_map_blocks()
4467 	ar.logical = map->m_lblk;  in ext4_ext_map_blocks()
4476 	offset = EXT4_LBLK_COFF(sbi, map->m_lblk);  in ext4_ext_map_blocks()
4478 	ar.goal -= offset;  in ext4_ext_map_blocks()
4479 	ar.logical -= offset;  in ext4_ext_map_blocks()
4480 	if (S_ISREG(inode->i_mode))  in ext4_ext_map_blocks()
4483 		/* disable in-core preallocation for non-regular files */  in ext4_ext_map_blocks()
4498 	ar.len = EXT4_C2B(sbi, ar.len) - offset;  in ext4_ext_map_blocks()
4509 		map->m_flags |= EXT4_MAP_UNWRITTEN;  in ext4_ext_map_blocks()
4514 		err = check_eofblocks_fl(handle, inode, map->m_lblk,  in ext4_ext_map_blocks()
4535 	if (allocated > map->m_len)  in ext4_ext_map_blocks()
4536 		allocated = map->m_len;  in ext4_ext_map_blocks()
4537 	map->m_flags |= EXT4_MAP_NEW;  in ext4_ext_map_blocks()
4549 						map->m_lblk, allocated);  in ext4_ext_map_blocks()
4554 				int reservation = allocated_clusters -  in ext4_ext_map_blocks()
4564 				 *   are [0-3],[4-7],[8-11]...  in ext4_ext_map_blocks()
4568 				 *   range [8-11], we would reserve 1 cluster  in ext4_ext_map_blocks()
4572 				 *   (for [0-3] and [4-7]; and not for [8-11] as  in ext4_ext_map_blocks()
4576 				 *   time, we will first write blocks [3-8] and  in ext4_ext_map_blocks()
4581 				 *   blocks [10-11], we would expect to claim  in ext4_ext_map_blocks()
4585 				 *   [8-11]. But our reserved cluster count had  in ext4_ext_map_blocks()
4598 				spin_lock(&ei->i_block_reservation_lock);  in ext4_ext_map_blocks()
4599 				ei->i_reserved_data_blocks += reservation;  in ext4_ext_map_blocks()
4600 				spin_unlock(&ei->i_block_reservation_lock);  in ext4_ext_map_blocks()
4623 	if (allocated > map->m_len)  in ext4_ext_map_blocks()
4624 		allocated = map->m_len;  in ext4_ext_map_blocks()
4626 	map->m_flags |= EXT4_MAP_MAPPED;  in ext4_ext_map_blocks()
4627 	map->m_pblk = newblock;  in ext4_ext_map_blocks()
4628 	map->m_len = allocated;  in ext4_ext_map_blocks()
4640 	struct super_block *sb = inode->i_sb;  in ext4_ext_truncate()
4651 	EXT4_I(inode)->i_disksize = inode->i_size;  in ext4_ext_truncate()
4656 	last_block = (inode->i_size + sb->s_blocksize - 1)  in ext4_ext_truncate()
4660 				    EXT_MAX_BLOCKS - last_block);  in ext4_ext_truncate()
4661 	if (err == -ENOMEM) {  in ext4_ext_truncate()
4668 	return ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1);  in ext4_ext_truncate()
4680 	int depth = 0;  in ext4_alloc_file_blocks()  local
4700 	depth = ext_depth(inode);  in ext4_alloc_file_blocks()
4705 		 * Recalculate credits when extent tree depth changes.  in ext4_alloc_file_blocks()
4707 		if (depth != ext_depth(inode)) {  in ext4_alloc_file_blocks()
4709 			depth = ext_depth(inode);  in ext4_alloc_file_blocks()
4722 				   inode->i_ino, map.m_lblk,  in ext4_alloc_file_blocks()
4729 		map.m_len = len = len - ret;  in ext4_alloc_file_blocks()
4730 		epos = (loff_t)map.m_lblk << inode->i_blkbits;  in ext4_alloc_file_blocks()
4731 		inode->i_ctime = current_time(inode);  in ext4_alloc_file_blocks()
4736 				inode->i_mtime = inode->i_ctime;  in ext4_alloc_file_blocks()
4738 			if (epos > inode->i_size)  in ext4_alloc_file_blocks()
4748 	if (ret == -ENOSPC &&  in ext4_alloc_file_blocks()
4749 			ext4_should_retry_alloc(inode->i_sb, &retries)) {  in ext4_alloc_file_blocks()
4770 	unsigned int blkbits = inode->i_blkbits;  in ext4_zero_range()
4774 	if (!S_ISREG(inode->i_mode))  in ext4_zero_range()
4775 		return -EINVAL;  in ext4_zero_range()
4779 		ret = ext4_force_commit(inode->i_sb);  in ext4_zero_range()
4794 		return -EINVAL;  in ext4_zero_range()
4795 	partial_begin = offset & ((1 << blkbits) - 1);  in ext4_zero_range()
4796 	partial_end = (offset + len) & ((1 << blkbits) - 1);  in ext4_zero_range()
4803 		max_blocks -= lblk;  in ext4_zero_range()
4811 		ret = -EOPNOTSUPP;  in ext4_zero_range()
4817 	     offset + len > EXT4_I(inode)->i_disksize)) {  in ext4_zero_range()
4835 				(round_up((offset + len), 1 << blkbits) -  in ext4_zero_range()
4852 		down_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_zero_range()
4856 			up_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_zero_range()
4862 			up_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_zero_range()
4866 		truncate_pagecache_range(inode, start, end - 1);  in ext4_zero_range()
4867 		inode->i_mtime = inode->i_ctime = current_time(inode);  in ext4_zero_range()
4871 		up_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_zero_range()
4888 		ext4_std_error(inode->i_sb, ret);  in ext4_zero_range()
4892 	inode->i_mtime = inode->i_ctime = current_time(inode);  in ext4_zero_range()
4910 	if (file->f_flags & O_SYNC)  in ext4_zero_range()
4922  * For block-mapped files, posix_fallocate should fall back to the method
4934 	unsigned int blkbits = inode->i_blkbits;  in ext4_fallocate()
4938 	 * range since we would need to re-encrypt blocks with a  in ext4_fallocate()
4949 		return -EOPNOTSUPP;  in ext4_fallocate()
4955 		return -EOPNOTSUPP;  in ext4_fallocate()
4984 	 * We only support preallocation for extent-based files only  in ext4_fallocate()
4987 		ret = -EOPNOTSUPP;  in ext4_fallocate()
4993 	     offset + len > EXT4_I(inode)->i_disksize)) {  in ext4_fallocate()
5007 	if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) {  in ext4_fallocate()
5008 		ret = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal,  in ext4_fallocate()
5009 						EXT4_I(inode)->i_sync_tid);  in ext4_fallocate()
5034 	unsigned int credits, blkbits = inode->i_blkbits;  in ext4_convert_unwritten_extents()
5058 		map.m_len = (max_blocks -= ret);  in ext4_convert_unwritten_extents()
5070 			ext4_warning(inode->i_sb,  in ext4_convert_unwritten_extents()
5073 				     inode->i_ino, map.m_lblk,  in ext4_convert_unwritten_extents()
5087  * If newes is not existing extent (newes->ec_pblk equals zero) find
5091  * If newes is existing extent (newes->ec_pblk is not equal zero)
5101 	if (newes->es_pblk == 0) {  in ext4_find_delayed_extent()
5102 		ext4_es_find_delayed_extent_range(inode, newes->es_lblk,  in ext4_find_delayed_extent()
5103 				newes->es_lblk + newes->es_len - 1, &es);  in ext4_find_delayed_extent()
5106 		 * No extent in extent-tree contains block @newes->es_pblk,  in ext4_find_delayed_extent()
5107 		 * then the block may stay in 1)a hole or 2)delayed-extent.  in ext4_find_delayed_extent()
5113 		if (es.es_lblk > newes->es_lblk) {  in ext4_find_delayed_extent()
5115 			newes->es_len = min(es.es_lblk - newes->es_lblk,  in ext4_find_delayed_extent()
5116 					    newes->es_len);  in ext4_find_delayed_extent()
5120 		newes->es_len = es.es_lblk + es.es_len - newes->es_lblk;  in ext4_find_delayed_extent()
5123 	block = newes->es_lblk + newes->es_len;  in ext4_find_delayed_extent()
5141 	int blockbits = inode->i_sb->s_blocksize_bits;  in ext4_xattr_fiemap()
5144 	/* in-inode? */  in ext4_xattr_fiemap()
5152 		physical = (__u64)iloc.bh->b_blocknr << blockbits;  in ext4_xattr_fiemap()
5154 				EXT4_I(inode)->i_extra_isize;  in ext4_xattr_fiemap()
5156 		length = EXT4_SB(inode->i_sb)->s_inode_size - offset;  in ext4_xattr_fiemap()
5160 		physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits;  in ext4_xattr_fiemap()
5161 		length = inode->i_sb->s_blocksize;  in ext4_xattr_fiemap()
5186 	if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {  in ext4_fiemap()
5198 		return -EBADR;  in ext4_fiemap()
5200 	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {  in ext4_fiemap()
5206 		start_blk = start >> inode->i_sb->s_blocksize_bits;  in ext4_fiemap()
5207 		last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;  in ext4_fiemap()
5209 			last_blk = EXT_MAX_BLOCKS-1;  in ext4_fiemap()
5210 		len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;  in ext4_fiemap()
5243 	if (handle->h_buffer_credits < 7) {  in ext4_access_path()
5247 		if (err && err != -EAGAIN)  in ext4_access_path()
5257  * Shift the extents of a path structure lying between path[depth].p_ext
5258  * and EXT_LAST_EXTENT(path[depth].p_hdr), by @shift blocks. @SHIFT tells
5266 	int depth, err = 0;  in ext4_ext_shift_path_extents()  local
5269 	depth = path->p_depth;  in ext4_ext_shift_path_extents()
5271 	while (depth >= 0) {  in ext4_ext_shift_path_extents()
5272 		if (depth == path->p_depth) {  in ext4_ext_shift_path_extents()
5273 			ex_start = path[depth].p_ext;  in ext4_ext_shift_path_extents()
5275 				return -EFSCORRUPTED;  in ext4_ext_shift_path_extents()
5277 			ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);  in ext4_ext_shift_path_extents()
5279 			err = ext4_access_path(handle, inode, path + depth);  in ext4_ext_shift_path_extents()
5283 			if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr))  in ext4_ext_shift_path_extents()
5288 					le32_add_cpu(&ex_start->ee_block,  in ext4_ext_shift_path_extents()
5289 						-shift);  in ext4_ext_shift_path_extents()
5292 					    EXT_FIRST_EXTENT(path[depth].p_hdr))  in ext4_ext_shift_path_extents()
5295 					    path, ex_start - 1))  in ext4_ext_shift_path_extents()
5296 						ex_last--;  in ext4_ext_shift_path_extents()
5300 					le32_add_cpu(&ex_last->ee_block, shift);  in ext4_ext_shift_path_extents()
5303 					ex_last--;  in ext4_ext_shift_path_extents()
5306 			err = ext4_ext_dirty(handle, inode, path + depth);  in ext4_ext_shift_path_extents()
5310 			if (--depth < 0 || !update)  in ext4_ext_shift_path_extents()
5315 		err = ext4_access_path(handle, inode, path + depth);  in ext4_ext_shift_path_extents()
5320 			le32_add_cpu(&path[depth].p_idx->ei_block, -shift);  in ext4_ext_shift_path_extents()
5322 			le32_add_cpu(&path[depth].p_idx->ei_block, shift);  in ext4_ext_shift_path_extents()
5323 		err = ext4_ext_dirty(handle, inode, path + depth);  in ext4_ext_shift_path_extents()
5328 		if (path[depth].p_idx != EXT_FIRST_INDEX(path[depth].p_hdr))  in ext4_ext_shift_path_extents()
5331 		depth--;  in ext4_ext_shift_path_extents()
5351 	int ret = 0, depth;  in ext4_ext_shift_extents()  local
5356 	path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,  in ext4_ext_shift_extents()
5361 	depth = path->p_depth;  in ext4_ext_shift_extents()
5362 	extent = path[depth].p_ext;  in ext4_ext_shift_extents()
5366 	stop = le32_to_cpu(extent->ee_block);  in ext4_ext_shift_extents()
5374 		path = ext4_find_extent(inode, start - 1, &path,  in ext4_ext_shift_extents()
5378 		depth = path->p_depth;  in ext4_ext_shift_extents()
5379 		extent =  path[depth].p_ext;  in ext4_ext_shift_extents()
5381 			ex_start = le32_to_cpu(extent->ee_block);  in ext4_ext_shift_extents()
5382 			ex_end = le32_to_cpu(extent->ee_block) +  in ext4_ext_shift_extents()
5390 		    (shift > start - ex_end)) {  in ext4_ext_shift_extents()
5391 			ret = -EINVAL;  in ext4_ext_shift_extents()
5395 		if (shift > EXT_MAX_BLOCKS -  in ext4_ext_shift_extents()
5397 			ret = -EINVAL;  in ext4_ext_shift_extents()
5422 		depth = path->p_depth;  in ext4_ext_shift_extents()
5423 		extent = path[depth].p_ext;  in ext4_ext_shift_extents()
5427 			return -EFSCORRUPTED;  in ext4_ext_shift_extents()
5430 		    le32_to_cpu(extent->ee_block)) {  in ext4_ext_shift_extents()
5432 			if (extent < EXT_LAST_EXTENT(path[depth].p_hdr)) {  in ext4_ext_shift_extents()
5433 				path[depth].p_ext++;  in ext4_ext_shift_extents()
5441 			extent = EXT_LAST_EXTENT(path[depth].p_hdr);  in ext4_ext_shift_extents()
5442 			*iterator = le32_to_cpu(extent->ee_block) +  in ext4_ext_shift_extents()
5445 			extent = EXT_FIRST_EXTENT(path[depth].p_hdr);  in ext4_ext_shift_extents()
5446 			if (le32_to_cpu(extent->ee_block) > 0)  in ext4_ext_shift_extents()
5447 				*iterator = le32_to_cpu(extent->ee_block) - 1;  in ext4_ext_shift_extents()
5452 			while (le32_to_cpu(extent->ee_block) < start)  in ext4_ext_shift_extents()
5454 			path[depth].p_ext = extent;  in ext4_ext_shift_extents()
5470  * Returns: 0 and non-zero on error.
5474 	struct super_block *sb = inode->i_sb;  in ext4_collapse_range()
5487 		return -EOPNOTSUPP;  in ext4_collapse_range()
5490 	if (offset & (EXT4_CLUSTER_SIZE(sb) - 1) ||  in ext4_collapse_range()
5491 	    len & (EXT4_CLUSTER_SIZE(sb) - 1))  in ext4_collapse_range()
5492 		return -EINVAL;  in ext4_collapse_range()
5494 	if (!S_ISREG(inode->i_mode))  in ext4_collapse_range()
5495 		return -EINVAL;  in ext4_collapse_range()
5504 		ret = ext4_force_commit(inode->i_sb);  in ext4_collapse_range()
5515 		ret = -EINVAL;  in ext4_collapse_range()
5521 		ret = -EOPNOTSUPP;  in ext4_collapse_range()
5532 	down_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_collapse_range()
5547 	ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset);  in ext4_collapse_range()
5555 	ret = filemap_write_and_wait_range(inode->i_mapping, offset + len,  in ext4_collapse_range()
5568 	down_write(&EXT4_I(inode)->i_data_sem);  in ext4_collapse_range()
5572 				    EXT_MAX_BLOCKS - punch_start);  in ext4_collapse_range()
5574 		up_write(&EXT4_I(inode)->i_data_sem);  in ext4_collapse_range()
5578 	ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1);  in ext4_collapse_range()
5580 		up_write(&EXT4_I(inode)->i_data_sem);  in ext4_collapse_range()
5586 				     punch_stop - punch_start, SHIFT_LEFT);  in ext4_collapse_range()
5588 		up_write(&EXT4_I(inode)->i_data_sem);  in ext4_collapse_range()
5592 	new_size = i_size_read(inode) - len;  in ext4_collapse_range()
5594 	EXT4_I(inode)->i_disksize = new_size;  in ext4_collapse_range()
5596 	up_write(&EXT4_I(inode)->i_data_sem);  in ext4_collapse_range()
5599 	inode->i_mtime = inode->i_ctime = current_time(inode);  in ext4_collapse_range()
5606 	up_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_collapse_range()
5622 	struct super_block *sb = inode->i_sb;  in ext4_insert_range()
5628 	int ret = 0, depth, split_flag = 0;  in ext4_insert_range()  local
5637 		return -EOPNOTSUPP;  in ext4_insert_range()
5640 	if (offset & (EXT4_CLUSTER_SIZE(sb) - 1) ||  in ext4_insert_range()
5641 			len & (EXT4_CLUSTER_SIZE(sb) - 1))  in ext4_insert_range()
5642 		return -EINVAL;  in ext4_insert_range()
5644 	if (!S_ISREG(inode->i_mode))  in ext4_insert_range()
5645 		return -EOPNOTSUPP;  in ext4_insert_range()
5654 		ret = ext4_force_commit(inode->i_sb);  in ext4_insert_range()
5662 		ret = -EOPNOTSUPP;  in ext4_insert_range()
5667 	if (inode->i_size + len > inode->i_sb->s_maxbytes) {  in ext4_insert_range()
5668 		ret = -EFBIG;  in ext4_insert_range()
5674 		ret = -EINVAL;  in ext4_insert_range()
5685 	down_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_insert_range()
5697 	ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,  in ext4_insert_range()
5711 	inode->i_size += len;  in ext4_insert_range()
5712 	EXT4_I(inode)->i_disksize += len;  in ext4_insert_range()
5713 	inode->i_mtime = inode->i_ctime = current_time(inode);  in ext4_insert_range()
5718 	down_write(&EXT4_I(inode)->i_data_sem);  in ext4_insert_range()
5723 		up_write(&EXT4_I(inode)->i_data_sem);  in ext4_insert_range()
5727 	depth = ext_depth(inode);  in ext4_insert_range()
5728 	extent = path[depth].p_ext;  in ext4_insert_range()
5730 		ee_start_lblk = le32_to_cpu(extent->ee_block);  in ext4_insert_range()
5752 			up_write(&EXT4_I(inode)->i_data_sem);  in ext4_insert_range()
5761 			EXT_MAX_BLOCKS - offset_lblk);  in ext4_insert_range()
5763 		up_write(&EXT4_I(inode)->i_data_sem);  in ext4_insert_range()
5775 	up_write(&EXT4_I(inode)->i_data_sem);  in ext4_insert_range()
5784 	up_write(&EXT4_I(inode)->i_mmap_sem);  in ext4_insert_range()
5791  * ext4_swap_extents - Swap extents between two inodes
5802  * stuff such as page-cache locking consistency, bh mapping consistency or
5819 	BUG_ON(!rwsem_is_locked(&EXT4_I(inode1)->i_data_sem));  in ext4_swap_extents()
5820 	BUG_ON(!rwsem_is_locked(&EXT4_I(inode2)->i_data_sem));  in ext4_swap_extents()
5851 		ex1 = path1[path1->p_depth].p_ext;  in ext4_swap_extents()
5852 		ex2 = path2[path2->p_depth].p_ext;  in ext4_swap_extents()
5857 		e1_blk = le32_to_cpu(ex1->ee_block);  in ext4_swap_extents()
5858 		e2_blk = le32_to_cpu(ex2->ee_block);  in ext4_swap_extents()
5879 			len = next1 - lblk1;  in ext4_swap_extents()
5880 			if (len < next2 - lblk2)  in ext4_swap_extents()
5881 				len = next2 - lblk2;  in ext4_swap_extents()
5886 			count -= len;  in ext4_swap_extents()
5912 		if (len > e1_blk + e1_len - lblk1)  in ext4_swap_extents()
5913 			len = e1_blk + e1_len - lblk1;  in ext4_swap_extents()
5914 		if (len > e2_blk + e2_len - lblk2)  in ext4_swap_extents()
5915 			len = e2_blk + e2_len - lblk2;  in ext4_swap_extents()
5937 		*erp = ext4_ext_get_access(handle, inode1, path1 + path1->p_depth);  in ext4_swap_extents()
5940 		*erp = ext4_ext_get_access(handle, inode2, path2 + path2->p_depth);  in ext4_swap_extents()
5948 		ex1->ee_len = cpu_to_le16(e2_len);  in ext4_swap_extents()
5949 		ex2->ee_len = cpu_to_le16(e1_len);  in ext4_swap_extents()
5958 				      path2->p_depth);  in ext4_swap_extents()
5962 				      path1->p_depth);  in ext4_swap_extents()
5974 		count -= len;  in ext4_swap_extents()