xref: /openbmc/linux/fs/ext4/extents.c (revision 8ec2d31b27f683e3deeaf5d562b534a695052de3)
1f5166768STheodore Ts'o // SPDX-License-Identifier: GPL-2.0
2a86c6181SAlex Tomas /*
3a86c6181SAlex Tomas  * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
4a86c6181SAlex Tomas  * Written by Alex Tomas <alex@clusterfs.com>
5a86c6181SAlex Tomas  *
6a86c6181SAlex Tomas  * Architecture independence:
7a86c6181SAlex Tomas  *   Copyright (c) 2005, Bull S.A.
8a86c6181SAlex Tomas  *   Written by Pierre Peiffer <pierre.peiffer@bull.net>
9a86c6181SAlex Tomas  */
10a86c6181SAlex Tomas 
11a86c6181SAlex Tomas /*
12a86c6181SAlex Tomas  * Extents support for EXT4
13a86c6181SAlex Tomas  *
14a86c6181SAlex Tomas  * TODO:
15a86c6181SAlex Tomas  *   - ext4*_error() should be used in some situations
16a86c6181SAlex Tomas  *   - analyze all BUG()/BUG_ON(), use -EIO where appropriate
17a86c6181SAlex Tomas  *   - smart tree reduction
18a86c6181SAlex Tomas  */
19a86c6181SAlex Tomas 
20a86c6181SAlex Tomas #include <linux/fs.h>
21a86c6181SAlex Tomas #include <linux/time.h>
22cd02ff0bSMingming Cao #include <linux/jbd2.h>
23a86c6181SAlex Tomas #include <linux/highuid.h>
24a86c6181SAlex Tomas #include <linux/pagemap.h>
25a86c6181SAlex Tomas #include <linux/quotaops.h>
26a86c6181SAlex Tomas #include <linux/string.h>
27a86c6181SAlex Tomas #include <linux/slab.h>
287c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
296873fa0dSEric Sandeen #include <linux/fiemap.h>
3066114cadSTejun Heo #include <linux/backing-dev.h>
31d3b6f23fSRitesh Harjani #include <linux/iomap.h>
323dcf5451SChristoph Hellwig #include "ext4_jbd2.h"
334a092d73STheodore Ts'o #include "ext4_extents.h"
34f19d5870STao Ma #include "xattr.h"
35a86c6181SAlex Tomas 
360562e0baSJiaying Zhang #include <trace/events/ext4.h>
370562e0baSJiaying Zhang 
385f95d21fSLukas Czerner /*
395f95d21fSLukas Czerner  * used by extent splitting.
405f95d21fSLukas Czerner  */
415f95d21fSLukas Czerner #define EXT4_EXT_MAY_ZEROOUT	0x1  /* safe to zeroout if split fails \
425f95d21fSLukas Czerner 					due to ENOSPC */
43556615dcSLukas Czerner #define EXT4_EXT_MARK_UNWRIT1	0x2  /* mark first half unwritten */
44556615dcSLukas Czerner #define EXT4_EXT_MARK_UNWRIT2	0x4  /* mark second half unwritten */
455f95d21fSLukas Czerner 
46dee1f973SDmitry Monakhov #define EXT4_EXT_DATA_VALID1	0x8  /* first half contains valid data */
47dee1f973SDmitry Monakhov #define EXT4_EXT_DATA_VALID2	0x10 /* second half contains valid data */
48dee1f973SDmitry Monakhov 
497ac5990dSDarrick J. Wong static __le32 ext4_extent_block_csum(struct inode *inode,
507ac5990dSDarrick J. Wong 				     struct ext4_extent_header *eh)
517ac5990dSDarrick J. Wong {
527ac5990dSDarrick J. Wong 	struct ext4_inode_info *ei = EXT4_I(inode);
537ac5990dSDarrick J. Wong 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
547ac5990dSDarrick J. Wong 	__u32 csum;
557ac5990dSDarrick J. Wong 
567ac5990dSDarrick J. Wong 	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh,
577ac5990dSDarrick J. Wong 			   EXT4_EXTENT_TAIL_OFFSET(eh));
587ac5990dSDarrick J. Wong 	return cpu_to_le32(csum);
597ac5990dSDarrick J. Wong }
607ac5990dSDarrick J. Wong 
617ac5990dSDarrick J. Wong static int ext4_extent_block_csum_verify(struct inode *inode,
627ac5990dSDarrick J. Wong 					 struct ext4_extent_header *eh)
637ac5990dSDarrick J. Wong {
647ac5990dSDarrick J. Wong 	struct ext4_extent_tail *et;
657ac5990dSDarrick J. Wong 
669aa5d32bSDmitry Monakhov 	if (!ext4_has_metadata_csum(inode->i_sb))
677ac5990dSDarrick J. Wong 		return 1;
687ac5990dSDarrick J. Wong 
697ac5990dSDarrick J. Wong 	et = find_ext4_extent_tail(eh);
707ac5990dSDarrick J. Wong 	if (et->et_checksum != ext4_extent_block_csum(inode, eh))
717ac5990dSDarrick J. Wong 		return 0;
727ac5990dSDarrick J. Wong 	return 1;
737ac5990dSDarrick J. Wong }
747ac5990dSDarrick J. Wong 
757ac5990dSDarrick J. Wong static void ext4_extent_block_csum_set(struct inode *inode,
767ac5990dSDarrick J. Wong 				       struct ext4_extent_header *eh)
777ac5990dSDarrick J. Wong {
787ac5990dSDarrick J. Wong 	struct ext4_extent_tail *et;
797ac5990dSDarrick J. Wong 
809aa5d32bSDmitry Monakhov 	if (!ext4_has_metadata_csum(inode->i_sb))
817ac5990dSDarrick J. Wong 		return;
827ac5990dSDarrick J. Wong 
837ac5990dSDarrick J. Wong 	et = find_ext4_extent_tail(eh);
847ac5990dSDarrick J. Wong 	et->et_checksum = ext4_extent_block_csum(inode, eh);
857ac5990dSDarrick J. Wong }
867ac5990dSDarrick J. Wong 
875f95d21fSLukas Czerner static int ext4_split_extent_at(handle_t *handle,
885f95d21fSLukas Czerner 			     struct inode *inode,
89dfe50809STheodore Ts'o 			     struct ext4_ext_path **ppath,
905f95d21fSLukas Czerner 			     ext4_lblk_t split,
915f95d21fSLukas Czerner 			     int split_flag,
925f95d21fSLukas Czerner 			     int flags);
935f95d21fSLukas Czerner 
94a4130367SJan Kara static int ext4_ext_trunc_restart_fn(struct inode *inode, int *dropped)
95a86c6181SAlex Tomas {
967b808191STheodore Ts'o 	/*
97a4130367SJan Kara 	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this
98a4130367SJan Kara 	 * moment, get_block can be called only for blocks inside i_size since
99a4130367SJan Kara 	 * page cache has been already dropped and writes are blocked by
100a4130367SJan Kara 	 * i_mutex. So we can safely drop the i_data_sem here.
1017b808191STheodore Ts'o 	 */
102a4130367SJan Kara 	BUG_ON(EXT4_JOURNAL(inode) == NULL);
103a4130367SJan Kara 	ext4_discard_preallocations(inode);
104a4130367SJan Kara 	up_write(&EXT4_I(inode)->i_data_sem);
105a4130367SJan Kara 	*dropped = 1;
106a4130367SJan Kara 	return 0;
107a4130367SJan Kara }
108487caeefSJan Kara 
109a4130367SJan Kara /*
110a4130367SJan Kara  * Make sure 'handle' has at least 'check_cred' credits. If not, restart
111a4130367SJan Kara  * transaction with 'restart_cred' credits. The function drops i_data_sem
112a4130367SJan Kara  * when restarting transaction and gets it after transaction is restarted.
113a4130367SJan Kara  *
114a4130367SJan Kara  * The function returns 0 on success, 1 if transaction had to be restarted,
115a4130367SJan Kara  * and < 0 in case of fatal error.
116a4130367SJan Kara  */
117a4130367SJan Kara int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
11883448bdfSJan Kara 				int check_cred, int restart_cred,
11983448bdfSJan Kara 				int revoke_cred)
120a4130367SJan Kara {
121a4130367SJan Kara 	int ret;
122a4130367SJan Kara 	int dropped = 0;
123a4130367SJan Kara 
124a4130367SJan Kara 	ret = ext4_journal_ensure_credits_fn(handle, check_cred, restart_cred,
12583448bdfSJan Kara 		revoke_cred, ext4_ext_trunc_restart_fn(inode, &dropped));
126a4130367SJan Kara 	if (dropped)
127a4130367SJan Kara 		down_write(&EXT4_I(inode)->i_data_sem);
128a4130367SJan Kara 	return ret;
129a86c6181SAlex Tomas }
130a86c6181SAlex Tomas 
131a86c6181SAlex Tomas /*
132a86c6181SAlex Tomas  * could return:
133a86c6181SAlex Tomas  *  - EROFS
134a86c6181SAlex Tomas  *  - ENOMEM
135a86c6181SAlex Tomas  */
136a86c6181SAlex Tomas static int ext4_ext_get_access(handle_t *handle, struct inode *inode,
137a86c6181SAlex Tomas 				struct ext4_ext_path *path)
138a86c6181SAlex Tomas {
139a86c6181SAlex Tomas 	if (path->p_bh) {
140a86c6181SAlex Tomas 		/* path points to block */
1415d601255Sliang xie 		BUFFER_TRACE(path->p_bh, "get_write_access");
142a86c6181SAlex Tomas 		return ext4_journal_get_write_access(handle, path->p_bh);
143a86c6181SAlex Tomas 	}
144a86c6181SAlex Tomas 	/* path points to leaf/index in inode body */
145a86c6181SAlex Tomas 	/* we use in-core data, no need to protect them */
146a86c6181SAlex Tomas 	return 0;
147a86c6181SAlex Tomas }
148a86c6181SAlex Tomas 
149a86c6181SAlex Tomas /*
150a86c6181SAlex Tomas  * could return:
151a86c6181SAlex Tomas  *  - EROFS
152a86c6181SAlex Tomas  *  - ENOMEM
153a86c6181SAlex Tomas  *  - EIO
154a86c6181SAlex Tomas  */
15543f81677SEric Biggers static int __ext4_ext_dirty(const char *where, unsigned int line,
15643f81677SEric Biggers 			    handle_t *handle, struct inode *inode,
15743f81677SEric Biggers 			    struct ext4_ext_path *path)
158a86c6181SAlex Tomas {
159a86c6181SAlex Tomas 	int err;
1604b1f1660SDmitry Monakhov 
1614b1f1660SDmitry Monakhov 	WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem));
162a86c6181SAlex Tomas 	if (path->p_bh) {
1637ac5990dSDarrick J. Wong 		ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh));
164a86c6181SAlex Tomas 		/* path points to block */
1659ea7a0dfSTheodore Ts'o 		err = __ext4_handle_dirty_metadata(where, line, handle,
1669ea7a0dfSTheodore Ts'o 						   inode, path->p_bh);
167a86c6181SAlex Tomas 	} else {
168a86c6181SAlex Tomas 		/* path points to leaf/index in inode body */
169a86c6181SAlex Tomas 		err = ext4_mark_inode_dirty(handle, inode);
170a86c6181SAlex Tomas 	}
171a86c6181SAlex Tomas 	return err;
172a86c6181SAlex Tomas }
173a86c6181SAlex Tomas 
17443f81677SEric Biggers #define ext4_ext_dirty(handle, inode, path) \
17543f81677SEric Biggers 		__ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path))
17643f81677SEric Biggers 
177f65e6fbaSAlex Tomas static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
178a86c6181SAlex Tomas 			      struct ext4_ext_path *path,
179725d26d3SAneesh Kumar K.V 			      ext4_lblk_t block)
180a86c6181SAlex Tomas {
181a86c6181SAlex Tomas 	if (path) {
18281fdbb4aSYongqiang Yang 		int depth = path->p_depth;
183a86c6181SAlex Tomas 		struct ext4_extent *ex;
184a86c6181SAlex Tomas 
185ad4fb9caSKazuya Mio 		/*
186ad4fb9caSKazuya Mio 		 * Try to predict block placement assuming that we are
187ad4fb9caSKazuya Mio 		 * filling in a file which will eventually be
188ad4fb9caSKazuya Mio 		 * non-sparse --- i.e., in the case of libbfd writing
189ad4fb9caSKazuya Mio 		 * an ELF object sections out-of-order but in a way
190ad4fb9caSKazuya Mio 		 * the eventually results in a contiguous object or
191ad4fb9caSKazuya Mio 		 * executable file, or some database extending a table
192ad4fb9caSKazuya Mio 		 * space file.  However, this is actually somewhat
193ad4fb9caSKazuya Mio 		 * non-ideal if we are writing a sparse file such as
194ad4fb9caSKazuya Mio 		 * qemu or KVM writing a raw image file that is going
195ad4fb9caSKazuya Mio 		 * to stay fairly sparse, since it will end up
196ad4fb9caSKazuya Mio 		 * fragmenting the file system's free space.  Maybe we
197ad4fb9caSKazuya Mio 		 * should have some hueristics or some way to allow
198ad4fb9caSKazuya Mio 		 * userspace to pass a hint to file system,
199b8d6568aSTao Ma 		 * especially if the latter case turns out to be
200ad4fb9caSKazuya Mio 		 * common.
201ad4fb9caSKazuya Mio 		 */
2027e028976SAvantika Mathur 		ex = path[depth].p_ext;
203ad4fb9caSKazuya Mio 		if (ex) {
204ad4fb9caSKazuya Mio 			ext4_fsblk_t ext_pblk = ext4_ext_pblock(ex);
205ad4fb9caSKazuya Mio 			ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block);
206ad4fb9caSKazuya Mio 
207ad4fb9caSKazuya Mio 			if (block > ext_block)
208ad4fb9caSKazuya Mio 				return ext_pblk + (block - ext_block);
209ad4fb9caSKazuya Mio 			else
210ad4fb9caSKazuya Mio 				return ext_pblk - (ext_block - block);
211ad4fb9caSKazuya Mio 		}
212a86c6181SAlex Tomas 
213d0d856e8SRandy Dunlap 		/* it looks like index is empty;
214d0d856e8SRandy Dunlap 		 * try to find starting block from index itself */
215a86c6181SAlex Tomas 		if (path[depth].p_bh)
216a86c6181SAlex Tomas 			return path[depth].p_bh->b_blocknr;
217a86c6181SAlex Tomas 	}
218a86c6181SAlex Tomas 
219a86c6181SAlex Tomas 	/* OK. use inode's group */
220f86186b4SEric Sandeen 	return ext4_inode_to_goal_block(inode);
221a86c6181SAlex Tomas }
222a86c6181SAlex Tomas 
223654b4908SAneesh Kumar K.V /*
224654b4908SAneesh Kumar K.V  * Allocation for a meta data block
225654b4908SAneesh Kumar K.V  */
226f65e6fbaSAlex Tomas static ext4_fsblk_t
227654b4908SAneesh Kumar K.V ext4_ext_new_meta_block(handle_t *handle, struct inode *inode,
228a86c6181SAlex Tomas 			struct ext4_ext_path *path,
22955f020dbSAllison Henderson 			struct ext4_extent *ex, int *err, unsigned int flags)
230a86c6181SAlex Tomas {
231f65e6fbaSAlex Tomas 	ext4_fsblk_t goal, newblock;
232a86c6181SAlex Tomas 
233a86c6181SAlex Tomas 	goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
23455f020dbSAllison Henderson 	newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
23555f020dbSAllison Henderson 					NULL, err);
236a86c6181SAlex Tomas 	return newblock;
237a86c6181SAlex Tomas }
238a86c6181SAlex Tomas 
23955ad63bfSTheodore Ts'o static inline int ext4_ext_space_block(struct inode *inode, int check)
240a86c6181SAlex Tomas {
241a86c6181SAlex Tomas 	int size;
242a86c6181SAlex Tomas 
243a86c6181SAlex Tomas 	size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
244a86c6181SAlex Tomas 			/ sizeof(struct ext4_extent);
245bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
24602dc62fbSYongqiang Yang 	if (!check && size > 6)
247a86c6181SAlex Tomas 		size = 6;
248a86c6181SAlex Tomas #endif
249a86c6181SAlex Tomas 	return size;
250a86c6181SAlex Tomas }
251a86c6181SAlex Tomas 
25255ad63bfSTheodore Ts'o static inline int ext4_ext_space_block_idx(struct inode *inode, int check)
253a86c6181SAlex Tomas {
254a86c6181SAlex Tomas 	int size;
255a86c6181SAlex Tomas 
256a86c6181SAlex Tomas 	size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
257a86c6181SAlex Tomas 			/ sizeof(struct ext4_extent_idx);
258bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
25902dc62fbSYongqiang Yang 	if (!check && size > 5)
260a86c6181SAlex Tomas 		size = 5;
261a86c6181SAlex Tomas #endif
262a86c6181SAlex Tomas 	return size;
263a86c6181SAlex Tomas }
264a86c6181SAlex Tomas 
26555ad63bfSTheodore Ts'o static inline int ext4_ext_space_root(struct inode *inode, int check)
266a86c6181SAlex Tomas {
267a86c6181SAlex Tomas 	int size;
268a86c6181SAlex Tomas 
269a86c6181SAlex Tomas 	size = sizeof(EXT4_I(inode)->i_data);
270a86c6181SAlex Tomas 	size -= sizeof(struct ext4_extent_header);
271a86c6181SAlex Tomas 	size /= sizeof(struct ext4_extent);
272bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
27302dc62fbSYongqiang Yang 	if (!check && size > 3)
274a86c6181SAlex Tomas 		size = 3;
275a86c6181SAlex Tomas #endif
276a86c6181SAlex Tomas 	return size;
277a86c6181SAlex Tomas }
278a86c6181SAlex Tomas 
27955ad63bfSTheodore Ts'o static inline int ext4_ext_space_root_idx(struct inode *inode, int check)
280a86c6181SAlex Tomas {
281a86c6181SAlex Tomas 	int size;
282a86c6181SAlex Tomas 
283a86c6181SAlex Tomas 	size = sizeof(EXT4_I(inode)->i_data);
284a86c6181SAlex Tomas 	size -= sizeof(struct ext4_extent_header);
285a86c6181SAlex Tomas 	size /= sizeof(struct ext4_extent_idx);
286bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
28702dc62fbSYongqiang Yang 	if (!check && size > 4)
288a86c6181SAlex Tomas 		size = 4;
289a86c6181SAlex Tomas #endif
290a86c6181SAlex Tomas 	return size;
291a86c6181SAlex Tomas }
292a86c6181SAlex Tomas 
293fcf6b1b7SDmitry Monakhov static inline int
294fcf6b1b7SDmitry Monakhov ext4_force_split_extent_at(handle_t *handle, struct inode *inode,
295dfe50809STheodore Ts'o 			   struct ext4_ext_path **ppath, ext4_lblk_t lblk,
296fcf6b1b7SDmitry Monakhov 			   int nofail)
297fcf6b1b7SDmitry Monakhov {
298dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
299fcf6b1b7SDmitry Monakhov 	int unwritten = ext4_ext_is_unwritten(path[path->p_depth].p_ext);
30073c384c0STheodore Ts'o 	int flags = EXT4_EX_NOCACHE | EXT4_GET_BLOCKS_PRE_IO;
30173c384c0STheodore Ts'o 
30273c384c0STheodore Ts'o 	if (nofail)
30373c384c0STheodore Ts'o 		flags |= EXT4_GET_BLOCKS_METADATA_NOFAIL | EXT4_EX_NOFAIL;
304fcf6b1b7SDmitry Monakhov 
305dfe50809STheodore Ts'o 	return ext4_split_extent_at(handle, inode, ppath, lblk, unwritten ?
306fcf6b1b7SDmitry Monakhov 			EXT4_EXT_MARK_UNWRIT1|EXT4_EXT_MARK_UNWRIT2 : 0,
30773c384c0STheodore Ts'o 			flags);
308fcf6b1b7SDmitry Monakhov }
309fcf6b1b7SDmitry Monakhov 
310c29c0ae7SAlex Tomas static int
311c29c0ae7SAlex Tomas ext4_ext_max_entries(struct inode *inode, int depth)
312c29c0ae7SAlex Tomas {
313c29c0ae7SAlex Tomas 	int max;
314c29c0ae7SAlex Tomas 
315c29c0ae7SAlex Tomas 	if (depth == ext_depth(inode)) {
316c29c0ae7SAlex Tomas 		if (depth == 0)
31755ad63bfSTheodore Ts'o 			max = ext4_ext_space_root(inode, 1);
318c29c0ae7SAlex Tomas 		else
31955ad63bfSTheodore Ts'o 			max = ext4_ext_space_root_idx(inode, 1);
320c29c0ae7SAlex Tomas 	} else {
321c29c0ae7SAlex Tomas 		if (depth == 0)
32255ad63bfSTheodore Ts'o 			max = ext4_ext_space_block(inode, 1);
323c29c0ae7SAlex Tomas 		else
32455ad63bfSTheodore Ts'o 			max = ext4_ext_space_block_idx(inode, 1);
325c29c0ae7SAlex Tomas 	}
326c29c0ae7SAlex Tomas 
327c29c0ae7SAlex Tomas 	return max;
328c29c0ae7SAlex Tomas }
329c29c0ae7SAlex Tomas 
33056b19868SAneesh Kumar K.V static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
33156b19868SAneesh Kumar K.V {
332bf89d16fSTheodore Ts'o 	ext4_fsblk_t block = ext4_ext_pblock(ext);
33356b19868SAneesh Kumar K.V 	int len = ext4_ext_get_actual_len(ext);
3345946d089SEryu Guan 	ext4_lblk_t lblock = le32_to_cpu(ext->ee_block);
335e84a26ceSTheodore Ts'o 
336f70749caSVegard Nossum 	/*
337f70749caSVegard Nossum 	 * We allow neither:
338f70749caSVegard Nossum 	 *  - zero length
339f70749caSVegard Nossum 	 *  - overflow/wrap-around
340f70749caSVegard Nossum 	 */
341f70749caSVegard Nossum 	if (lblock + len <= lblock)
34231d4f3a2STheodore Ts'o 		return 0;
3436fd058f7STheodore Ts'o 	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);
34456b19868SAneesh Kumar K.V }
34556b19868SAneesh Kumar K.V 
34656b19868SAneesh Kumar K.V static int ext4_valid_extent_idx(struct inode *inode,
34756b19868SAneesh Kumar K.V 				struct ext4_extent_idx *ext_idx)
34856b19868SAneesh Kumar K.V {
349bf89d16fSTheodore Ts'o 	ext4_fsblk_t block = ext4_idx_pblock(ext_idx);
350e84a26ceSTheodore Ts'o 
3516fd058f7STheodore Ts'o 	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);
35256b19868SAneesh Kumar K.V }
35356b19868SAneesh Kumar K.V 
35456b19868SAneesh Kumar K.V static int ext4_valid_extent_entries(struct inode *inode,
35556b19868SAneesh Kumar K.V 				     struct ext4_extent_header *eh,
35654d3adbcSTheodore Ts'o 				     ext4_fsblk_t *pblk, int depth)
35756b19868SAneesh Kumar K.V {
35856b19868SAneesh Kumar K.V 	unsigned short entries;
35956b19868SAneesh Kumar K.V 	if (eh->eh_entries == 0)
36056b19868SAneesh Kumar K.V 		return 1;
36156b19868SAneesh Kumar K.V 
36256b19868SAneesh Kumar K.V 	entries = le16_to_cpu(eh->eh_entries);
36356b19868SAneesh Kumar K.V 
36456b19868SAneesh Kumar K.V 	if (depth == 0) {
36556b19868SAneesh Kumar K.V 		/* leaf entries */
36681fdbb4aSYongqiang Yang 		struct ext4_extent *ext = EXT_FIRST_EXTENT(eh);
3675946d089SEryu Guan 		ext4_lblk_t lblock = 0;
3685946d089SEryu Guan 		ext4_lblk_t prev = 0;
3695946d089SEryu Guan 		int len = 0;
37056b19868SAneesh Kumar K.V 		while (entries) {
37156b19868SAneesh Kumar K.V 			if (!ext4_valid_extent(inode, ext))
37256b19868SAneesh Kumar K.V 				return 0;
3735946d089SEryu Guan 
3745946d089SEryu Guan 			/* Check for overlapping extents */
3755946d089SEryu Guan 			lblock = le32_to_cpu(ext->ee_block);
3765946d089SEryu Guan 			len = ext4_ext_get_actual_len(ext);
3775946d089SEryu Guan 			if ((lblock <= prev) && prev) {
37854d3adbcSTheodore Ts'o 				*pblk = ext4_ext_pblock(ext);
3795946d089SEryu Guan 				return 0;
3805946d089SEryu Guan 			}
38156b19868SAneesh Kumar K.V 			ext++;
38256b19868SAneesh Kumar K.V 			entries--;
3835946d089SEryu Guan 			prev = lblock + len - 1;
38456b19868SAneesh Kumar K.V 		}
38556b19868SAneesh Kumar K.V 	} else {
38681fdbb4aSYongqiang Yang 		struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh);
38756b19868SAneesh Kumar K.V 		while (entries) {
38856b19868SAneesh Kumar K.V 			if (!ext4_valid_extent_idx(inode, ext_idx))
38956b19868SAneesh Kumar K.V 				return 0;
39056b19868SAneesh Kumar K.V 			ext_idx++;
39156b19868SAneesh Kumar K.V 			entries--;
39256b19868SAneesh Kumar K.V 		}
39356b19868SAneesh Kumar K.V 	}
39456b19868SAneesh Kumar K.V 	return 1;
39556b19868SAneesh Kumar K.V }
39656b19868SAneesh Kumar K.V 
397c398eda0STheodore Ts'o static int __ext4_ext_check(const char *function, unsigned int line,
398c398eda0STheodore Ts'o 			    struct inode *inode, struct ext4_extent_header *eh,
399c349179bSTheodore Ts'o 			    int depth, ext4_fsblk_t pblk)
400c29c0ae7SAlex Tomas {
401c29c0ae7SAlex Tomas 	const char *error_msg;
4026a797d27SDarrick J. Wong 	int max = 0, err = -EFSCORRUPTED;
403c29c0ae7SAlex Tomas 
404c29c0ae7SAlex Tomas 	if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) {
405c29c0ae7SAlex Tomas 		error_msg = "invalid magic";
406c29c0ae7SAlex Tomas 		goto corrupted;
407c29c0ae7SAlex Tomas 	}
408c29c0ae7SAlex Tomas 	if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {
409c29c0ae7SAlex Tomas 		error_msg = "unexpected eh_depth";
410c29c0ae7SAlex Tomas 		goto corrupted;
411c29c0ae7SAlex Tomas 	}
412c29c0ae7SAlex Tomas 	if (unlikely(eh->eh_max == 0)) {
413c29c0ae7SAlex Tomas 		error_msg = "invalid eh_max";
414c29c0ae7SAlex Tomas 		goto corrupted;
415c29c0ae7SAlex Tomas 	}
416c29c0ae7SAlex Tomas 	max = ext4_ext_max_entries(inode, depth);
417c29c0ae7SAlex Tomas 	if (unlikely(le16_to_cpu(eh->eh_max) > max)) {
418c29c0ae7SAlex Tomas 		error_msg = "too large eh_max";
419c29c0ae7SAlex Tomas 		goto corrupted;
420c29c0ae7SAlex Tomas 	}
421c29c0ae7SAlex Tomas 	if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) {
422c29c0ae7SAlex Tomas 		error_msg = "invalid eh_entries";
423c29c0ae7SAlex Tomas 		goto corrupted;
424c29c0ae7SAlex Tomas 	}
42554d3adbcSTheodore Ts'o 	if (!ext4_valid_extent_entries(inode, eh, &pblk, depth)) {
42656b19868SAneesh Kumar K.V 		error_msg = "invalid extent entries";
42756b19868SAneesh Kumar K.V 		goto corrupted;
42856b19868SAneesh Kumar K.V 	}
4297bc94916SVegard Nossum 	if (unlikely(depth > 32)) {
4307bc94916SVegard Nossum 		error_msg = "too large eh_depth";
4317bc94916SVegard Nossum 		goto corrupted;
4327bc94916SVegard Nossum 	}
4337ac5990dSDarrick J. Wong 	/* Verify checksum on non-root extent tree nodes */
4347ac5990dSDarrick J. Wong 	if (ext_depth(inode) != depth &&
4357ac5990dSDarrick J. Wong 	    !ext4_extent_block_csum_verify(inode, eh)) {
4367ac5990dSDarrick J. Wong 		error_msg = "extent tree corrupted";
4376a797d27SDarrick J. Wong 		err = -EFSBADCRC;
4387ac5990dSDarrick J. Wong 		goto corrupted;
4397ac5990dSDarrick J. Wong 	}
440c29c0ae7SAlex Tomas 	return 0;
441c29c0ae7SAlex Tomas 
442c29c0ae7SAlex Tomas corrupted:
44354d3adbcSTheodore Ts'o 	ext4_error_inode_err(inode, function, line, 0, -err,
444c349179bSTheodore Ts'o 			     "pblk %llu bad header/extent: %s - magic %x, "
445c29c0ae7SAlex Tomas 			     "entries %u, max %u(%u), depth %u(%u)",
446c349179bSTheodore Ts'o 			     (unsigned long long) pblk, error_msg,
447c349179bSTheodore Ts'o 			     le16_to_cpu(eh->eh_magic),
44854d3adbcSTheodore Ts'o 			     le16_to_cpu(eh->eh_entries),
44954d3adbcSTheodore Ts'o 			     le16_to_cpu(eh->eh_max),
450c29c0ae7SAlex Tomas 			     max, le16_to_cpu(eh->eh_depth), depth);
4516a797d27SDarrick J. Wong 	return err;
452c29c0ae7SAlex Tomas }
453c29c0ae7SAlex Tomas 
454c349179bSTheodore Ts'o #define ext4_ext_check(inode, eh, depth, pblk)			\
455c349179bSTheodore Ts'o 	__ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk))
456c29c0ae7SAlex Tomas 
4577a262f7cSAneesh Kumar K.V int ext4_ext_check_inode(struct inode *inode)
4587a262f7cSAneesh Kumar K.V {
459c349179bSTheodore Ts'o 	return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode), 0);
4607a262f7cSAneesh Kumar K.V }
4617a262f7cSAneesh Kumar K.V 
4624068664eSDmitry Monakhov static void ext4_cache_extents(struct inode *inode,
4634068664eSDmitry Monakhov 			       struct ext4_extent_header *eh)
4644068664eSDmitry Monakhov {
4654068664eSDmitry Monakhov 	struct ext4_extent *ex = EXT_FIRST_EXTENT(eh);
4664068664eSDmitry Monakhov 	ext4_lblk_t prev = 0;
4674068664eSDmitry Monakhov 	int i;
4684068664eSDmitry Monakhov 
4694068664eSDmitry Monakhov 	for (i = le16_to_cpu(eh->eh_entries); i > 0; i--, ex++) {
4704068664eSDmitry Monakhov 		unsigned int status = EXTENT_STATUS_WRITTEN;
4714068664eSDmitry Monakhov 		ext4_lblk_t lblk = le32_to_cpu(ex->ee_block);
4724068664eSDmitry Monakhov 		int len = ext4_ext_get_actual_len(ex);
4734068664eSDmitry Monakhov 
4744068664eSDmitry Monakhov 		if (prev && (prev != lblk))
4754068664eSDmitry Monakhov 			ext4_es_cache_extent(inode, prev, lblk - prev, ~0,
4764068664eSDmitry Monakhov 					     EXTENT_STATUS_HOLE);
4774068664eSDmitry Monakhov 
4784068664eSDmitry Monakhov 		if (ext4_ext_is_unwritten(ex))
4794068664eSDmitry Monakhov 			status = EXTENT_STATUS_UNWRITTEN;
4804068664eSDmitry Monakhov 		ext4_es_cache_extent(inode, lblk, len,
4814068664eSDmitry Monakhov 				     ext4_ext_pblock(ex), status);
4824068664eSDmitry Monakhov 		prev = lblk + len;
4834068664eSDmitry Monakhov 	}
4844068664eSDmitry Monakhov }
4854068664eSDmitry Monakhov 
4867d7ea89eSTheodore Ts'o static struct buffer_head *
4877d7ea89eSTheodore Ts'o __read_extent_tree_block(const char *function, unsigned int line,
488107a7bd3STheodore Ts'o 			 struct inode *inode, ext4_fsblk_t pblk, int depth,
489107a7bd3STheodore Ts'o 			 int flags)
490f8489128SDarrick J. Wong {
4917d7ea89eSTheodore Ts'o 	struct buffer_head		*bh;
4927d7ea89eSTheodore Ts'o 	int				err;
49373c384c0STheodore Ts'o 	gfp_t				gfp_flags = __GFP_MOVABLE | GFP_NOFS;
494f8489128SDarrick J. Wong 
49573c384c0STheodore Ts'o 	if (flags & EXT4_EX_NOFAIL)
49673c384c0STheodore Ts'o 		gfp_flags |= __GFP_NOFAIL;
49773c384c0STheodore Ts'o 
49873c384c0STheodore Ts'o 	bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags);
4997d7ea89eSTheodore Ts'o 	if (unlikely(!bh))
5007d7ea89eSTheodore Ts'o 		return ERR_PTR(-ENOMEM);
5017d7ea89eSTheodore Ts'o 
5027d7ea89eSTheodore Ts'o 	if (!bh_uptodate_or_lock(bh)) {
5037d7ea89eSTheodore Ts'o 		trace_ext4_ext_load_extent(inode, pblk, _RET_IP_);
5047d7ea89eSTheodore Ts'o 		err = bh_submit_read(bh);
5057d7ea89eSTheodore Ts'o 		if (err < 0)
5067d7ea89eSTheodore Ts'o 			goto errout;
5077d7ea89eSTheodore Ts'o 	}
5087869a4a6STheodore Ts'o 	if (buffer_verified(bh) && !(flags & EXT4_EX_FORCE_CACHE))
5097d7ea89eSTheodore Ts'o 		return bh;
5100a944e8aSTheodore Ts'o 	if (!ext4_has_feature_journal(inode->i_sb) ||
5110a944e8aSTheodore Ts'o 	    (inode->i_ino !=
5120a944e8aSTheodore Ts'o 	     le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum))) {
5137d7ea89eSTheodore Ts'o 		err = __ext4_ext_check(function, line, inode,
514c349179bSTheodore Ts'o 				       ext_block_hdr(bh), depth, pblk);
5157d7ea89eSTheodore Ts'o 		if (err)
5167d7ea89eSTheodore Ts'o 			goto errout;
5170a944e8aSTheodore Ts'o 	}
518f8489128SDarrick J. Wong 	set_buffer_verified(bh);
519107a7bd3STheodore Ts'o 	/*
520107a7bd3STheodore Ts'o 	 * If this is a leaf block, cache all of its entries
521107a7bd3STheodore Ts'o 	 */
522107a7bd3STheodore Ts'o 	if (!(flags & EXT4_EX_NOCACHE) && depth == 0) {
523107a7bd3STheodore Ts'o 		struct ext4_extent_header *eh = ext_block_hdr(bh);
5244068664eSDmitry Monakhov 		ext4_cache_extents(inode, eh);
525107a7bd3STheodore Ts'o 	}
5267d7ea89eSTheodore Ts'o 	return bh;
5277d7ea89eSTheodore Ts'o errout:
5287d7ea89eSTheodore Ts'o 	put_bh(bh);
5297d7ea89eSTheodore Ts'o 	return ERR_PTR(err);
5307d7ea89eSTheodore Ts'o 
531f8489128SDarrick J. Wong }
532f8489128SDarrick J. Wong 
533107a7bd3STheodore Ts'o #define read_extent_tree_block(inode, pblk, depth, flags)		\
534107a7bd3STheodore Ts'o 	__read_extent_tree_block(__func__, __LINE__, (inode), (pblk),   \
535107a7bd3STheodore Ts'o 				 (depth), (flags))
536f8489128SDarrick J. Wong 
5377869a4a6STheodore Ts'o /*
5387869a4a6STheodore Ts'o  * This function is called to cache a file's extent information in the
5397869a4a6STheodore Ts'o  * extent status tree
5407869a4a6STheodore Ts'o  */
5417869a4a6STheodore Ts'o int ext4_ext_precache(struct inode *inode)
5427869a4a6STheodore Ts'o {
5437869a4a6STheodore Ts'o 	struct ext4_inode_info *ei = EXT4_I(inode);
5447869a4a6STheodore Ts'o 	struct ext4_ext_path *path = NULL;
5457869a4a6STheodore Ts'o 	struct buffer_head *bh;
5467869a4a6STheodore Ts'o 	int i = 0, depth, ret = 0;
5477869a4a6STheodore Ts'o 
5487869a4a6STheodore Ts'o 	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5497869a4a6STheodore Ts'o 		return 0;	/* not an extent-mapped inode */
5507869a4a6STheodore Ts'o 
5517869a4a6STheodore Ts'o 	down_read(&ei->i_data_sem);
5527869a4a6STheodore Ts'o 	depth = ext_depth(inode);
5537869a4a6STheodore Ts'o 
5542f424a5aSRitesh Harjani 	/* Don't cache anything if there are no external extent blocks */
5552f424a5aSRitesh Harjani 	if (!depth) {
5562f424a5aSRitesh Harjani 		up_read(&ei->i_data_sem);
5572f424a5aSRitesh Harjani 		return ret;
5582f424a5aSRitesh Harjani 	}
5592f424a5aSRitesh Harjani 
5606396bb22SKees Cook 	path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
5617869a4a6STheodore Ts'o 		       GFP_NOFS);
5627869a4a6STheodore Ts'o 	if (path == NULL) {
5637869a4a6STheodore Ts'o 		up_read(&ei->i_data_sem);
5647869a4a6STheodore Ts'o 		return -ENOMEM;
5657869a4a6STheodore Ts'o 	}
5667869a4a6STheodore Ts'o 
5677869a4a6STheodore Ts'o 	path[0].p_hdr = ext_inode_hdr(inode);
5687869a4a6STheodore Ts'o 	ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0);
5697869a4a6STheodore Ts'o 	if (ret)
5707869a4a6STheodore Ts'o 		goto out;
5717869a4a6STheodore Ts'o 	path[0].p_idx = EXT_FIRST_INDEX(path[0].p_hdr);
5727869a4a6STheodore Ts'o 	while (i >= 0) {
5737869a4a6STheodore Ts'o 		/*
5747869a4a6STheodore Ts'o 		 * If this is a leaf block or we've reached the end of
5757869a4a6STheodore Ts'o 		 * the index block, go up
5767869a4a6STheodore Ts'o 		 */
5777869a4a6STheodore Ts'o 		if ((i == depth) ||
5787869a4a6STheodore Ts'o 		    path[i].p_idx > EXT_LAST_INDEX(path[i].p_hdr)) {
5797869a4a6STheodore Ts'o 			brelse(path[i].p_bh);
5807869a4a6STheodore Ts'o 			path[i].p_bh = NULL;
5817869a4a6STheodore Ts'o 			i--;
5827869a4a6STheodore Ts'o 			continue;
5837869a4a6STheodore Ts'o 		}
5847869a4a6STheodore Ts'o 		bh = read_extent_tree_block(inode,
5857869a4a6STheodore Ts'o 					    ext4_idx_pblock(path[i].p_idx++),
5867869a4a6STheodore Ts'o 					    depth - i - 1,
5877869a4a6STheodore Ts'o 					    EXT4_EX_FORCE_CACHE);
5887869a4a6STheodore Ts'o 		if (IS_ERR(bh)) {
5897869a4a6STheodore Ts'o 			ret = PTR_ERR(bh);
5907869a4a6STheodore Ts'o 			break;
5917869a4a6STheodore Ts'o 		}
5927869a4a6STheodore Ts'o 		i++;
5937869a4a6STheodore Ts'o 		path[i].p_bh = bh;
5947869a4a6STheodore Ts'o 		path[i].p_hdr = ext_block_hdr(bh);
5957869a4a6STheodore Ts'o 		path[i].p_idx = EXT_FIRST_INDEX(path[i].p_hdr);
5967869a4a6STheodore Ts'o 	}
5977869a4a6STheodore Ts'o 	ext4_set_inode_state(inode, EXT4_STATE_EXT_PRECACHED);
5987869a4a6STheodore Ts'o out:
5997869a4a6STheodore Ts'o 	up_read(&ei->i_data_sem);
6007869a4a6STheodore Ts'o 	ext4_ext_drop_refs(path);
6017869a4a6STheodore Ts'o 	kfree(path);
6027869a4a6STheodore Ts'o 	return ret;
6037869a4a6STheodore Ts'o }
6047869a4a6STheodore Ts'o 
605a86c6181SAlex Tomas #ifdef EXT_DEBUG
606a86c6181SAlex Tomas static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
607a86c6181SAlex Tomas {
608a86c6181SAlex Tomas 	int k, l = path->p_depth;
609a86c6181SAlex Tomas 
610a86c6181SAlex Tomas 	ext_debug("path:");
611a86c6181SAlex Tomas 	for (k = 0; k <= l; k++, path++) {
612a86c6181SAlex Tomas 		if (path->p_idx) {
6136e89bbb7SEric Biggers 			ext_debug("  %d->%llu",
6146e89bbb7SEric Biggers 				  le32_to_cpu(path->p_idx->ei_block),
615bf89d16fSTheodore Ts'o 				  ext4_idx_pblock(path->p_idx));
616a86c6181SAlex Tomas 		} else if (path->p_ext) {
617553f9008SMingming 			ext_debug("  %d:[%d]%d:%llu ",
618a86c6181SAlex Tomas 				  le32_to_cpu(path->p_ext->ee_block),
619556615dcSLukas Czerner 				  ext4_ext_is_unwritten(path->p_ext),
620a2df2a63SAmit Arora 				  ext4_ext_get_actual_len(path->p_ext),
621bf89d16fSTheodore Ts'o 				  ext4_ext_pblock(path->p_ext));
622a86c6181SAlex Tomas 		} else
623a86c6181SAlex Tomas 			ext_debug("  []");
624a86c6181SAlex Tomas 	}
625a86c6181SAlex Tomas 	ext_debug("\n");
626a86c6181SAlex Tomas }
627a86c6181SAlex Tomas 
628a86c6181SAlex Tomas static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
629a86c6181SAlex Tomas {
630a86c6181SAlex Tomas 	int depth = ext_depth(inode);
631a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
632a86c6181SAlex Tomas 	struct ext4_extent *ex;
633a86c6181SAlex Tomas 	int i;
634a86c6181SAlex Tomas 
635a86c6181SAlex Tomas 	if (!path)
636a86c6181SAlex Tomas 		return;
637a86c6181SAlex Tomas 
638a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
639a86c6181SAlex Tomas 	ex = EXT_FIRST_EXTENT(eh);
640a86c6181SAlex Tomas 
641553f9008SMingming 	ext_debug("Displaying leaf extents for inode %lu\n", inode->i_ino);
642553f9008SMingming 
643a86c6181SAlex Tomas 	for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) {
644553f9008SMingming 		ext_debug("%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),
645556615dcSLukas Czerner 			  ext4_ext_is_unwritten(ex),
646bf89d16fSTheodore Ts'o 			  ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex));
647a86c6181SAlex Tomas 	}
648a86c6181SAlex Tomas 	ext_debug("\n");
649a86c6181SAlex Tomas }
6501b16da77SYongqiang Yang 
6511b16da77SYongqiang Yang static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path,
6521b16da77SYongqiang Yang 			ext4_fsblk_t newblock, int level)
6531b16da77SYongqiang Yang {
6541b16da77SYongqiang Yang 	int depth = ext_depth(inode);
6551b16da77SYongqiang Yang 	struct ext4_extent *ex;
6561b16da77SYongqiang Yang 
6571b16da77SYongqiang Yang 	if (depth != level) {
6581b16da77SYongqiang Yang 		struct ext4_extent_idx *idx;
6591b16da77SYongqiang Yang 		idx = path[level].p_idx;
6601b16da77SYongqiang Yang 		while (idx <= EXT_MAX_INDEX(path[level].p_hdr)) {
6611b16da77SYongqiang Yang 			ext_debug("%d: move %d:%llu in new index %llu\n", level,
6621b16da77SYongqiang Yang 					le32_to_cpu(idx->ei_block),
6631b16da77SYongqiang Yang 					ext4_idx_pblock(idx),
6641b16da77SYongqiang Yang 					newblock);
6651b16da77SYongqiang Yang 			idx++;
6661b16da77SYongqiang Yang 		}
6671b16da77SYongqiang Yang 
6681b16da77SYongqiang Yang 		return;
6691b16da77SYongqiang Yang 	}
6701b16da77SYongqiang Yang 
6711b16da77SYongqiang Yang 	ex = path[depth].p_ext;
6721b16da77SYongqiang Yang 	while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) {
6731b16da77SYongqiang Yang 		ext_debug("move %d:%llu:[%d]%d in new leaf %llu\n",
6741b16da77SYongqiang Yang 				le32_to_cpu(ex->ee_block),
6751b16da77SYongqiang Yang 				ext4_ext_pblock(ex),
676556615dcSLukas Czerner 				ext4_ext_is_unwritten(ex),
6771b16da77SYongqiang Yang 				ext4_ext_get_actual_len(ex),
6781b16da77SYongqiang Yang 				newblock);
6791b16da77SYongqiang Yang 		ex++;
6801b16da77SYongqiang Yang 	}
6811b16da77SYongqiang Yang }
6821b16da77SYongqiang Yang 
683a86c6181SAlex Tomas #else
684a86c6181SAlex Tomas #define ext4_ext_show_path(inode, path)
685a86c6181SAlex Tomas #define ext4_ext_show_leaf(inode, path)
6861b16da77SYongqiang Yang #define ext4_ext_show_move(inode, path, newblock, level)
687a86c6181SAlex Tomas #endif
688a86c6181SAlex Tomas 
689b35905c1SAneesh Kumar K.V void ext4_ext_drop_refs(struct ext4_ext_path *path)
690a86c6181SAlex Tomas {
691b7ea89adSTheodore Ts'o 	int depth, i;
692a86c6181SAlex Tomas 
693b7ea89adSTheodore Ts'o 	if (!path)
694b7ea89adSTheodore Ts'o 		return;
695b7ea89adSTheodore Ts'o 	depth = path->p_depth;
696de745485SEric Biggers 	for (i = 0; i <= depth; i++, path++) {
697a86c6181SAlex Tomas 		if (path->p_bh) {
698a86c6181SAlex Tomas 			brelse(path->p_bh);
699a86c6181SAlex Tomas 			path->p_bh = NULL;
700a86c6181SAlex Tomas 		}
701a86c6181SAlex Tomas 	}
702de745485SEric Biggers }
703a86c6181SAlex Tomas 
704a86c6181SAlex Tomas /*
705d0d856e8SRandy Dunlap  * ext4_ext_binsearch_idx:
706d0d856e8SRandy Dunlap  * binary search for the closest index of the given block
707c29c0ae7SAlex Tomas  * the header must be checked before calling this
708a86c6181SAlex Tomas  */
709a86c6181SAlex Tomas static void
710725d26d3SAneesh Kumar K.V ext4_ext_binsearch_idx(struct inode *inode,
711725d26d3SAneesh Kumar K.V 			struct ext4_ext_path *path, ext4_lblk_t block)
712a86c6181SAlex Tomas {
713a86c6181SAlex Tomas 	struct ext4_extent_header *eh = path->p_hdr;
714a86c6181SAlex Tomas 	struct ext4_extent_idx *r, *l, *m;
715a86c6181SAlex Tomas 
716a86c6181SAlex Tomas 
717bba90743SEric Sandeen 	ext_debug("binsearch for %u(idx):  ", block);
718a86c6181SAlex Tomas 
719a86c6181SAlex Tomas 	l = EXT_FIRST_INDEX(eh) + 1;
720e9f410b1SDmitry Monakhov 	r = EXT_LAST_INDEX(eh);
721a86c6181SAlex Tomas 	while (l <= r) {
722a86c6181SAlex Tomas 		m = l + (r - l) / 2;
723a86c6181SAlex Tomas 		if (block < le32_to_cpu(m->ei_block))
724a86c6181SAlex Tomas 			r = m - 1;
725a86c6181SAlex Tomas 		else
726a86c6181SAlex Tomas 			l = m + 1;
72726d535edSDmitry Monakhov 		ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ei_block),
72826d535edSDmitry Monakhov 				m, le32_to_cpu(m->ei_block),
72926d535edSDmitry Monakhov 				r, le32_to_cpu(r->ei_block));
730a86c6181SAlex Tomas 	}
731a86c6181SAlex Tomas 
732a86c6181SAlex Tomas 	path->p_idx = l - 1;
7334a3c3a51SZheng Liu 	ext_debug("  -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block),
734bf89d16fSTheodore Ts'o 		  ext4_idx_pblock(path->p_idx));
735a86c6181SAlex Tomas 
736a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH
737a86c6181SAlex Tomas 	{
738a86c6181SAlex Tomas 		struct ext4_extent_idx *chix, *ix;
739a86c6181SAlex Tomas 		int k;
740a86c6181SAlex Tomas 
741a86c6181SAlex Tomas 		chix = ix = EXT_FIRST_INDEX(eh);
742a86c6181SAlex Tomas 		for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {
7436e89bbb7SEric Biggers 			if (k != 0 && le32_to_cpu(ix->ei_block) <=
7446e89bbb7SEric Biggers 			    le32_to_cpu(ix[-1].ei_block)) {
7454776004fSTheodore Ts'o 				printk(KERN_DEBUG "k=%d, ix=0x%p, "
7464776004fSTheodore Ts'o 				       "first=0x%p\n", k,
747a86c6181SAlex Tomas 				       ix, EXT_FIRST_INDEX(eh));
7484776004fSTheodore Ts'o 				printk(KERN_DEBUG "%u <= %u\n",
749a86c6181SAlex Tomas 				       le32_to_cpu(ix->ei_block),
750a86c6181SAlex Tomas 				       le32_to_cpu(ix[-1].ei_block));
751a86c6181SAlex Tomas 			}
752a86c6181SAlex Tomas 			BUG_ON(k && le32_to_cpu(ix->ei_block)
753a86c6181SAlex Tomas 					   <= le32_to_cpu(ix[-1].ei_block));
754a86c6181SAlex Tomas 			if (block < le32_to_cpu(ix->ei_block))
755a86c6181SAlex Tomas 				break;
756a86c6181SAlex Tomas 			chix = ix;
757a86c6181SAlex Tomas 		}
758a86c6181SAlex Tomas 		BUG_ON(chix != path->p_idx);
759a86c6181SAlex Tomas 	}
760a86c6181SAlex Tomas #endif
761a86c6181SAlex Tomas 
762a86c6181SAlex Tomas }
763a86c6181SAlex Tomas 
764a86c6181SAlex Tomas /*
765d0d856e8SRandy Dunlap  * ext4_ext_binsearch:
766d0d856e8SRandy Dunlap  * binary search for closest extent of the given block
767c29c0ae7SAlex Tomas  * the header must be checked before calling this
768a86c6181SAlex Tomas  */
769a86c6181SAlex Tomas static void
770725d26d3SAneesh Kumar K.V ext4_ext_binsearch(struct inode *inode,
771725d26d3SAneesh Kumar K.V 		struct ext4_ext_path *path, ext4_lblk_t block)
772a86c6181SAlex Tomas {
773a86c6181SAlex Tomas 	struct ext4_extent_header *eh = path->p_hdr;
774a86c6181SAlex Tomas 	struct ext4_extent *r, *l, *m;
775a86c6181SAlex Tomas 
776a86c6181SAlex Tomas 	if (eh->eh_entries == 0) {
777a86c6181SAlex Tomas 		/*
778d0d856e8SRandy Dunlap 		 * this leaf is empty:
779a86c6181SAlex Tomas 		 * we get such a leaf in split/add case
780a86c6181SAlex Tomas 		 */
781a86c6181SAlex Tomas 		return;
782a86c6181SAlex Tomas 	}
783a86c6181SAlex Tomas 
784bba90743SEric Sandeen 	ext_debug("binsearch for %u:  ", block);
785a86c6181SAlex Tomas 
786a86c6181SAlex Tomas 	l = EXT_FIRST_EXTENT(eh) + 1;
787e9f410b1SDmitry Monakhov 	r = EXT_LAST_EXTENT(eh);
788a86c6181SAlex Tomas 
789a86c6181SAlex Tomas 	while (l <= r) {
790a86c6181SAlex Tomas 		m = l + (r - l) / 2;
791a86c6181SAlex Tomas 		if (block < le32_to_cpu(m->ee_block))
792a86c6181SAlex Tomas 			r = m - 1;
793a86c6181SAlex Tomas 		else
794a86c6181SAlex Tomas 			l = m + 1;
79526d535edSDmitry Monakhov 		ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ee_block),
79626d535edSDmitry Monakhov 				m, le32_to_cpu(m->ee_block),
79726d535edSDmitry Monakhov 				r, le32_to_cpu(r->ee_block));
798a86c6181SAlex Tomas 	}
799a86c6181SAlex Tomas 
800a86c6181SAlex Tomas 	path->p_ext = l - 1;
801553f9008SMingming 	ext_debug("  -> %d:%llu:[%d]%d ",
802a86c6181SAlex Tomas 			le32_to_cpu(path->p_ext->ee_block),
803bf89d16fSTheodore Ts'o 			ext4_ext_pblock(path->p_ext),
804556615dcSLukas Czerner 			ext4_ext_is_unwritten(path->p_ext),
805a2df2a63SAmit Arora 			ext4_ext_get_actual_len(path->p_ext));
806a86c6181SAlex Tomas 
807a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH
808a86c6181SAlex Tomas 	{
809a86c6181SAlex Tomas 		struct ext4_extent *chex, *ex;
810a86c6181SAlex Tomas 		int k;
811a86c6181SAlex Tomas 
812a86c6181SAlex Tomas 		chex = ex = EXT_FIRST_EXTENT(eh);
813a86c6181SAlex Tomas 		for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) {
814a86c6181SAlex Tomas 			BUG_ON(k && le32_to_cpu(ex->ee_block)
815a86c6181SAlex Tomas 					  <= le32_to_cpu(ex[-1].ee_block));
816a86c6181SAlex Tomas 			if (block < le32_to_cpu(ex->ee_block))
817a86c6181SAlex Tomas 				break;
818a86c6181SAlex Tomas 			chex = ex;
819a86c6181SAlex Tomas 		}
820a86c6181SAlex Tomas 		BUG_ON(chex != path->p_ext);
821a86c6181SAlex Tomas 	}
822a86c6181SAlex Tomas #endif
823a86c6181SAlex Tomas 
824a86c6181SAlex Tomas }
825a86c6181SAlex Tomas 
8264209ae12SHarshad Shirwadkar void ext4_ext_tree_init(handle_t *handle, struct inode *inode)
827a86c6181SAlex Tomas {
828a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
829a86c6181SAlex Tomas 
830a86c6181SAlex Tomas 	eh = ext_inode_hdr(inode);
831a86c6181SAlex Tomas 	eh->eh_depth = 0;
832a86c6181SAlex Tomas 	eh->eh_entries = 0;
833a86c6181SAlex Tomas 	eh->eh_magic = EXT4_EXT_MAGIC;
83455ad63bfSTheodore Ts'o 	eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
835a86c6181SAlex Tomas 	ext4_mark_inode_dirty(handle, inode);
836a86c6181SAlex Tomas }
837a86c6181SAlex Tomas 
838a86c6181SAlex Tomas struct ext4_ext_path *
839ed8a1a76STheodore Ts'o ext4_find_extent(struct inode *inode, ext4_lblk_t block,
840705912caSTheodore Ts'o 		 struct ext4_ext_path **orig_path, int flags)
841a86c6181SAlex Tomas {
842a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
843a86c6181SAlex Tomas 	struct buffer_head *bh;
844705912caSTheodore Ts'o 	struct ext4_ext_path *path = orig_path ? *orig_path : NULL;
845705912caSTheodore Ts'o 	short int depth, i, ppos = 0;
846860d21e2STheodore Ts'o 	int ret;
84773c384c0STheodore Ts'o 	gfp_t gfp_flags = GFP_NOFS;
84873c384c0STheodore Ts'o 
84973c384c0STheodore Ts'o 	if (flags & EXT4_EX_NOFAIL)
85073c384c0STheodore Ts'o 		gfp_flags |= __GFP_NOFAIL;
851a86c6181SAlex Tomas 
852a86c6181SAlex Tomas 	eh = ext_inode_hdr(inode);
853c29c0ae7SAlex Tomas 	depth = ext_depth(inode);
854bc890a60STheodore Ts'o 	if (depth < 0 || depth > EXT4_MAX_EXTENT_DEPTH) {
855bc890a60STheodore Ts'o 		EXT4_ERROR_INODE(inode, "inode has invalid extent depth: %d",
856bc890a60STheodore Ts'o 				 depth);
857bc890a60STheodore Ts'o 		ret = -EFSCORRUPTED;
858bc890a60STheodore Ts'o 		goto err;
859bc890a60STheodore Ts'o 	}
860a86c6181SAlex Tomas 
86110809df8STheodore Ts'o 	if (path) {
862523f431cSTheodore Ts'o 		ext4_ext_drop_refs(path);
86310809df8STheodore Ts'o 		if (depth > path[0].p_maxdepth) {
86410809df8STheodore Ts'o 			kfree(path);
86510809df8STheodore Ts'o 			*orig_path = path = NULL;
86610809df8STheodore Ts'o 		}
86710809df8STheodore Ts'o 	}
86810809df8STheodore Ts'o 	if (!path) {
869a86c6181SAlex Tomas 		/* account possible depth increase */
8706396bb22SKees Cook 		path = kcalloc(depth + 2, sizeof(struct ext4_ext_path),
87173c384c0STheodore Ts'o 				gfp_flags);
87219008f6dSTheodore Ts'o 		if (unlikely(!path))
873a86c6181SAlex Tomas 			return ERR_PTR(-ENOMEM);
87410809df8STheodore Ts'o 		path[0].p_maxdepth = depth + 1;
875a86c6181SAlex Tomas 	}
876a86c6181SAlex Tomas 	path[0].p_hdr = eh;
8771973adcbSShen Feng 	path[0].p_bh = NULL;
878a86c6181SAlex Tomas 
879c29c0ae7SAlex Tomas 	i = depth;
8804068664eSDmitry Monakhov 	if (!(flags & EXT4_EX_NOCACHE) && depth == 0)
8814068664eSDmitry Monakhov 		ext4_cache_extents(inode, eh);
882a86c6181SAlex Tomas 	/* walk through the tree */
883a86c6181SAlex Tomas 	while (i) {
884a86c6181SAlex Tomas 		ext_debug("depth %d: num %d, max %d\n",
885a86c6181SAlex Tomas 			  ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
886c29c0ae7SAlex Tomas 
887a86c6181SAlex Tomas 		ext4_ext_binsearch_idx(inode, path + ppos, block);
888bf89d16fSTheodore Ts'o 		path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx);
889a86c6181SAlex Tomas 		path[ppos].p_depth = i;
890a86c6181SAlex Tomas 		path[ppos].p_ext = NULL;
891a86c6181SAlex Tomas 
892107a7bd3STheodore Ts'o 		bh = read_extent_tree_block(inode, path[ppos].p_block, --i,
893107a7bd3STheodore Ts'o 					    flags);
894a1c83681SViresh Kumar 		if (IS_ERR(bh)) {
8957d7ea89eSTheodore Ts'o 			ret = PTR_ERR(bh);
896a86c6181SAlex Tomas 			goto err;
897860d21e2STheodore Ts'o 		}
8987d7ea89eSTheodore Ts'o 
899a86c6181SAlex Tomas 		eh = ext_block_hdr(bh);
900a86c6181SAlex Tomas 		ppos++;
901a86c6181SAlex Tomas 		path[ppos].p_bh = bh;
902a86c6181SAlex Tomas 		path[ppos].p_hdr = eh;
903a86c6181SAlex Tomas 	}
904a86c6181SAlex Tomas 
905a86c6181SAlex Tomas 	path[ppos].p_depth = i;
906a86c6181SAlex Tomas 	path[ppos].p_ext = NULL;
907a86c6181SAlex Tomas 	path[ppos].p_idx = NULL;
908a86c6181SAlex Tomas 
909a86c6181SAlex Tomas 	/* find extent */
910a86c6181SAlex Tomas 	ext4_ext_binsearch(inode, path + ppos, block);
9111973adcbSShen Feng 	/* if not an empty leaf */
9121973adcbSShen Feng 	if (path[ppos].p_ext)
913bf89d16fSTheodore Ts'o 		path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext);
914a86c6181SAlex Tomas 
915a86c6181SAlex Tomas 	ext4_ext_show_path(inode, path);
916a86c6181SAlex Tomas 
917a86c6181SAlex Tomas 	return path;
918a86c6181SAlex Tomas 
919a86c6181SAlex Tomas err:
920a86c6181SAlex Tomas 	ext4_ext_drop_refs(path);
921a86c6181SAlex Tomas 	kfree(path);
922705912caSTheodore Ts'o 	if (orig_path)
923705912caSTheodore Ts'o 		*orig_path = NULL;
924860d21e2STheodore Ts'o 	return ERR_PTR(ret);
925a86c6181SAlex Tomas }
926a86c6181SAlex Tomas 
927a86c6181SAlex Tomas /*
928d0d856e8SRandy Dunlap  * ext4_ext_insert_index:
929d0d856e8SRandy Dunlap  * insert new index [@logical;@ptr] into the block at @curp;
930d0d856e8SRandy Dunlap  * check where to insert: before @curp or after @curp
931a86c6181SAlex Tomas  */
9321f109d5aSTheodore Ts'o static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
933a86c6181SAlex Tomas 				 struct ext4_ext_path *curp,
934f65e6fbaSAlex Tomas 				 int logical, ext4_fsblk_t ptr)
935a86c6181SAlex Tomas {
936a86c6181SAlex Tomas 	struct ext4_extent_idx *ix;
937a86c6181SAlex Tomas 	int len, err;
938a86c6181SAlex Tomas 
9397e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, curp);
9407e028976SAvantika Mathur 	if (err)
941a86c6181SAlex Tomas 		return err;
942a86c6181SAlex Tomas 
943273df556SFrank Mayhar 	if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) {
944273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
945273df556SFrank Mayhar 				 "logical %d == ei_block %d!",
946273df556SFrank Mayhar 				 logical, le32_to_cpu(curp->p_idx->ei_block));
9476a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
948273df556SFrank Mayhar 	}
949d4620315SRobin Dong 
950d4620315SRobin Dong 	if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries)
951d4620315SRobin Dong 			     >= le16_to_cpu(curp->p_hdr->eh_max))) {
952d4620315SRobin Dong 		EXT4_ERROR_INODE(inode,
953d4620315SRobin Dong 				 "eh_entries %d >= eh_max %d!",
954d4620315SRobin Dong 				 le16_to_cpu(curp->p_hdr->eh_entries),
955d4620315SRobin Dong 				 le16_to_cpu(curp->p_hdr->eh_max));
9566a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
957d4620315SRobin Dong 	}
958d4620315SRobin Dong 
959a86c6181SAlex Tomas 	if (logical > le32_to_cpu(curp->p_idx->ei_block)) {
960a86c6181SAlex Tomas 		/* insert after */
96180e675f9SEric Gouriou 		ext_debug("insert new index %d after: %llu\n", logical, ptr);
962a86c6181SAlex Tomas 		ix = curp->p_idx + 1;
963a86c6181SAlex Tomas 	} else {
964a86c6181SAlex Tomas 		/* insert before */
96580e675f9SEric Gouriou 		ext_debug("insert new index %d before: %llu\n", logical, ptr);
966a86c6181SAlex Tomas 		ix = curp->p_idx;
967a86c6181SAlex Tomas 	}
968a86c6181SAlex Tomas 
96980e675f9SEric Gouriou 	len = EXT_LAST_INDEX(curp->p_hdr) - ix + 1;
97080e675f9SEric Gouriou 	BUG_ON(len < 0);
97180e675f9SEric Gouriou 	if (len > 0) {
97280e675f9SEric Gouriou 		ext_debug("insert new index %d: "
97380e675f9SEric Gouriou 				"move %d indices from 0x%p to 0x%p\n",
97480e675f9SEric Gouriou 				logical, len, ix, ix + 1);
97580e675f9SEric Gouriou 		memmove(ix + 1, ix, len * sizeof(struct ext4_extent_idx));
97680e675f9SEric Gouriou 	}
97780e675f9SEric Gouriou 
978f472e026STao Ma 	if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) {
979f472e026STao Ma 		EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!");
9806a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
981f472e026STao Ma 	}
982f472e026STao Ma 
983a86c6181SAlex Tomas 	ix->ei_block = cpu_to_le32(logical);
984f65e6fbaSAlex Tomas 	ext4_idx_store_pblock(ix, ptr);
985e8546d06SMarcin Slusarz 	le16_add_cpu(&curp->p_hdr->eh_entries, 1);
986a86c6181SAlex Tomas 
987273df556SFrank Mayhar 	if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) {
988273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
9896a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
990273df556SFrank Mayhar 	}
991a86c6181SAlex Tomas 
992a86c6181SAlex Tomas 	err = ext4_ext_dirty(handle, inode, curp);
993a86c6181SAlex Tomas 	ext4_std_error(inode->i_sb, err);
994a86c6181SAlex Tomas 
995a86c6181SAlex Tomas 	return err;
996a86c6181SAlex Tomas }
997a86c6181SAlex Tomas 
998a86c6181SAlex Tomas /*
999d0d856e8SRandy Dunlap  * ext4_ext_split:
1000d0d856e8SRandy Dunlap  * inserts new subtree into the path, using free index entry
1001d0d856e8SRandy Dunlap  * at depth @at:
1002a86c6181SAlex Tomas  * - allocates all needed blocks (new leaf and all intermediate index blocks)
1003a86c6181SAlex Tomas  * - makes decision where to split
1004d0d856e8SRandy Dunlap  * - moves remaining extents and index entries (right to the split point)
1005a86c6181SAlex Tomas  *   into the newly allocated blocks
1006d0d856e8SRandy Dunlap  * - initializes subtree
1007a86c6181SAlex Tomas  */
1008a86c6181SAlex Tomas static int ext4_ext_split(handle_t *handle, struct inode *inode,
100955f020dbSAllison Henderson 			  unsigned int flags,
1010a86c6181SAlex Tomas 			  struct ext4_ext_path *path,
1011a86c6181SAlex Tomas 			  struct ext4_extent *newext, int at)
1012a86c6181SAlex Tomas {
1013a86c6181SAlex Tomas 	struct buffer_head *bh = NULL;
1014a86c6181SAlex Tomas 	int depth = ext_depth(inode);
1015a86c6181SAlex Tomas 	struct ext4_extent_header *neh;
1016a86c6181SAlex Tomas 	struct ext4_extent_idx *fidx;
1017a86c6181SAlex Tomas 	int i = at, k, m, a;
1018f65e6fbaSAlex Tomas 	ext4_fsblk_t newblock, oldblock;
1019a86c6181SAlex Tomas 	__le32 border;
1020f65e6fbaSAlex Tomas 	ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
102173c384c0STheodore Ts'o 	gfp_t gfp_flags = GFP_NOFS;
1022a86c6181SAlex Tomas 	int err = 0;
1023592acbf1SSriram Rajagopalan 	size_t ext_size = 0;
1024a86c6181SAlex Tomas 
102573c384c0STheodore Ts'o 	if (flags & EXT4_EX_NOFAIL)
102673c384c0STheodore Ts'o 		gfp_flags |= __GFP_NOFAIL;
102773c384c0STheodore Ts'o 
1028a86c6181SAlex Tomas 	/* make decision: where to split? */
1029d0d856e8SRandy Dunlap 	/* FIXME: now decision is simplest: at current extent */
1030a86c6181SAlex Tomas 
1031d0d856e8SRandy Dunlap 	/* if current leaf will be split, then we should use
1032a86c6181SAlex Tomas 	 * border from split point */
1033273df556SFrank Mayhar 	if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {
1034273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
10356a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1036273df556SFrank Mayhar 	}
1037a86c6181SAlex Tomas 	if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
1038a86c6181SAlex Tomas 		border = path[depth].p_ext[1].ee_block;
1039d0d856e8SRandy Dunlap 		ext_debug("leaf will be split."
1040a86c6181SAlex Tomas 				" next leaf starts at %d\n",
1041a86c6181SAlex Tomas 				  le32_to_cpu(border));
1042a86c6181SAlex Tomas 	} else {
1043a86c6181SAlex Tomas 		border = newext->ee_block;
1044a86c6181SAlex Tomas 		ext_debug("leaf will be added."
1045a86c6181SAlex Tomas 				" next leaf starts at %d\n",
1046a86c6181SAlex Tomas 				le32_to_cpu(border));
1047a86c6181SAlex Tomas 	}
1048a86c6181SAlex Tomas 
1049a86c6181SAlex Tomas 	/*
1050d0d856e8SRandy Dunlap 	 * If error occurs, then we break processing
1051d0d856e8SRandy Dunlap 	 * and mark filesystem read-only. index won't
1052a86c6181SAlex Tomas 	 * be inserted and tree will be in consistent
1053d0d856e8SRandy Dunlap 	 * state. Next mount will repair buffers too.
1054a86c6181SAlex Tomas 	 */
1055a86c6181SAlex Tomas 
1056a86c6181SAlex Tomas 	/*
1057d0d856e8SRandy Dunlap 	 * Get array to track all allocated blocks.
1058d0d856e8SRandy Dunlap 	 * We need this to handle errors and free blocks
1059d0d856e8SRandy Dunlap 	 * upon them.
1060a86c6181SAlex Tomas 	 */
106173c384c0STheodore Ts'o 	ablocks = kcalloc(depth, sizeof(ext4_fsblk_t), gfp_flags);
1062a86c6181SAlex Tomas 	if (!ablocks)
1063a86c6181SAlex Tomas 		return -ENOMEM;
1064a86c6181SAlex Tomas 
1065a86c6181SAlex Tomas 	/* allocate all needed blocks */
1066a86c6181SAlex Tomas 	ext_debug("allocate %d blocks for indexes/leaf\n", depth - at);
1067a86c6181SAlex Tomas 	for (a = 0; a < depth - at; a++) {
1068654b4908SAneesh Kumar K.V 		newblock = ext4_ext_new_meta_block(handle, inode, path,
106955f020dbSAllison Henderson 						   newext, &err, flags);
1070a86c6181SAlex Tomas 		if (newblock == 0)
1071a86c6181SAlex Tomas 			goto cleanup;
1072a86c6181SAlex Tomas 		ablocks[a] = newblock;
1073a86c6181SAlex Tomas 	}
1074a86c6181SAlex Tomas 
1075a86c6181SAlex Tomas 	/* initialize new leaf */
1076a86c6181SAlex Tomas 	newblock = ablocks[--a];
1077273df556SFrank Mayhar 	if (unlikely(newblock == 0)) {
1078273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "newblock == 0!");
10796a797d27SDarrick J. Wong 		err = -EFSCORRUPTED;
1080273df556SFrank Mayhar 		goto cleanup;
1081273df556SFrank Mayhar 	}
1082c45653c3SNikolay Borisov 	bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1083aebf0243SWang Shilong 	if (unlikely(!bh)) {
1084860d21e2STheodore Ts'o 		err = -ENOMEM;
1085a86c6181SAlex Tomas 		goto cleanup;
1086a86c6181SAlex Tomas 	}
1087a86c6181SAlex Tomas 	lock_buffer(bh);
1088a86c6181SAlex Tomas 
10897e028976SAvantika Mathur 	err = ext4_journal_get_create_access(handle, bh);
10907e028976SAvantika Mathur 	if (err)
1091a86c6181SAlex Tomas 		goto cleanup;
1092a86c6181SAlex Tomas 
1093a86c6181SAlex Tomas 	neh = ext_block_hdr(bh);
1094a86c6181SAlex Tomas 	neh->eh_entries = 0;
109555ad63bfSTheodore Ts'o 	neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1096a86c6181SAlex Tomas 	neh->eh_magic = EXT4_EXT_MAGIC;
1097a86c6181SAlex Tomas 	neh->eh_depth = 0;
1098a86c6181SAlex Tomas 
1099d0d856e8SRandy Dunlap 	/* move remainder of path[depth] to the new leaf */
1100273df556SFrank Mayhar 	if (unlikely(path[depth].p_hdr->eh_entries !=
1101273df556SFrank Mayhar 		     path[depth].p_hdr->eh_max)) {
1102273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
1103273df556SFrank Mayhar 				 path[depth].p_hdr->eh_entries,
1104273df556SFrank Mayhar 				 path[depth].p_hdr->eh_max);
11056a797d27SDarrick J. Wong 		err = -EFSCORRUPTED;
1106273df556SFrank Mayhar 		goto cleanup;
1107273df556SFrank Mayhar 	}
1108a86c6181SAlex Tomas 	/* start copy from next extent */
11091b16da77SYongqiang Yang 	m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++;
11101b16da77SYongqiang Yang 	ext4_ext_show_move(inode, path, newblock, depth);
1111a86c6181SAlex Tomas 	if (m) {
11121b16da77SYongqiang Yang 		struct ext4_extent *ex;
11131b16da77SYongqiang Yang 		ex = EXT_FIRST_EXTENT(neh);
11141b16da77SYongqiang Yang 		memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m);
1115e8546d06SMarcin Slusarz 		le16_add_cpu(&neh->eh_entries, m);
1116a86c6181SAlex Tomas 	}
1117a86c6181SAlex Tomas 
1118592acbf1SSriram Rajagopalan 	/* zero out unused area in the extent block */
1119592acbf1SSriram Rajagopalan 	ext_size = sizeof(struct ext4_extent_header) +
1120592acbf1SSriram Rajagopalan 		sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries);
1121592acbf1SSriram Rajagopalan 	memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
11227ac5990dSDarrick J. Wong 	ext4_extent_block_csum_set(inode, neh);
1123a86c6181SAlex Tomas 	set_buffer_uptodate(bh);
1124a86c6181SAlex Tomas 	unlock_buffer(bh);
1125a86c6181SAlex Tomas 
11260390131bSFrank Mayhar 	err = ext4_handle_dirty_metadata(handle, inode, bh);
11277e028976SAvantika Mathur 	if (err)
1128a86c6181SAlex Tomas 		goto cleanup;
1129a86c6181SAlex Tomas 	brelse(bh);
1130a86c6181SAlex Tomas 	bh = NULL;
1131a86c6181SAlex Tomas 
1132a86c6181SAlex Tomas 	/* correct old leaf */
1133a86c6181SAlex Tomas 	if (m) {
11347e028976SAvantika Mathur 		err = ext4_ext_get_access(handle, inode, path + depth);
11357e028976SAvantika Mathur 		if (err)
1136a86c6181SAlex Tomas 			goto cleanup;
1137e8546d06SMarcin Slusarz 		le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);
11387e028976SAvantika Mathur 		err = ext4_ext_dirty(handle, inode, path + depth);
11397e028976SAvantika Mathur 		if (err)
1140a86c6181SAlex Tomas 			goto cleanup;
1141a86c6181SAlex Tomas 
1142a86c6181SAlex Tomas 	}
1143a86c6181SAlex Tomas 
1144a86c6181SAlex Tomas 	/* create intermediate indexes */
1145a86c6181SAlex Tomas 	k = depth - at - 1;
1146273df556SFrank Mayhar 	if (unlikely(k < 0)) {
1147273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "k %d < 0!", k);
11486a797d27SDarrick J. Wong 		err = -EFSCORRUPTED;
1149273df556SFrank Mayhar 		goto cleanup;
1150273df556SFrank Mayhar 	}
1151a86c6181SAlex Tomas 	if (k)
1152a86c6181SAlex Tomas 		ext_debug("create %d intermediate indices\n", k);
1153a86c6181SAlex Tomas 	/* insert new index into current index block */
1154a86c6181SAlex Tomas 	/* current depth stored in i var */
1155a86c6181SAlex Tomas 	i = depth - 1;
1156a86c6181SAlex Tomas 	while (k--) {
1157a86c6181SAlex Tomas 		oldblock = newblock;
1158a86c6181SAlex Tomas 		newblock = ablocks[--a];
1159bba90743SEric Sandeen 		bh = sb_getblk(inode->i_sb, newblock);
1160aebf0243SWang Shilong 		if (unlikely(!bh)) {
1161860d21e2STheodore Ts'o 			err = -ENOMEM;
1162a86c6181SAlex Tomas 			goto cleanup;
1163a86c6181SAlex Tomas 		}
1164a86c6181SAlex Tomas 		lock_buffer(bh);
1165a86c6181SAlex Tomas 
11667e028976SAvantika Mathur 		err = ext4_journal_get_create_access(handle, bh);
11677e028976SAvantika Mathur 		if (err)
1168a86c6181SAlex Tomas 			goto cleanup;
1169a86c6181SAlex Tomas 
1170a86c6181SAlex Tomas 		neh = ext_block_hdr(bh);
1171a86c6181SAlex Tomas 		neh->eh_entries = cpu_to_le16(1);
1172a86c6181SAlex Tomas 		neh->eh_magic = EXT4_EXT_MAGIC;
117355ad63bfSTheodore Ts'o 		neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1174a86c6181SAlex Tomas 		neh->eh_depth = cpu_to_le16(depth - i);
1175a86c6181SAlex Tomas 		fidx = EXT_FIRST_INDEX(neh);
1176a86c6181SAlex Tomas 		fidx->ei_block = border;
1177f65e6fbaSAlex Tomas 		ext4_idx_store_pblock(fidx, oldblock);
1178a86c6181SAlex Tomas 
1179bba90743SEric Sandeen 		ext_debug("int.index at %d (block %llu): %u -> %llu\n",
1180bba90743SEric Sandeen 				i, newblock, le32_to_cpu(border), oldblock);
1181a86c6181SAlex Tomas 
11821b16da77SYongqiang Yang 		/* move remainder of path[i] to the new index block */
1183273df556SFrank Mayhar 		if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) !=
1184273df556SFrank Mayhar 					EXT_LAST_INDEX(path[i].p_hdr))) {
1185273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
1186273df556SFrank Mayhar 					 "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!",
1187273df556SFrank Mayhar 					 le32_to_cpu(path[i].p_ext->ee_block));
11886a797d27SDarrick J. Wong 			err = -EFSCORRUPTED;
1189273df556SFrank Mayhar 			goto cleanup;
1190273df556SFrank Mayhar 		}
11911b16da77SYongqiang Yang 		/* start copy indexes */
11921b16da77SYongqiang Yang 		m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++;
11931b16da77SYongqiang Yang 		ext_debug("cur 0x%p, last 0x%p\n", path[i].p_idx,
11941b16da77SYongqiang Yang 				EXT_MAX_INDEX(path[i].p_hdr));
11951b16da77SYongqiang Yang 		ext4_ext_show_move(inode, path, newblock, i);
1196a86c6181SAlex Tomas 		if (m) {
11971b16da77SYongqiang Yang 			memmove(++fidx, path[i].p_idx,
1198a86c6181SAlex Tomas 				sizeof(struct ext4_extent_idx) * m);
1199e8546d06SMarcin Slusarz 			le16_add_cpu(&neh->eh_entries, m);
1200a86c6181SAlex Tomas 		}
1201592acbf1SSriram Rajagopalan 		/* zero out unused area in the extent block */
1202592acbf1SSriram Rajagopalan 		ext_size = sizeof(struct ext4_extent_header) +
1203592acbf1SSriram Rajagopalan 		   (sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries));
1204592acbf1SSriram Rajagopalan 		memset(bh->b_data + ext_size, 0,
1205592acbf1SSriram Rajagopalan 			inode->i_sb->s_blocksize - ext_size);
12067ac5990dSDarrick J. Wong 		ext4_extent_block_csum_set(inode, neh);
1207a86c6181SAlex Tomas 		set_buffer_uptodate(bh);
1208a86c6181SAlex Tomas 		unlock_buffer(bh);
1209a86c6181SAlex Tomas 
12100390131bSFrank Mayhar 		err = ext4_handle_dirty_metadata(handle, inode, bh);
12117e028976SAvantika Mathur 		if (err)
1212a86c6181SAlex Tomas 			goto cleanup;
1213a86c6181SAlex Tomas 		brelse(bh);
1214a86c6181SAlex Tomas 		bh = NULL;
1215a86c6181SAlex Tomas 
1216a86c6181SAlex Tomas 		/* correct old index */
1217a86c6181SAlex Tomas 		if (m) {
1218a86c6181SAlex Tomas 			err = ext4_ext_get_access(handle, inode, path + i);
1219a86c6181SAlex Tomas 			if (err)
1220a86c6181SAlex Tomas 				goto cleanup;
1221e8546d06SMarcin Slusarz 			le16_add_cpu(&path[i].p_hdr->eh_entries, -m);
1222a86c6181SAlex Tomas 			err = ext4_ext_dirty(handle, inode, path + i);
1223a86c6181SAlex Tomas 			if (err)
1224a86c6181SAlex Tomas 				goto cleanup;
1225a86c6181SAlex Tomas 		}
1226a86c6181SAlex Tomas 
1227a86c6181SAlex Tomas 		i--;
1228a86c6181SAlex Tomas 	}
1229a86c6181SAlex Tomas 
1230a86c6181SAlex Tomas 	/* insert new index */
1231a86c6181SAlex Tomas 	err = ext4_ext_insert_index(handle, inode, path + at,
1232a86c6181SAlex Tomas 				    le32_to_cpu(border), newblock);
1233a86c6181SAlex Tomas 
1234a86c6181SAlex Tomas cleanup:
1235a86c6181SAlex Tomas 	if (bh) {
1236a86c6181SAlex Tomas 		if (buffer_locked(bh))
1237a86c6181SAlex Tomas 			unlock_buffer(bh);
1238a86c6181SAlex Tomas 		brelse(bh);
1239a86c6181SAlex Tomas 	}
1240a86c6181SAlex Tomas 
1241a86c6181SAlex Tomas 	if (err) {
1242a86c6181SAlex Tomas 		/* free all allocated blocks in error case */
1243a86c6181SAlex Tomas 		for (i = 0; i < depth; i++) {
1244a86c6181SAlex Tomas 			if (!ablocks[i])
1245a86c6181SAlex Tomas 				continue;
12467dc57615SPeter Huewe 			ext4_free_blocks(handle, inode, NULL, ablocks[i], 1,
1247e6362609STheodore Ts'o 					 EXT4_FREE_BLOCKS_METADATA);
1248a86c6181SAlex Tomas 		}
1249a86c6181SAlex Tomas 	}
1250a86c6181SAlex Tomas 	kfree(ablocks);
1251a86c6181SAlex Tomas 
1252a86c6181SAlex Tomas 	return err;
1253a86c6181SAlex Tomas }
1254a86c6181SAlex Tomas 
1255a86c6181SAlex Tomas /*
1256d0d856e8SRandy Dunlap  * ext4_ext_grow_indepth:
1257d0d856e8SRandy Dunlap  * implements tree growing procedure:
1258a86c6181SAlex Tomas  * - allocates new block
1259a86c6181SAlex Tomas  * - moves top-level data (index block or leaf) into the new block
1260d0d856e8SRandy Dunlap  * - initializes new top-level, creating index that points to the
1261a86c6181SAlex Tomas  *   just created block
1262a86c6181SAlex Tomas  */
1263a86c6181SAlex Tomas static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
1264be5cd90dSDmitry Monakhov 				 unsigned int flags)
1265a86c6181SAlex Tomas {
1266a86c6181SAlex Tomas 	struct ext4_extent_header *neh;
1267a86c6181SAlex Tomas 	struct buffer_head *bh;
1268be5cd90dSDmitry Monakhov 	ext4_fsblk_t newblock, goal = 0;
1269be5cd90dSDmitry Monakhov 	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
1270a86c6181SAlex Tomas 	int err = 0;
1271592acbf1SSriram Rajagopalan 	size_t ext_size = 0;
1272a86c6181SAlex Tomas 
1273be5cd90dSDmitry Monakhov 	/* Try to prepend new index to old one */
1274be5cd90dSDmitry Monakhov 	if (ext_depth(inode))
1275be5cd90dSDmitry Monakhov 		goal = ext4_idx_pblock(EXT_FIRST_INDEX(ext_inode_hdr(inode)));
1276be5cd90dSDmitry Monakhov 	if (goal > le32_to_cpu(es->s_first_data_block)) {
1277be5cd90dSDmitry Monakhov 		flags |= EXT4_MB_HINT_TRY_GOAL;
1278be5cd90dSDmitry Monakhov 		goal--;
1279be5cd90dSDmitry Monakhov 	} else
1280be5cd90dSDmitry Monakhov 		goal = ext4_inode_to_goal_block(inode);
1281be5cd90dSDmitry Monakhov 	newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
1282be5cd90dSDmitry Monakhov 					NULL, &err);
1283a86c6181SAlex Tomas 	if (newblock == 0)
1284a86c6181SAlex Tomas 		return err;
1285a86c6181SAlex Tomas 
1286c45653c3SNikolay Borisov 	bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1287aebf0243SWang Shilong 	if (unlikely(!bh))
1288860d21e2STheodore Ts'o 		return -ENOMEM;
1289a86c6181SAlex Tomas 	lock_buffer(bh);
1290a86c6181SAlex Tomas 
12917e028976SAvantika Mathur 	err = ext4_journal_get_create_access(handle, bh);
12927e028976SAvantika Mathur 	if (err) {
1293a86c6181SAlex Tomas 		unlock_buffer(bh);
1294a86c6181SAlex Tomas 		goto out;
1295a86c6181SAlex Tomas 	}
1296a86c6181SAlex Tomas 
1297592acbf1SSriram Rajagopalan 	ext_size = sizeof(EXT4_I(inode)->i_data);
1298a86c6181SAlex Tomas 	/* move top-level index/leaf into new block */
1299592acbf1SSriram Rajagopalan 	memmove(bh->b_data, EXT4_I(inode)->i_data, ext_size);
1300592acbf1SSriram Rajagopalan 	/* zero out unused area in the extent block */
1301592acbf1SSriram Rajagopalan 	memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1302a86c6181SAlex Tomas 
1303a86c6181SAlex Tomas 	/* set size of new block */
1304a86c6181SAlex Tomas 	neh = ext_block_hdr(bh);
1305a86c6181SAlex Tomas 	/* old root could have indexes or leaves
1306a86c6181SAlex Tomas 	 * so calculate e_max right way */
1307a86c6181SAlex Tomas 	if (ext_depth(inode))
130855ad63bfSTheodore Ts'o 		neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1309a86c6181SAlex Tomas 	else
131055ad63bfSTheodore Ts'o 		neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1311a86c6181SAlex Tomas 	neh->eh_magic = EXT4_EXT_MAGIC;
13127ac5990dSDarrick J. Wong 	ext4_extent_block_csum_set(inode, neh);
1313a86c6181SAlex Tomas 	set_buffer_uptodate(bh);
1314a86c6181SAlex Tomas 	unlock_buffer(bh);
1315a86c6181SAlex Tomas 
13160390131bSFrank Mayhar 	err = ext4_handle_dirty_metadata(handle, inode, bh);
13177e028976SAvantika Mathur 	if (err)
1318a86c6181SAlex Tomas 		goto out;
1319a86c6181SAlex Tomas 
13201939dd84SDmitry Monakhov 	/* Update top-level index: num,max,pointer */
1321a86c6181SAlex Tomas 	neh = ext_inode_hdr(inode);
13221939dd84SDmitry Monakhov 	neh->eh_entries = cpu_to_le16(1);
13231939dd84SDmitry Monakhov 	ext4_idx_store_pblock(EXT_FIRST_INDEX(neh), newblock);
13241939dd84SDmitry Monakhov 	if (neh->eh_depth == 0) {
13251939dd84SDmitry Monakhov 		/* Root extent block becomes index block */
13261939dd84SDmitry Monakhov 		neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
13271939dd84SDmitry Monakhov 		EXT_FIRST_INDEX(neh)->ei_block =
13281939dd84SDmitry Monakhov 			EXT_FIRST_EXTENT(neh)->ee_block;
13291939dd84SDmitry Monakhov 	}
13302ae02107SMingming Cao 	ext_debug("new root: num %d(%d), lblock %d, ptr %llu\n",
1331a86c6181SAlex Tomas 		  le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),
13325a0790c2SAndi Kleen 		  le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block),
1333bf89d16fSTheodore Ts'o 		  ext4_idx_pblock(EXT_FIRST_INDEX(neh)));
1334a86c6181SAlex Tomas 
1335ba39ebb6SWei Yongjun 	le16_add_cpu(&neh->eh_depth, 1);
13364209ae12SHarshad Shirwadkar 	err = ext4_mark_inode_dirty(handle, inode);
1337a86c6181SAlex Tomas out:
1338a86c6181SAlex Tomas 	brelse(bh);
1339a86c6181SAlex Tomas 
1340a86c6181SAlex Tomas 	return err;
1341a86c6181SAlex Tomas }
1342a86c6181SAlex Tomas 
1343a86c6181SAlex Tomas /*
1344d0d856e8SRandy Dunlap  * ext4_ext_create_new_leaf:
1345d0d856e8SRandy Dunlap  * finds empty index and adds new leaf.
1346d0d856e8SRandy Dunlap  * if no free index is found, then it requests in-depth growing.
1347a86c6181SAlex Tomas  */
1348a86c6181SAlex Tomas static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode,
1349107a7bd3STheodore Ts'o 				    unsigned int mb_flags,
1350107a7bd3STheodore Ts'o 				    unsigned int gb_flags,
1351dfe50809STheodore Ts'o 				    struct ext4_ext_path **ppath,
1352a86c6181SAlex Tomas 				    struct ext4_extent *newext)
1353a86c6181SAlex Tomas {
1354dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
1355a86c6181SAlex Tomas 	struct ext4_ext_path *curp;
1356a86c6181SAlex Tomas 	int depth, i, err = 0;
1357a86c6181SAlex Tomas 
1358a86c6181SAlex Tomas repeat:
1359a86c6181SAlex Tomas 	i = depth = ext_depth(inode);
1360a86c6181SAlex Tomas 
1361a86c6181SAlex Tomas 	/* walk up to the tree and look for free index entry */
1362a86c6181SAlex Tomas 	curp = path + depth;
1363a86c6181SAlex Tomas 	while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) {
1364a86c6181SAlex Tomas 		i--;
1365a86c6181SAlex Tomas 		curp--;
1366a86c6181SAlex Tomas 	}
1367a86c6181SAlex Tomas 
1368d0d856e8SRandy Dunlap 	/* we use already allocated block for index block,
1369d0d856e8SRandy Dunlap 	 * so subsequent data blocks should be contiguous */
1370a86c6181SAlex Tomas 	if (EXT_HAS_FREE_INDEX(curp)) {
1371a86c6181SAlex Tomas 		/* if we found index with free entry, then use that
1372a86c6181SAlex Tomas 		 * entry: create all needed subtree and add new leaf */
1373107a7bd3STheodore Ts'o 		err = ext4_ext_split(handle, inode, mb_flags, path, newext, i);
1374787e0981SShen Feng 		if (err)
1375787e0981SShen Feng 			goto out;
1376a86c6181SAlex Tomas 
1377a86c6181SAlex Tomas 		/* refill path */
1378ed8a1a76STheodore Ts'o 		path = ext4_find_extent(inode,
1379725d26d3SAneesh Kumar K.V 				    (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1380dfe50809STheodore Ts'o 				    ppath, gb_flags);
1381a86c6181SAlex Tomas 		if (IS_ERR(path))
1382a86c6181SAlex Tomas 			err = PTR_ERR(path);
1383a86c6181SAlex Tomas 	} else {
1384a86c6181SAlex Tomas 		/* tree is full, time to grow in depth */
1385be5cd90dSDmitry Monakhov 		err = ext4_ext_grow_indepth(handle, inode, mb_flags);
1386a86c6181SAlex Tomas 		if (err)
1387a86c6181SAlex Tomas 			goto out;
1388a86c6181SAlex Tomas 
1389a86c6181SAlex Tomas 		/* refill path */
1390ed8a1a76STheodore Ts'o 		path = ext4_find_extent(inode,
1391725d26d3SAneesh Kumar K.V 				   (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1392dfe50809STheodore Ts'o 				    ppath, gb_flags);
1393a86c6181SAlex Tomas 		if (IS_ERR(path)) {
1394a86c6181SAlex Tomas 			err = PTR_ERR(path);
1395a86c6181SAlex Tomas 			goto out;
1396a86c6181SAlex Tomas 		}
1397a86c6181SAlex Tomas 
1398a86c6181SAlex Tomas 		/*
1399d0d856e8SRandy Dunlap 		 * only first (depth 0 -> 1) produces free space;
1400d0d856e8SRandy Dunlap 		 * in all other cases we have to split the grown tree
1401a86c6181SAlex Tomas 		 */
1402a86c6181SAlex Tomas 		depth = ext_depth(inode);
1403a86c6181SAlex Tomas 		if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
1404d0d856e8SRandy Dunlap 			/* now we need to split */
1405a86c6181SAlex Tomas 			goto repeat;
1406a86c6181SAlex Tomas 		}
1407a86c6181SAlex Tomas 	}
1408a86c6181SAlex Tomas 
1409a86c6181SAlex Tomas out:
1410a86c6181SAlex Tomas 	return err;
1411a86c6181SAlex Tomas }
1412a86c6181SAlex Tomas 
1413a86c6181SAlex Tomas /*
14141988b51eSAlex Tomas  * search the closest allocated block to the left for *logical
14151988b51eSAlex Tomas  * and returns it at @logical + it's physical address at @phys
14161988b51eSAlex Tomas  * if *logical is the smallest allocated block, the function
14171988b51eSAlex Tomas  * returns 0 at @phys
14181988b51eSAlex Tomas  * return value contains 0 (success) or error code
14191988b51eSAlex Tomas  */
14201f109d5aSTheodore Ts'o static int ext4_ext_search_left(struct inode *inode,
14211f109d5aSTheodore Ts'o 				struct ext4_ext_path *path,
14221988b51eSAlex Tomas 				ext4_lblk_t *logical, ext4_fsblk_t *phys)
14231988b51eSAlex Tomas {
14241988b51eSAlex Tomas 	struct ext4_extent_idx *ix;
14251988b51eSAlex Tomas 	struct ext4_extent *ex;
1426b939e376SAneesh Kumar K.V 	int depth, ee_len;
14271988b51eSAlex Tomas 
1428273df556SFrank Mayhar 	if (unlikely(path == NULL)) {
1429273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
14306a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1431273df556SFrank Mayhar 	}
14321988b51eSAlex Tomas 	depth = path->p_depth;
14331988b51eSAlex Tomas 	*phys = 0;
14341988b51eSAlex Tomas 
14351988b51eSAlex Tomas 	if (depth == 0 && path->p_ext == NULL)
14361988b51eSAlex Tomas 		return 0;
14371988b51eSAlex Tomas 
14381988b51eSAlex Tomas 	/* usually extent in the path covers blocks smaller
14391988b51eSAlex Tomas 	 * then *logical, but it can be that extent is the
14401988b51eSAlex Tomas 	 * first one in the file */
14411988b51eSAlex Tomas 
14421988b51eSAlex Tomas 	ex = path[depth].p_ext;
1443b939e376SAneesh Kumar K.V 	ee_len = ext4_ext_get_actual_len(ex);
14441988b51eSAlex Tomas 	if (*logical < le32_to_cpu(ex->ee_block)) {
1445273df556SFrank Mayhar 		if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1446273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
1447273df556SFrank Mayhar 					 "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!",
1448273df556SFrank Mayhar 					 *logical, le32_to_cpu(ex->ee_block));
14496a797d27SDarrick J. Wong 			return -EFSCORRUPTED;
1450273df556SFrank Mayhar 		}
14511988b51eSAlex Tomas 		while (--depth >= 0) {
14521988b51eSAlex Tomas 			ix = path[depth].p_idx;
1453273df556SFrank Mayhar 			if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1454273df556SFrank Mayhar 				EXT4_ERROR_INODE(inode,
1455273df556SFrank Mayhar 				  "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!",
14566ee3b212STao Ma 				  ix != NULL ? le32_to_cpu(ix->ei_block) : 0,
1457273df556SFrank Mayhar 				  EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?
14586ee3b212STao Ma 		le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0,
1459273df556SFrank Mayhar 				  depth);
14606a797d27SDarrick J. Wong 				return -EFSCORRUPTED;
1461273df556SFrank Mayhar 			}
14621988b51eSAlex Tomas 		}
14631988b51eSAlex Tomas 		return 0;
14641988b51eSAlex Tomas 	}
14651988b51eSAlex Tomas 
1466273df556SFrank Mayhar 	if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1467273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
1468273df556SFrank Mayhar 				 "logical %d < ee_block %d + ee_len %d!",
1469273df556SFrank Mayhar 				 *logical, le32_to_cpu(ex->ee_block), ee_len);
14706a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1471273df556SFrank Mayhar 	}
14721988b51eSAlex Tomas 
1473b939e376SAneesh Kumar K.V 	*logical = le32_to_cpu(ex->ee_block) + ee_len - 1;
1474bf89d16fSTheodore Ts'o 	*phys = ext4_ext_pblock(ex) + ee_len - 1;
14751988b51eSAlex Tomas 	return 0;
14761988b51eSAlex Tomas }
14771988b51eSAlex Tomas 
14781988b51eSAlex Tomas /*
14791988b51eSAlex Tomas  * search the closest allocated block to the right for *logical
14801988b51eSAlex Tomas  * and returns it at @logical + it's physical address at @phys
1481df3ab170STao Ma  * if *logical is the largest allocated block, the function
14821988b51eSAlex Tomas  * returns 0 at @phys
14831988b51eSAlex Tomas  * return value contains 0 (success) or error code
14841988b51eSAlex Tomas  */
14851f109d5aSTheodore Ts'o static int ext4_ext_search_right(struct inode *inode,
14861f109d5aSTheodore Ts'o 				 struct ext4_ext_path *path,
14874d33b1efSTheodore Ts'o 				 ext4_lblk_t *logical, ext4_fsblk_t *phys,
14884d33b1efSTheodore Ts'o 				 struct ext4_extent **ret_ex)
14891988b51eSAlex Tomas {
14901988b51eSAlex Tomas 	struct buffer_head *bh = NULL;
14911988b51eSAlex Tomas 	struct ext4_extent_header *eh;
14921988b51eSAlex Tomas 	struct ext4_extent_idx *ix;
14931988b51eSAlex Tomas 	struct ext4_extent *ex;
14941988b51eSAlex Tomas 	ext4_fsblk_t block;
1495395a87bfSEric Sandeen 	int depth;	/* Note, NOT eh_depth; depth from top of tree */
1496395a87bfSEric Sandeen 	int ee_len;
14971988b51eSAlex Tomas 
1498273df556SFrank Mayhar 	if (unlikely(path == NULL)) {
1499273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
15006a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1501273df556SFrank Mayhar 	}
15021988b51eSAlex Tomas 	depth = path->p_depth;
15031988b51eSAlex Tomas 	*phys = 0;
15041988b51eSAlex Tomas 
15051988b51eSAlex Tomas 	if (depth == 0 && path->p_ext == NULL)
15061988b51eSAlex Tomas 		return 0;
15071988b51eSAlex Tomas 
15081988b51eSAlex Tomas 	/* usually extent in the path covers blocks smaller
15091988b51eSAlex Tomas 	 * then *logical, but it can be that extent is the
15101988b51eSAlex Tomas 	 * first one in the file */
15111988b51eSAlex Tomas 
15121988b51eSAlex Tomas 	ex = path[depth].p_ext;
1513b939e376SAneesh Kumar K.V 	ee_len = ext4_ext_get_actual_len(ex);
15141988b51eSAlex Tomas 	if (*logical < le32_to_cpu(ex->ee_block)) {
1515273df556SFrank Mayhar 		if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1516273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
1517273df556SFrank Mayhar 					 "first_extent(path[%d].p_hdr) != ex",
1518273df556SFrank Mayhar 					 depth);
15196a797d27SDarrick J. Wong 			return -EFSCORRUPTED;
1520273df556SFrank Mayhar 		}
15211988b51eSAlex Tomas 		while (--depth >= 0) {
15221988b51eSAlex Tomas 			ix = path[depth].p_idx;
1523273df556SFrank Mayhar 			if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1524273df556SFrank Mayhar 				EXT4_ERROR_INODE(inode,
1525273df556SFrank Mayhar 						 "ix != EXT_FIRST_INDEX *logical %d!",
1526273df556SFrank Mayhar 						 *logical);
15276a797d27SDarrick J. Wong 				return -EFSCORRUPTED;
1528273df556SFrank Mayhar 			}
15291988b51eSAlex Tomas 		}
15304d33b1efSTheodore Ts'o 		goto found_extent;
15311988b51eSAlex Tomas 	}
15321988b51eSAlex Tomas 
1533273df556SFrank Mayhar 	if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1534273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
1535273df556SFrank Mayhar 				 "logical %d < ee_block %d + ee_len %d!",
1536273df556SFrank Mayhar 				 *logical, le32_to_cpu(ex->ee_block), ee_len);
15376a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1538273df556SFrank Mayhar 	}
15391988b51eSAlex Tomas 
15401988b51eSAlex Tomas 	if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
15411988b51eSAlex Tomas 		/* next allocated block in this leaf */
15421988b51eSAlex Tomas 		ex++;
15434d33b1efSTheodore Ts'o 		goto found_extent;
15441988b51eSAlex Tomas 	}
15451988b51eSAlex Tomas 
15461988b51eSAlex Tomas 	/* go up and search for index to the right */
15471988b51eSAlex Tomas 	while (--depth >= 0) {
15481988b51eSAlex Tomas 		ix = path[depth].p_idx;
15491988b51eSAlex Tomas 		if (ix != EXT_LAST_INDEX(path[depth].p_hdr))
155025f1ee3aSWu Fengguang 			goto got_index;
15511988b51eSAlex Tomas 	}
15521988b51eSAlex Tomas 
155325f1ee3aSWu Fengguang 	/* we've gone up to the root and found no index to the right */
15541988b51eSAlex Tomas 	return 0;
15551988b51eSAlex Tomas 
155625f1ee3aSWu Fengguang got_index:
15571988b51eSAlex Tomas 	/* we've found index to the right, let's
15581988b51eSAlex Tomas 	 * follow it and find the closest allocated
15591988b51eSAlex Tomas 	 * block to the right */
15601988b51eSAlex Tomas 	ix++;
1561bf89d16fSTheodore Ts'o 	block = ext4_idx_pblock(ix);
15621988b51eSAlex Tomas 	while (++depth < path->p_depth) {
1563395a87bfSEric Sandeen 		/* subtract from p_depth to get proper eh_depth */
15647d7ea89eSTheodore Ts'o 		bh = read_extent_tree_block(inode, block,
1565107a7bd3STheodore Ts'o 					    path->p_depth - depth, 0);
15667d7ea89eSTheodore Ts'o 		if (IS_ERR(bh))
15677d7ea89eSTheodore Ts'o 			return PTR_ERR(bh);
15687d7ea89eSTheodore Ts'o 		eh = ext_block_hdr(bh);
15691988b51eSAlex Tomas 		ix = EXT_FIRST_INDEX(eh);
1570bf89d16fSTheodore Ts'o 		block = ext4_idx_pblock(ix);
15711988b51eSAlex Tomas 		put_bh(bh);
15721988b51eSAlex Tomas 	}
15731988b51eSAlex Tomas 
1574107a7bd3STheodore Ts'o 	bh = read_extent_tree_block(inode, block, path->p_depth - depth, 0);
15757d7ea89eSTheodore Ts'o 	if (IS_ERR(bh))
15767d7ea89eSTheodore Ts'o 		return PTR_ERR(bh);
15771988b51eSAlex Tomas 	eh = ext_block_hdr(bh);
15781988b51eSAlex Tomas 	ex = EXT_FIRST_EXTENT(eh);
15794d33b1efSTheodore Ts'o found_extent:
15801988b51eSAlex Tomas 	*logical = le32_to_cpu(ex->ee_block);
1581bf89d16fSTheodore Ts'o 	*phys = ext4_ext_pblock(ex);
15824d33b1efSTheodore Ts'o 	*ret_ex = ex;
15834d33b1efSTheodore Ts'o 	if (bh)
15841988b51eSAlex Tomas 		put_bh(bh);
15851988b51eSAlex Tomas 	return 0;
15861988b51eSAlex Tomas }
15871988b51eSAlex Tomas 
15881988b51eSAlex Tomas /*
1589d0d856e8SRandy Dunlap  * ext4_ext_next_allocated_block:
1590f17722f9SLukas Czerner  * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
1591d0d856e8SRandy Dunlap  * NOTE: it considers block number from index entry as
1592d0d856e8SRandy Dunlap  * allocated block. Thus, index entries have to be consistent
1593d0d856e8SRandy Dunlap  * with leaves.
1594a86c6181SAlex Tomas  */
1595fcf6b1b7SDmitry Monakhov ext4_lblk_t
1596a86c6181SAlex Tomas ext4_ext_next_allocated_block(struct ext4_ext_path *path)
1597a86c6181SAlex Tomas {
1598a86c6181SAlex Tomas 	int depth;
1599a86c6181SAlex Tomas 
1600a86c6181SAlex Tomas 	BUG_ON(path == NULL);
1601a86c6181SAlex Tomas 	depth = path->p_depth;
1602a86c6181SAlex Tomas 
1603a86c6181SAlex Tomas 	if (depth == 0 && path->p_ext == NULL)
1604f17722f9SLukas Czerner 		return EXT_MAX_BLOCKS;
1605a86c6181SAlex Tomas 
1606a86c6181SAlex Tomas 	while (depth >= 0) {
16076e89bbb7SEric Biggers 		struct ext4_ext_path *p = &path[depth];
16086e89bbb7SEric Biggers 
1609a86c6181SAlex Tomas 		if (depth == path->p_depth) {
1610a86c6181SAlex Tomas 			/* leaf */
16116e89bbb7SEric Biggers 			if (p->p_ext && p->p_ext != EXT_LAST_EXTENT(p->p_hdr))
16126e89bbb7SEric Biggers 				return le32_to_cpu(p->p_ext[1].ee_block);
1613a86c6181SAlex Tomas 		} else {
1614a86c6181SAlex Tomas 			/* index */
16156e89bbb7SEric Biggers 			if (p->p_idx != EXT_LAST_INDEX(p->p_hdr))
16166e89bbb7SEric Biggers 				return le32_to_cpu(p->p_idx[1].ei_block);
1617a86c6181SAlex Tomas 		}
1618a86c6181SAlex Tomas 		depth--;
1619a86c6181SAlex Tomas 	}
1620a86c6181SAlex Tomas 
1621f17722f9SLukas Czerner 	return EXT_MAX_BLOCKS;
1622a86c6181SAlex Tomas }
1623a86c6181SAlex Tomas 
1624a86c6181SAlex Tomas /*
1625d0d856e8SRandy Dunlap  * ext4_ext_next_leaf_block:
1626f17722f9SLukas Czerner  * returns first allocated block from next leaf or EXT_MAX_BLOCKS
1627a86c6181SAlex Tomas  */
16285718789dSRobin Dong static ext4_lblk_t ext4_ext_next_leaf_block(struct ext4_ext_path *path)
1629a86c6181SAlex Tomas {
1630a86c6181SAlex Tomas 	int depth;
1631a86c6181SAlex Tomas 
1632a86c6181SAlex Tomas 	BUG_ON(path == NULL);
1633a86c6181SAlex Tomas 	depth = path->p_depth;
1634a86c6181SAlex Tomas 
1635a86c6181SAlex Tomas 	/* zero-tree has no leaf blocks at all */
1636a86c6181SAlex Tomas 	if (depth == 0)
1637f17722f9SLukas Czerner 		return EXT_MAX_BLOCKS;
1638a86c6181SAlex Tomas 
1639a86c6181SAlex Tomas 	/* go to index block */
1640a86c6181SAlex Tomas 	depth--;
1641a86c6181SAlex Tomas 
1642a86c6181SAlex Tomas 	while (depth >= 0) {
1643a86c6181SAlex Tomas 		if (path[depth].p_idx !=
1644a86c6181SAlex Tomas 				EXT_LAST_INDEX(path[depth].p_hdr))
1645725d26d3SAneesh Kumar K.V 			return (ext4_lblk_t)
1646725d26d3SAneesh Kumar K.V 				le32_to_cpu(path[depth].p_idx[1].ei_block);
1647a86c6181SAlex Tomas 		depth--;
1648a86c6181SAlex Tomas 	}
1649a86c6181SAlex Tomas 
1650f17722f9SLukas Czerner 	return EXT_MAX_BLOCKS;
1651a86c6181SAlex Tomas }
1652a86c6181SAlex Tomas 
1653a86c6181SAlex Tomas /*
1654d0d856e8SRandy Dunlap  * ext4_ext_correct_indexes:
1655d0d856e8SRandy Dunlap  * if leaf gets modified and modified extent is first in the leaf,
1656d0d856e8SRandy Dunlap  * then we have to correct all indexes above.
1657a86c6181SAlex Tomas  * TODO: do we need to correct tree in all cases?
1658a86c6181SAlex Tomas  */
16591d03ec98SAneesh Kumar K.V static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
1660a86c6181SAlex Tomas 				struct ext4_ext_path *path)
1661a86c6181SAlex Tomas {
1662a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
1663a86c6181SAlex Tomas 	int depth = ext_depth(inode);
1664a86c6181SAlex Tomas 	struct ext4_extent *ex;
1665a86c6181SAlex Tomas 	__le32 border;
1666a86c6181SAlex Tomas 	int k, err = 0;
1667a86c6181SAlex Tomas 
1668a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
1669a86c6181SAlex Tomas 	ex = path[depth].p_ext;
1670273df556SFrank Mayhar 
1671273df556SFrank Mayhar 	if (unlikely(ex == NULL || eh == NULL)) {
1672273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
1673273df556SFrank Mayhar 				 "ex %p == NULL or eh %p == NULL", ex, eh);
16746a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1675273df556SFrank Mayhar 	}
1676a86c6181SAlex Tomas 
1677a86c6181SAlex Tomas 	if (depth == 0) {
1678a86c6181SAlex Tomas 		/* there is no tree at all */
1679a86c6181SAlex Tomas 		return 0;
1680a86c6181SAlex Tomas 	}
1681a86c6181SAlex Tomas 
1682a86c6181SAlex Tomas 	if (ex != EXT_FIRST_EXTENT(eh)) {
1683a86c6181SAlex Tomas 		/* we correct tree if first leaf got modified only */
1684a86c6181SAlex Tomas 		return 0;
1685a86c6181SAlex Tomas 	}
1686a86c6181SAlex Tomas 
1687a86c6181SAlex Tomas 	/*
1688d0d856e8SRandy Dunlap 	 * TODO: we need correction if border is smaller than current one
1689a86c6181SAlex Tomas 	 */
1690a86c6181SAlex Tomas 	k = depth - 1;
1691a86c6181SAlex Tomas 	border = path[depth].p_ext->ee_block;
16927e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, path + k);
16937e028976SAvantika Mathur 	if (err)
1694a86c6181SAlex Tomas 		return err;
1695a86c6181SAlex Tomas 	path[k].p_idx->ei_block = border;
16967e028976SAvantika Mathur 	err = ext4_ext_dirty(handle, inode, path + k);
16977e028976SAvantika Mathur 	if (err)
1698a86c6181SAlex Tomas 		return err;
1699a86c6181SAlex Tomas 
1700a86c6181SAlex Tomas 	while (k--) {
1701a86c6181SAlex Tomas 		/* change all left-side indexes */
1702a86c6181SAlex Tomas 		if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr))
1703a86c6181SAlex Tomas 			break;
17047e028976SAvantika Mathur 		err = ext4_ext_get_access(handle, inode, path + k);
17057e028976SAvantika Mathur 		if (err)
1706a86c6181SAlex Tomas 			break;
1707a86c6181SAlex Tomas 		path[k].p_idx->ei_block = border;
17087e028976SAvantika Mathur 		err = ext4_ext_dirty(handle, inode, path + k);
17097e028976SAvantika Mathur 		if (err)
1710a86c6181SAlex Tomas 			break;
1711a86c6181SAlex Tomas 	}
1712a86c6181SAlex Tomas 
1713a86c6181SAlex Tomas 	return err;
1714a86c6181SAlex Tomas }
1715a86c6181SAlex Tomas 
171643f81677SEric Biggers static int ext4_can_extents_be_merged(struct inode *inode,
171743f81677SEric Biggers 				      struct ext4_extent *ex1,
1718a86c6181SAlex Tomas 				      struct ext4_extent *ex2)
1719a86c6181SAlex Tomas {
1720da0169b3SEric Sandeen 	unsigned short ext1_ee_len, ext2_ee_len;
1721a2df2a63SAmit Arora 
1722556615dcSLukas Czerner 	if (ext4_ext_is_unwritten(ex1) != ext4_ext_is_unwritten(ex2))
1723a2df2a63SAmit Arora 		return 0;
1724a2df2a63SAmit Arora 
1725a2df2a63SAmit Arora 	ext1_ee_len = ext4_ext_get_actual_len(ex1);
1726a2df2a63SAmit Arora 	ext2_ee_len = ext4_ext_get_actual_len(ex2);
1727a2df2a63SAmit Arora 
1728a2df2a63SAmit Arora 	if (le32_to_cpu(ex1->ee_block) + ext1_ee_len !=
172963f57933SAndrew Morton 			le32_to_cpu(ex2->ee_block))
1730a86c6181SAlex Tomas 		return 0;
1731a86c6181SAlex Tomas 
1732da0169b3SEric Sandeen 	if (ext1_ee_len + ext2_ee_len > EXT_INIT_MAX_LEN)
1733471d4011SSuparna Bhattacharya 		return 0;
1734378f32baSMatthew Bobrowski 
1735556615dcSLukas Czerner 	if (ext4_ext_is_unwritten(ex1) &&
1736378f32baSMatthew Bobrowski 	    ext1_ee_len + ext2_ee_len > EXT_UNWRITTEN_MAX_LEN)
1737a9b82415SDarrick J. Wong 		return 0;
1738bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
1739b939e376SAneesh Kumar K.V 	if (ext1_ee_len >= 4)
1740a86c6181SAlex Tomas 		return 0;
1741a86c6181SAlex Tomas #endif
1742a86c6181SAlex Tomas 
1743bf89d16fSTheodore Ts'o 	if (ext4_ext_pblock(ex1) + ext1_ee_len == ext4_ext_pblock(ex2))
1744a86c6181SAlex Tomas 		return 1;
1745a86c6181SAlex Tomas 	return 0;
1746a86c6181SAlex Tomas }
1747a86c6181SAlex Tomas 
1748a86c6181SAlex Tomas /*
174956055d3aSAmit Arora  * This function tries to merge the "ex" extent to the next extent in the tree.
175056055d3aSAmit Arora  * It always tries to merge towards right. If you want to merge towards
175156055d3aSAmit Arora  * left, pass "ex - 1" as argument instead of "ex".
175256055d3aSAmit Arora  * Returns 0 if the extents (ex and ex+1) were _not_ merged and returns
175356055d3aSAmit Arora  * 1 if they got merged.
175456055d3aSAmit Arora  */
1755197217a5SYongqiang Yang static int ext4_ext_try_to_merge_right(struct inode *inode,
175656055d3aSAmit Arora 				 struct ext4_ext_path *path,
175756055d3aSAmit Arora 				 struct ext4_extent *ex)
175856055d3aSAmit Arora {
175956055d3aSAmit Arora 	struct ext4_extent_header *eh;
176056055d3aSAmit Arora 	unsigned int depth, len;
1761556615dcSLukas Czerner 	int merge_done = 0, unwritten;
176256055d3aSAmit Arora 
176356055d3aSAmit Arora 	depth = ext_depth(inode);
176456055d3aSAmit Arora 	BUG_ON(path[depth].p_hdr == NULL);
176556055d3aSAmit Arora 	eh = path[depth].p_hdr;
176656055d3aSAmit Arora 
176756055d3aSAmit Arora 	while (ex < EXT_LAST_EXTENT(eh)) {
176856055d3aSAmit Arora 		if (!ext4_can_extents_be_merged(inode, ex, ex + 1))
176956055d3aSAmit Arora 			break;
177056055d3aSAmit Arora 		/* merge with next extent! */
1771556615dcSLukas Czerner 		unwritten = ext4_ext_is_unwritten(ex);
177256055d3aSAmit Arora 		ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
177356055d3aSAmit Arora 				+ ext4_ext_get_actual_len(ex + 1));
1774556615dcSLukas Czerner 		if (unwritten)
1775556615dcSLukas Czerner 			ext4_ext_mark_unwritten(ex);
177656055d3aSAmit Arora 
177756055d3aSAmit Arora 		if (ex + 1 < EXT_LAST_EXTENT(eh)) {
177856055d3aSAmit Arora 			len = (EXT_LAST_EXTENT(eh) - ex - 1)
177956055d3aSAmit Arora 				* sizeof(struct ext4_extent);
178056055d3aSAmit Arora 			memmove(ex + 1, ex + 2, len);
178156055d3aSAmit Arora 		}
1782e8546d06SMarcin Slusarz 		le16_add_cpu(&eh->eh_entries, -1);
178356055d3aSAmit Arora 		merge_done = 1;
178456055d3aSAmit Arora 		WARN_ON(eh->eh_entries == 0);
178556055d3aSAmit Arora 		if (!eh->eh_entries)
178624676da4STheodore Ts'o 			EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!");
178756055d3aSAmit Arora 	}
178856055d3aSAmit Arora 
178956055d3aSAmit Arora 	return merge_done;
179056055d3aSAmit Arora }
179156055d3aSAmit Arora 
179256055d3aSAmit Arora /*
1793ecb94f5fSTheodore Ts'o  * This function does a very simple check to see if we can collapse
1794ecb94f5fSTheodore Ts'o  * an extent tree with a single extent tree leaf block into the inode.
1795ecb94f5fSTheodore Ts'o  */
1796ecb94f5fSTheodore Ts'o static void ext4_ext_try_to_merge_up(handle_t *handle,
1797ecb94f5fSTheodore Ts'o 				     struct inode *inode,
1798ecb94f5fSTheodore Ts'o 				     struct ext4_ext_path *path)
1799ecb94f5fSTheodore Ts'o {
1800ecb94f5fSTheodore Ts'o 	size_t s;
1801ecb94f5fSTheodore Ts'o 	unsigned max_root = ext4_ext_space_root(inode, 0);
1802ecb94f5fSTheodore Ts'o 	ext4_fsblk_t blk;
1803ecb94f5fSTheodore Ts'o 
1804ecb94f5fSTheodore Ts'o 	if ((path[0].p_depth != 1) ||
1805ecb94f5fSTheodore Ts'o 	    (le16_to_cpu(path[0].p_hdr->eh_entries) != 1) ||
1806ecb94f5fSTheodore Ts'o 	    (le16_to_cpu(path[1].p_hdr->eh_entries) > max_root))
1807ecb94f5fSTheodore Ts'o 		return;
1808ecb94f5fSTheodore Ts'o 
1809ecb94f5fSTheodore Ts'o 	/*
1810ecb94f5fSTheodore Ts'o 	 * We need to modify the block allocation bitmap and the block
1811ecb94f5fSTheodore Ts'o 	 * group descriptor to release the extent tree block.  If we
1812ecb94f5fSTheodore Ts'o 	 * can't get the journal credits, give up.
1813ecb94f5fSTheodore Ts'o 	 */
181483448bdfSJan Kara 	if (ext4_journal_extend(handle, 2,
181583448bdfSJan Kara 			ext4_free_metadata_revoke_credits(inode->i_sb, 1)))
1816ecb94f5fSTheodore Ts'o 		return;
1817ecb94f5fSTheodore Ts'o 
1818ecb94f5fSTheodore Ts'o 	/*
1819ecb94f5fSTheodore Ts'o 	 * Copy the extent data up to the inode
1820ecb94f5fSTheodore Ts'o 	 */
1821ecb94f5fSTheodore Ts'o 	blk = ext4_idx_pblock(path[0].p_idx);
1822ecb94f5fSTheodore Ts'o 	s = le16_to_cpu(path[1].p_hdr->eh_entries) *
1823ecb94f5fSTheodore Ts'o 		sizeof(struct ext4_extent_idx);
1824ecb94f5fSTheodore Ts'o 	s += sizeof(struct ext4_extent_header);
1825ecb94f5fSTheodore Ts'o 
182610809df8STheodore Ts'o 	path[1].p_maxdepth = path[0].p_maxdepth;
1827ecb94f5fSTheodore Ts'o 	memcpy(path[0].p_hdr, path[1].p_hdr, s);
1828ecb94f5fSTheodore Ts'o 	path[0].p_depth = 0;
1829ecb94f5fSTheodore Ts'o 	path[0].p_ext = EXT_FIRST_EXTENT(path[0].p_hdr) +
1830ecb94f5fSTheodore Ts'o 		(path[1].p_ext - EXT_FIRST_EXTENT(path[1].p_hdr));
1831ecb94f5fSTheodore Ts'o 	path[0].p_hdr->eh_max = cpu_to_le16(max_root);
1832ecb94f5fSTheodore Ts'o 
1833ecb94f5fSTheodore Ts'o 	brelse(path[1].p_bh);
1834ecb94f5fSTheodore Ts'o 	ext4_free_blocks(handle, inode, NULL, blk, 1,
183571d4f7d0STheodore Ts'o 			 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
1836ecb94f5fSTheodore Ts'o }
1837ecb94f5fSTheodore Ts'o 
1838ecb94f5fSTheodore Ts'o /*
1839adde81cfSEric Biggers  * This function tries to merge the @ex extent to neighbours in the tree, then
1840adde81cfSEric Biggers  * tries to collapse the extent tree into the inode.
1841197217a5SYongqiang Yang  */
1842ecb94f5fSTheodore Ts'o static void ext4_ext_try_to_merge(handle_t *handle,
1843ecb94f5fSTheodore Ts'o 				  struct inode *inode,
1844197217a5SYongqiang Yang 				  struct ext4_ext_path *path,
1845adde81cfSEric Biggers 				  struct ext4_extent *ex)
1846adde81cfSEric Biggers {
1847197217a5SYongqiang Yang 	struct ext4_extent_header *eh;
1848197217a5SYongqiang Yang 	unsigned int depth;
1849197217a5SYongqiang Yang 	int merge_done = 0;
1850197217a5SYongqiang Yang 
1851197217a5SYongqiang Yang 	depth = ext_depth(inode);
1852197217a5SYongqiang Yang 	BUG_ON(path[depth].p_hdr == NULL);
1853197217a5SYongqiang Yang 	eh = path[depth].p_hdr;
1854197217a5SYongqiang Yang 
1855197217a5SYongqiang Yang 	if (ex > EXT_FIRST_EXTENT(eh))
1856197217a5SYongqiang Yang 		merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1);
1857197217a5SYongqiang Yang 
1858197217a5SYongqiang Yang 	if (!merge_done)
1859ecb94f5fSTheodore Ts'o 		(void) ext4_ext_try_to_merge_right(inode, path, ex);
1860197217a5SYongqiang Yang 
1861ecb94f5fSTheodore Ts'o 	ext4_ext_try_to_merge_up(handle, inode, path);
1862197217a5SYongqiang Yang }
1863197217a5SYongqiang Yang 
1864197217a5SYongqiang Yang /*
186525d14f98SAmit Arora  * check if a portion of the "newext" extent overlaps with an
186625d14f98SAmit Arora  * existing extent.
186725d14f98SAmit Arora  *
186825d14f98SAmit Arora  * If there is an overlap discovered, it updates the length of the newext
186925d14f98SAmit Arora  * such that there will be no overlap, and then returns 1.
187025d14f98SAmit Arora  * If there is no overlap found, it returns 0.
187125d14f98SAmit Arora  */
18724d33b1efSTheodore Ts'o static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi,
18734d33b1efSTheodore Ts'o 					   struct inode *inode,
187425d14f98SAmit Arora 					   struct ext4_extent *newext,
187525d14f98SAmit Arora 					   struct ext4_ext_path *path)
187625d14f98SAmit Arora {
1877725d26d3SAneesh Kumar K.V 	ext4_lblk_t b1, b2;
187825d14f98SAmit Arora 	unsigned int depth, len1;
187925d14f98SAmit Arora 	unsigned int ret = 0;
188025d14f98SAmit Arora 
188125d14f98SAmit Arora 	b1 = le32_to_cpu(newext->ee_block);
1882a2df2a63SAmit Arora 	len1 = ext4_ext_get_actual_len(newext);
188325d14f98SAmit Arora 	depth = ext_depth(inode);
188425d14f98SAmit Arora 	if (!path[depth].p_ext)
188525d14f98SAmit Arora 		goto out;
1886f5a44db5STheodore Ts'o 	b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block));
188725d14f98SAmit Arora 
188825d14f98SAmit Arora 	/*
188925d14f98SAmit Arora 	 * get the next allocated block if the extent in the path
189025d14f98SAmit Arora 	 * is before the requested block(s)
189125d14f98SAmit Arora 	 */
189225d14f98SAmit Arora 	if (b2 < b1) {
189325d14f98SAmit Arora 		b2 = ext4_ext_next_allocated_block(path);
1894f17722f9SLukas Czerner 		if (b2 == EXT_MAX_BLOCKS)
189525d14f98SAmit Arora 			goto out;
1896f5a44db5STheodore Ts'o 		b2 = EXT4_LBLK_CMASK(sbi, b2);
189725d14f98SAmit Arora 	}
189825d14f98SAmit Arora 
1899725d26d3SAneesh Kumar K.V 	/* check for wrap through zero on extent logical start block*/
190025d14f98SAmit Arora 	if (b1 + len1 < b1) {
1901f17722f9SLukas Czerner 		len1 = EXT_MAX_BLOCKS - b1;
190225d14f98SAmit Arora 		newext->ee_len = cpu_to_le16(len1);
190325d14f98SAmit Arora 		ret = 1;
190425d14f98SAmit Arora 	}
190525d14f98SAmit Arora 
190625d14f98SAmit Arora 	/* check for overlap */
190725d14f98SAmit Arora 	if (b1 + len1 > b2) {
190825d14f98SAmit Arora 		newext->ee_len = cpu_to_le16(b2 - b1);
190925d14f98SAmit Arora 		ret = 1;
191025d14f98SAmit Arora 	}
191125d14f98SAmit Arora out:
191225d14f98SAmit Arora 	return ret;
191325d14f98SAmit Arora }
191425d14f98SAmit Arora 
191525d14f98SAmit Arora /*
1916d0d856e8SRandy Dunlap  * ext4_ext_insert_extent:
1917d0d856e8SRandy Dunlap  * tries to merge requsted extent into the existing extent or
1918d0d856e8SRandy Dunlap  * inserts requested extent as new one into the tree,
1919d0d856e8SRandy Dunlap  * creating new leaf in the no-space case.
1920a86c6181SAlex Tomas  */
1921a86c6181SAlex Tomas int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1922dfe50809STheodore Ts'o 				struct ext4_ext_path **ppath,
1923107a7bd3STheodore Ts'o 				struct ext4_extent *newext, int gb_flags)
1924a86c6181SAlex Tomas {
1925dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
1926a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
1927a86c6181SAlex Tomas 	struct ext4_extent *ex, *fex;
1928a86c6181SAlex Tomas 	struct ext4_extent *nearex; /* nearest extent */
1929a86c6181SAlex Tomas 	struct ext4_ext_path *npath = NULL;
1930725d26d3SAneesh Kumar K.V 	int depth, len, err;
1931725d26d3SAneesh Kumar K.V 	ext4_lblk_t next;
1932556615dcSLukas Czerner 	int mb_flags = 0, unwritten;
1933a86c6181SAlex Tomas 
1934e3cf5d5dSTheodore Ts'o 	if (gb_flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
1935e3cf5d5dSTheodore Ts'o 		mb_flags |= EXT4_MB_DELALLOC_RESERVED;
1936273df556SFrank Mayhar 	if (unlikely(ext4_ext_get_actual_len(newext) == 0)) {
1937273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
19386a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1939273df556SFrank Mayhar 	}
1940a86c6181SAlex Tomas 	depth = ext_depth(inode);
1941a86c6181SAlex Tomas 	ex = path[depth].p_ext;
1942be8981beSLukas Czerner 	eh = path[depth].p_hdr;
1943273df556SFrank Mayhar 	if (unlikely(path[depth].p_hdr == NULL)) {
1944273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
19456a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
1946273df556SFrank Mayhar 	}
1947a86c6181SAlex Tomas 
1948a86c6181SAlex Tomas 	/* try to insert block into found extent and return */
1949107a7bd3STheodore Ts'o 	if (ex && !(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) {
1950be8981beSLukas Czerner 
1951be8981beSLukas Czerner 		/*
1952be8981beSLukas Czerner 		 * Try to see whether we should rather test the extent on
1953be8981beSLukas Czerner 		 * right from ex, or from the left of ex. This is because
1954ed8a1a76STheodore Ts'o 		 * ext4_find_extent() can return either extent on the
1955be8981beSLukas Czerner 		 * left, or on the right from the searched position. This
1956be8981beSLukas Czerner 		 * will make merging more effective.
1957be8981beSLukas Czerner 		 */
1958be8981beSLukas Czerner 		if (ex < EXT_LAST_EXTENT(eh) &&
1959be8981beSLukas Czerner 		    (le32_to_cpu(ex->ee_block) +
1960be8981beSLukas Czerner 		    ext4_ext_get_actual_len(ex) <
1961be8981beSLukas Czerner 		    le32_to_cpu(newext->ee_block))) {
1962be8981beSLukas Czerner 			ex += 1;
1963be8981beSLukas Czerner 			goto prepend;
1964be8981beSLukas Czerner 		} else if ((ex > EXT_FIRST_EXTENT(eh)) &&
1965be8981beSLukas Czerner 			   (le32_to_cpu(newext->ee_block) +
1966be8981beSLukas Czerner 			   ext4_ext_get_actual_len(newext) <
1967be8981beSLukas Czerner 			   le32_to_cpu(ex->ee_block)))
1968be8981beSLukas Czerner 			ex -= 1;
1969be8981beSLukas Czerner 
1970be8981beSLukas Czerner 		/* Try to append newex to the ex */
1971be8981beSLukas Czerner 		if (ext4_can_extents_be_merged(inode, ex, newext)) {
1972be8981beSLukas Czerner 			ext_debug("append [%d]%d block to %u:[%d]%d"
1973be8981beSLukas Czerner 				  "(from %llu)\n",
1974556615dcSLukas Czerner 				  ext4_ext_is_unwritten(newext),
1975a2df2a63SAmit Arora 				  ext4_ext_get_actual_len(newext),
1976a86c6181SAlex Tomas 				  le32_to_cpu(ex->ee_block),
1977556615dcSLukas Czerner 				  ext4_ext_is_unwritten(ex),
1978bf89d16fSTheodore Ts'o 				  ext4_ext_get_actual_len(ex),
1979bf89d16fSTheodore Ts'o 				  ext4_ext_pblock(ex));
1980be8981beSLukas Czerner 			err = ext4_ext_get_access(handle, inode,
1981be8981beSLukas Czerner 						  path + depth);
19827e028976SAvantika Mathur 			if (err)
1983a86c6181SAlex Tomas 				return err;
1984556615dcSLukas Czerner 			unwritten = ext4_ext_is_unwritten(ex);
1985a2df2a63SAmit Arora 			ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
1986a2df2a63SAmit Arora 					+ ext4_ext_get_actual_len(newext));
1987556615dcSLukas Czerner 			if (unwritten)
1988556615dcSLukas Czerner 				ext4_ext_mark_unwritten(ex);
1989a86c6181SAlex Tomas 			eh = path[depth].p_hdr;
1990a86c6181SAlex Tomas 			nearex = ex;
1991a86c6181SAlex Tomas 			goto merge;
1992a86c6181SAlex Tomas 		}
1993a86c6181SAlex Tomas 
1994be8981beSLukas Czerner prepend:
1995be8981beSLukas Czerner 		/* Try to prepend newex to the ex */
1996be8981beSLukas Czerner 		if (ext4_can_extents_be_merged(inode, newext, ex)) {
1997be8981beSLukas Czerner 			ext_debug("prepend %u[%d]%d block to %u:[%d]%d"
1998be8981beSLukas Czerner 				  "(from %llu)\n",
1999be8981beSLukas Czerner 				  le32_to_cpu(newext->ee_block),
2000556615dcSLukas Czerner 				  ext4_ext_is_unwritten(newext),
2001be8981beSLukas Czerner 				  ext4_ext_get_actual_len(newext),
2002be8981beSLukas Czerner 				  le32_to_cpu(ex->ee_block),
2003556615dcSLukas Czerner 				  ext4_ext_is_unwritten(ex),
2004be8981beSLukas Czerner 				  ext4_ext_get_actual_len(ex),
2005be8981beSLukas Czerner 				  ext4_ext_pblock(ex));
2006be8981beSLukas Czerner 			err = ext4_ext_get_access(handle, inode,
2007be8981beSLukas Czerner 						  path + depth);
2008be8981beSLukas Czerner 			if (err)
2009be8981beSLukas Czerner 				return err;
2010be8981beSLukas Czerner 
2011556615dcSLukas Czerner 			unwritten = ext4_ext_is_unwritten(ex);
2012be8981beSLukas Czerner 			ex->ee_block = newext->ee_block;
2013be8981beSLukas Czerner 			ext4_ext_store_pblock(ex, ext4_ext_pblock(newext));
2014be8981beSLukas Czerner 			ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
2015be8981beSLukas Czerner 					+ ext4_ext_get_actual_len(newext));
2016556615dcSLukas Czerner 			if (unwritten)
2017556615dcSLukas Czerner 				ext4_ext_mark_unwritten(ex);
2018be8981beSLukas Czerner 			eh = path[depth].p_hdr;
2019be8981beSLukas Czerner 			nearex = ex;
2020be8981beSLukas Czerner 			goto merge;
2021be8981beSLukas Czerner 		}
2022be8981beSLukas Czerner 	}
2023be8981beSLukas Czerner 
2024a86c6181SAlex Tomas 	depth = ext_depth(inode);
2025a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
2026a86c6181SAlex Tomas 	if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max))
2027a86c6181SAlex Tomas 		goto has_space;
2028a86c6181SAlex Tomas 
2029a86c6181SAlex Tomas 	/* probably next leaf has space for us? */
2030a86c6181SAlex Tomas 	fex = EXT_LAST_EXTENT(eh);
2031598dbdf2SRobin Dong 	next = EXT_MAX_BLOCKS;
2032598dbdf2SRobin Dong 	if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block))
20335718789dSRobin Dong 		next = ext4_ext_next_leaf_block(path);
2034598dbdf2SRobin Dong 	if (next != EXT_MAX_BLOCKS) {
203532de6756SYongqiang Yang 		ext_debug("next leaf block - %u\n", next);
2036a86c6181SAlex Tomas 		BUG_ON(npath != NULL);
203773c384c0STheodore Ts'o 		npath = ext4_find_extent(inode, next, NULL, gb_flags);
2038a86c6181SAlex Tomas 		if (IS_ERR(npath))
2039a86c6181SAlex Tomas 			return PTR_ERR(npath);
2040a86c6181SAlex Tomas 		BUG_ON(npath->p_depth != path->p_depth);
2041a86c6181SAlex Tomas 		eh = npath[depth].p_hdr;
2042a86c6181SAlex Tomas 		if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) {
204325985edcSLucas De Marchi 			ext_debug("next leaf isn't full(%d)\n",
2044a86c6181SAlex Tomas 				  le16_to_cpu(eh->eh_entries));
2045a86c6181SAlex Tomas 			path = npath;
2046ffb505ffSRobin Dong 			goto has_space;
2047a86c6181SAlex Tomas 		}
2048a86c6181SAlex Tomas 		ext_debug("next leaf has no free space(%d,%d)\n",
2049a86c6181SAlex Tomas 			  le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
2050a86c6181SAlex Tomas 	}
2051a86c6181SAlex Tomas 
2052a86c6181SAlex Tomas 	/*
2053d0d856e8SRandy Dunlap 	 * There is no free space in the found leaf.
2054d0d856e8SRandy Dunlap 	 * We're gonna add a new leaf in the tree.
2055a86c6181SAlex Tomas 	 */
2056107a7bd3STheodore Ts'o 	if (gb_flags & EXT4_GET_BLOCKS_METADATA_NOFAIL)
2057e3cf5d5dSTheodore Ts'o 		mb_flags |= EXT4_MB_USE_RESERVED;
2058107a7bd3STheodore Ts'o 	err = ext4_ext_create_new_leaf(handle, inode, mb_flags, gb_flags,
2059dfe50809STheodore Ts'o 				       ppath, newext);
2060a86c6181SAlex Tomas 	if (err)
2061a86c6181SAlex Tomas 		goto cleanup;
2062a86c6181SAlex Tomas 	depth = ext_depth(inode);
2063a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
2064a86c6181SAlex Tomas 
2065a86c6181SAlex Tomas has_space:
2066a86c6181SAlex Tomas 	nearex = path[depth].p_ext;
2067a86c6181SAlex Tomas 
20687e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, path + depth);
20697e028976SAvantika Mathur 	if (err)
2070a86c6181SAlex Tomas 		goto cleanup;
2071a86c6181SAlex Tomas 
2072a86c6181SAlex Tomas 	if (!nearex) {
2073a86c6181SAlex Tomas 		/* there is no extent in this leaf, create first one */
207432de6756SYongqiang Yang 		ext_debug("first extent in the leaf: %u:%llu:[%d]%d\n",
2075a86c6181SAlex Tomas 				le32_to_cpu(newext->ee_block),
2076bf89d16fSTheodore Ts'o 				ext4_ext_pblock(newext),
2077556615dcSLukas Czerner 				ext4_ext_is_unwritten(newext),
2078a2df2a63SAmit Arora 				ext4_ext_get_actual_len(newext));
207980e675f9SEric Gouriou 		nearex = EXT_FIRST_EXTENT(eh);
2080a86c6181SAlex Tomas 	} else {
208180e675f9SEric Gouriou 		if (le32_to_cpu(newext->ee_block)
208280e675f9SEric Gouriou 			   > le32_to_cpu(nearex->ee_block)) {
208380e675f9SEric Gouriou 			/* Insert after */
208432de6756SYongqiang Yang 			ext_debug("insert %u:%llu:[%d]%d before: "
208532de6756SYongqiang Yang 					"nearest %p\n",
2086a86c6181SAlex Tomas 					le32_to_cpu(newext->ee_block),
2087bf89d16fSTheodore Ts'o 					ext4_ext_pblock(newext),
2088556615dcSLukas Czerner 					ext4_ext_is_unwritten(newext),
2089a2df2a63SAmit Arora 					ext4_ext_get_actual_len(newext),
209080e675f9SEric Gouriou 					nearex);
209180e675f9SEric Gouriou 			nearex++;
209280e675f9SEric Gouriou 		} else {
209380e675f9SEric Gouriou 			/* Insert before */
209480e675f9SEric Gouriou 			BUG_ON(newext->ee_block == nearex->ee_block);
209532de6756SYongqiang Yang 			ext_debug("insert %u:%llu:[%d]%d after: "
209632de6756SYongqiang Yang 					"nearest %p\n",
209780e675f9SEric Gouriou 					le32_to_cpu(newext->ee_block),
209880e675f9SEric Gouriou 					ext4_ext_pblock(newext),
2099556615dcSLukas Czerner 					ext4_ext_is_unwritten(newext),
210080e675f9SEric Gouriou 					ext4_ext_get_actual_len(newext),
210180e675f9SEric Gouriou 					nearex);
210280e675f9SEric Gouriou 		}
210380e675f9SEric Gouriou 		len = EXT_LAST_EXTENT(eh) - nearex + 1;
210480e675f9SEric Gouriou 		if (len > 0) {
210532de6756SYongqiang Yang 			ext_debug("insert %u:%llu:[%d]%d: "
210680e675f9SEric Gouriou 					"move %d extents from 0x%p to 0x%p\n",
210780e675f9SEric Gouriou 					le32_to_cpu(newext->ee_block),
210880e675f9SEric Gouriou 					ext4_ext_pblock(newext),
2109556615dcSLukas Czerner 					ext4_ext_is_unwritten(newext),
211080e675f9SEric Gouriou 					ext4_ext_get_actual_len(newext),
211180e675f9SEric Gouriou 					len, nearex, nearex + 1);
211280e675f9SEric Gouriou 			memmove(nearex + 1, nearex,
211380e675f9SEric Gouriou 				len * sizeof(struct ext4_extent));
211480e675f9SEric Gouriou 		}
2115a86c6181SAlex Tomas 	}
2116a86c6181SAlex Tomas 
2117e8546d06SMarcin Slusarz 	le16_add_cpu(&eh->eh_entries, 1);
211880e675f9SEric Gouriou 	path[depth].p_ext = nearex;
2119a86c6181SAlex Tomas 	nearex->ee_block = newext->ee_block;
2120bf89d16fSTheodore Ts'o 	ext4_ext_store_pblock(nearex, ext4_ext_pblock(newext));
2121a86c6181SAlex Tomas 	nearex->ee_len = newext->ee_len;
2122a86c6181SAlex Tomas 
2123a86c6181SAlex Tomas merge:
2124e7bcf823SHaiboLiu 	/* try to merge extents */
2125107a7bd3STheodore Ts'o 	if (!(gb_flags & EXT4_GET_BLOCKS_PRE_IO))
2126ecb94f5fSTheodore Ts'o 		ext4_ext_try_to_merge(handle, inode, path, nearex);
2127a86c6181SAlex Tomas 
2128a86c6181SAlex Tomas 
2129a86c6181SAlex Tomas 	/* time to correct all indexes above */
2130a86c6181SAlex Tomas 	err = ext4_ext_correct_indexes(handle, inode, path);
2131a86c6181SAlex Tomas 	if (err)
2132a86c6181SAlex Tomas 		goto cleanup;
2133a86c6181SAlex Tomas 
2134ecb94f5fSTheodore Ts'o 	err = ext4_ext_dirty(handle, inode, path + path->p_depth);
2135a86c6181SAlex Tomas 
2136a86c6181SAlex Tomas cleanup:
2137a86c6181SAlex Tomas 	ext4_ext_drop_refs(npath);
2138a86c6181SAlex Tomas 	kfree(npath);
2139a86c6181SAlex Tomas 	return err;
2140a86c6181SAlex Tomas }
2141a86c6181SAlex Tomas 
2142bb5835edSTheodore Ts'o static int ext4_fill_es_cache_info(struct inode *inode,
2143bb5835edSTheodore Ts'o 				   ext4_lblk_t block, ext4_lblk_t num,
2144bb5835edSTheodore Ts'o 				   struct fiemap_extent_info *fieinfo)
2145bb5835edSTheodore Ts'o {
2146bb5835edSTheodore Ts'o 	ext4_lblk_t next, end = block + num - 1;
2147bb5835edSTheodore Ts'o 	struct extent_status es;
2148bb5835edSTheodore Ts'o 	unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
2149bb5835edSTheodore Ts'o 	unsigned int flags;
2150bb5835edSTheodore Ts'o 	int err;
2151bb5835edSTheodore Ts'o 
2152bb5835edSTheodore Ts'o 	while (block <= end) {
2153bb5835edSTheodore Ts'o 		next = 0;
2154bb5835edSTheodore Ts'o 		flags = 0;
2155bb5835edSTheodore Ts'o 		if (!ext4_es_lookup_extent(inode, block, &next, &es))
2156bb5835edSTheodore Ts'o 			break;
2157bb5835edSTheodore Ts'o 		if (ext4_es_is_unwritten(&es))
2158bb5835edSTheodore Ts'o 			flags |= FIEMAP_EXTENT_UNWRITTEN;
2159bb5835edSTheodore Ts'o 		if (ext4_es_is_delayed(&es))
2160bb5835edSTheodore Ts'o 			flags |= (FIEMAP_EXTENT_DELALLOC |
2161bb5835edSTheodore Ts'o 				  FIEMAP_EXTENT_UNKNOWN);
2162bb5835edSTheodore Ts'o 		if (ext4_es_is_hole(&es))
2163bb5835edSTheodore Ts'o 			flags |= EXT4_FIEMAP_EXTENT_HOLE;
2164bb5835edSTheodore Ts'o 		if (next == 0)
2165bb5835edSTheodore Ts'o 			flags |= FIEMAP_EXTENT_LAST;
2166bb5835edSTheodore Ts'o 		if (flags & (FIEMAP_EXTENT_DELALLOC|
2167bb5835edSTheodore Ts'o 			     EXT4_FIEMAP_EXTENT_HOLE))
2168bb5835edSTheodore Ts'o 			es.es_pblk = 0;
2169bb5835edSTheodore Ts'o 		else
2170bb5835edSTheodore Ts'o 			es.es_pblk = ext4_es_pblock(&es);
2171bb5835edSTheodore Ts'o 		err = fiemap_fill_next_extent(fieinfo,
2172bb5835edSTheodore Ts'o 				(__u64)es.es_lblk << blksize_bits,
2173bb5835edSTheodore Ts'o 				(__u64)es.es_pblk << blksize_bits,
2174bb5835edSTheodore Ts'o 				(__u64)es.es_len << blksize_bits,
2175bb5835edSTheodore Ts'o 				flags);
2176bb5835edSTheodore Ts'o 		if (next == 0)
2177bb5835edSTheodore Ts'o 			break;
2178bb5835edSTheodore Ts'o 		block = next;
2179bb5835edSTheodore Ts'o 		if (err < 0)
2180bb5835edSTheodore Ts'o 			return err;
2181bb5835edSTheodore Ts'o 		if (err == 1)
2182bb5835edSTheodore Ts'o 			return 0;
2183bb5835edSTheodore Ts'o 	}
2184bb5835edSTheodore Ts'o 	return 0;
2185bb5835edSTheodore Ts'o }
2186bb5835edSTheodore Ts'o 
2187bb5835edSTheodore Ts'o 
2188a86c6181SAlex Tomas /*
2189140a5250SJan Kara  * ext4_ext_determine_hole - determine hole around given block
2190140a5250SJan Kara  * @inode:	inode we lookup in
2191140a5250SJan Kara  * @path:	path in extent tree to @lblk
2192140a5250SJan Kara  * @lblk:	pointer to logical block around which we want to determine hole
2193140a5250SJan Kara  *
2194140a5250SJan Kara  * Determine hole length (and start if easily possible) around given logical
2195140a5250SJan Kara  * block. We don't try too hard to find the beginning of the hole but @path
2196140a5250SJan Kara  * actually points to extent before @lblk, we provide it.
2197140a5250SJan Kara  *
2198140a5250SJan Kara  * The function returns the length of a hole starting at @lblk. We update @lblk
2199140a5250SJan Kara  * to the beginning of the hole if we managed to find it.
2200140a5250SJan Kara  */
2201140a5250SJan Kara static ext4_lblk_t ext4_ext_determine_hole(struct inode *inode,
2202140a5250SJan Kara 					   struct ext4_ext_path *path,
2203140a5250SJan Kara 					   ext4_lblk_t *lblk)
2204140a5250SJan Kara {
2205140a5250SJan Kara 	int depth = ext_depth(inode);
2206140a5250SJan Kara 	struct ext4_extent *ex;
2207140a5250SJan Kara 	ext4_lblk_t len;
2208140a5250SJan Kara 
2209140a5250SJan Kara 	ex = path[depth].p_ext;
2210140a5250SJan Kara 	if (ex == NULL) {
2211140a5250SJan Kara 		/* there is no extent yet, so gap is [0;-] */
2212140a5250SJan Kara 		*lblk = 0;
2213140a5250SJan Kara 		len = EXT_MAX_BLOCKS;
2214140a5250SJan Kara 	} else if (*lblk < le32_to_cpu(ex->ee_block)) {
2215140a5250SJan Kara 		len = le32_to_cpu(ex->ee_block) - *lblk;
2216140a5250SJan Kara 	} else if (*lblk >= le32_to_cpu(ex->ee_block)
2217140a5250SJan Kara 			+ ext4_ext_get_actual_len(ex)) {
2218140a5250SJan Kara 		ext4_lblk_t next;
2219140a5250SJan Kara 
2220140a5250SJan Kara 		*lblk = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex);
2221140a5250SJan Kara 		next = ext4_ext_next_allocated_block(path);
2222140a5250SJan Kara 		BUG_ON(next == *lblk);
2223140a5250SJan Kara 		len = next - *lblk;
2224140a5250SJan Kara 	} else {
2225140a5250SJan Kara 		BUG();
2226140a5250SJan Kara 	}
2227140a5250SJan Kara 	return len;
2228140a5250SJan Kara }
2229140a5250SJan Kara 
2230140a5250SJan Kara /*
2231d0d856e8SRandy Dunlap  * ext4_ext_put_gap_in_cache:
2232d0d856e8SRandy Dunlap  * calculate boundaries of the gap that the requested block fits into
2233a86c6181SAlex Tomas  * and cache this gap
2234a86c6181SAlex Tomas  */
223509b88252SAvantika Mathur static void
2236140a5250SJan Kara ext4_ext_put_gap_in_cache(struct inode *inode, ext4_lblk_t hole_start,
2237140a5250SJan Kara 			  ext4_lblk_t hole_len)
2238a86c6181SAlex Tomas {
22392f8e0a7cSZheng Liu 	struct extent_status es;
2240a86c6181SAlex Tomas 
2241ad431025SEric Whitney 	ext4_es_find_extent_range(inode, &ext4_es_is_delayed, hole_start,
2242140a5250SJan Kara 				  hole_start + hole_len - 1, &es);
22432f8e0a7cSZheng Liu 	if (es.es_len) {
22442f8e0a7cSZheng Liu 		/* There's delayed extent containing lblock? */
2245140a5250SJan Kara 		if (es.es_lblk <= hole_start)
22462f8e0a7cSZheng Liu 			return;
2247140a5250SJan Kara 		hole_len = min(es.es_lblk - hole_start, hole_len);
22482f8e0a7cSZheng Liu 	}
2249140a5250SJan Kara 	ext_debug(" -> %u:%u\n", hole_start, hole_len);
2250140a5250SJan Kara 	ext4_es_insert_extent(inode, hole_start, hole_len, ~0,
2251140a5250SJan Kara 			      EXTENT_STATUS_HOLE);
2252a86c6181SAlex Tomas }
2253a86c6181SAlex Tomas 
2254a86c6181SAlex Tomas /*
2255d0d856e8SRandy Dunlap  * ext4_ext_rm_idx:
2256d0d856e8SRandy Dunlap  * removes index from the index block.
2257a86c6181SAlex Tomas  */
22581d03ec98SAneesh Kumar K.V static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
2259c36575e6SForrest Liu 			struct ext4_ext_path *path, int depth)
2260a86c6181SAlex Tomas {
2261a86c6181SAlex Tomas 	int err;
2262f65e6fbaSAlex Tomas 	ext4_fsblk_t leaf;
2263a86c6181SAlex Tomas 
2264a86c6181SAlex Tomas 	/* free index block */
2265c36575e6SForrest Liu 	depth--;
2266c36575e6SForrest Liu 	path = path + depth;
2267bf89d16fSTheodore Ts'o 	leaf = ext4_idx_pblock(path->p_idx);
2268273df556SFrank Mayhar 	if (unlikely(path->p_hdr->eh_entries == 0)) {
2269273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
22706a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
2271273df556SFrank Mayhar 	}
22727e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, path);
22737e028976SAvantika Mathur 	if (err)
2274a86c6181SAlex Tomas 		return err;
22750e1147b0SRobin Dong 
22760e1147b0SRobin Dong 	if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) {
22770e1147b0SRobin Dong 		int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx;
22780e1147b0SRobin Dong 		len *= sizeof(struct ext4_extent_idx);
22790e1147b0SRobin Dong 		memmove(path->p_idx, path->p_idx + 1, len);
22800e1147b0SRobin Dong 	}
22810e1147b0SRobin Dong 
2282e8546d06SMarcin Slusarz 	le16_add_cpu(&path->p_hdr->eh_entries, -1);
22837e028976SAvantika Mathur 	err = ext4_ext_dirty(handle, inode, path);
22847e028976SAvantika Mathur 	if (err)
2285a86c6181SAlex Tomas 		return err;
22862ae02107SMingming Cao 	ext_debug("index is empty, remove it, free block %llu\n", leaf);
2287d8990240SAditya Kali 	trace_ext4_ext_rm_idx(inode, leaf);
2288d8990240SAditya Kali 
22897dc57615SPeter Huewe 	ext4_free_blocks(handle, inode, NULL, leaf, 1,
2290e6362609STheodore Ts'o 			 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
2291c36575e6SForrest Liu 
2292c36575e6SForrest Liu 	while (--depth >= 0) {
2293c36575e6SForrest Liu 		if (path->p_idx != EXT_FIRST_INDEX(path->p_hdr))
2294c36575e6SForrest Liu 			break;
2295c36575e6SForrest Liu 		path--;
2296c36575e6SForrest Liu 		err = ext4_ext_get_access(handle, inode, path);
2297c36575e6SForrest Liu 		if (err)
2298c36575e6SForrest Liu 			break;
2299c36575e6SForrest Liu 		path->p_idx->ei_block = (path+1)->p_idx->ei_block;
2300c36575e6SForrest Liu 		err = ext4_ext_dirty(handle, inode, path);
2301c36575e6SForrest Liu 		if (err)
2302c36575e6SForrest Liu 			break;
2303c36575e6SForrest Liu 	}
2304a86c6181SAlex Tomas 	return err;
2305a86c6181SAlex Tomas }
2306a86c6181SAlex Tomas 
2307a86c6181SAlex Tomas /*
2308ee12b630SMingming Cao  * ext4_ext_calc_credits_for_single_extent:
2309ee12b630SMingming Cao  * This routine returns max. credits that needed to insert an extent
2310ee12b630SMingming Cao  * to the extent tree.
2311ee12b630SMingming Cao  * When pass the actual path, the caller should calculate credits
2312ee12b630SMingming Cao  * under i_data_sem.
2313a86c6181SAlex Tomas  */
2314525f4ed8SMingming Cao int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks,
2315a86c6181SAlex Tomas 						struct ext4_ext_path *path)
2316a86c6181SAlex Tomas {
2317a86c6181SAlex Tomas 	if (path) {
2318ee12b630SMingming Cao 		int depth = ext_depth(inode);
2319f3bd1f3fSMingming Cao 		int ret = 0;
2320ee12b630SMingming Cao 
2321a86c6181SAlex Tomas 		/* probably there is space in leaf? */
2322a86c6181SAlex Tomas 		if (le16_to_cpu(path[depth].p_hdr->eh_entries)
2323ee12b630SMingming Cao 				< le16_to_cpu(path[depth].p_hdr->eh_max)) {
2324ee12b630SMingming Cao 
2325ee12b630SMingming Cao 			/*
2326ee12b630SMingming Cao 			 *  There are some space in the leaf tree, no
2327ee12b630SMingming Cao 			 *  need to account for leaf block credit
2328ee12b630SMingming Cao 			 *
2329ee12b630SMingming Cao 			 *  bitmaps and block group descriptor blocks
2330df3ab170STao Ma 			 *  and other metadata blocks still need to be
2331ee12b630SMingming Cao 			 *  accounted.
2332ee12b630SMingming Cao 			 */
2333525f4ed8SMingming Cao 			/* 1 bitmap, 1 block group descriptor */
2334ee12b630SMingming Cao 			ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);
23355887e98bSAneesh Kumar K.V 			return ret;
2336ee12b630SMingming Cao 		}
2337ee12b630SMingming Cao 	}
2338ee12b630SMingming Cao 
2339525f4ed8SMingming Cao 	return ext4_chunk_trans_blocks(inode, nrblocks);
2340a86c6181SAlex Tomas }
2341a86c6181SAlex Tomas 
2342a86c6181SAlex Tomas /*
2343fffb2739SJan Kara  * How many index/leaf blocks need to change/allocate to add @extents extents?
2344ee12b630SMingming Cao  *
2345fffb2739SJan Kara  * If we add a single extent, then in the worse case, each tree level
2346fffb2739SJan Kara  * index/leaf need to be changed in case of the tree split.
2347ee12b630SMingming Cao  *
2348fffb2739SJan Kara  * If more extents are inserted, they could cause the whole tree split more
2349fffb2739SJan Kara  * than once, but this is really rare.
2350a86c6181SAlex Tomas  */
2351fffb2739SJan Kara int ext4_ext_index_trans_blocks(struct inode *inode, int extents)
2352ee12b630SMingming Cao {
2353ee12b630SMingming Cao 	int index;
2354f19d5870STao Ma 	int depth;
2355f19d5870STao Ma 
2356f19d5870STao Ma 	/* If we are converting the inline data, only one is needed here. */
2357f19d5870STao Ma 	if (ext4_has_inline_data(inode))
2358f19d5870STao Ma 		return 1;
2359f19d5870STao Ma 
2360f19d5870STao Ma 	depth = ext_depth(inode);
2361a86c6181SAlex Tomas 
2362fffb2739SJan Kara 	if (extents <= 1)
2363ee12b630SMingming Cao 		index = depth * 2;
2364ee12b630SMingming Cao 	else
2365ee12b630SMingming Cao 		index = depth * 3;
2366a86c6181SAlex Tomas 
2367ee12b630SMingming Cao 	return index;
2368a86c6181SAlex Tomas }
2369a86c6181SAlex Tomas 
2370981250caSTheodore Ts'o static inline int get_default_free_blocks_flags(struct inode *inode)
2371981250caSTheodore Ts'o {
2372ddfa17e4STahsin Erdogan 	if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) ||
2373ddfa17e4STahsin Erdogan 	    ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE))
2374981250caSTheodore Ts'o 		return EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET;
2375981250caSTheodore Ts'o 	else if (ext4_should_journal_data(inode))
2376981250caSTheodore Ts'o 		return EXT4_FREE_BLOCKS_FORGET;
2377981250caSTheodore Ts'o 	return 0;
2378981250caSTheodore Ts'o }
2379981250caSTheodore Ts'o 
23809fe67149SEric Whitney /*
23819fe67149SEric Whitney  * ext4_rereserve_cluster - increment the reserved cluster count when
23829fe67149SEric Whitney  *                          freeing a cluster with a pending reservation
23839fe67149SEric Whitney  *
23849fe67149SEric Whitney  * @inode - file containing the cluster
23859fe67149SEric Whitney  * @lblk - logical block in cluster to be reserved
23869fe67149SEric Whitney  *
23879fe67149SEric Whitney  * Increments the reserved cluster count and adjusts quota in a bigalloc
23889fe67149SEric Whitney  * file system when freeing a partial cluster containing at least one
23899fe67149SEric Whitney  * delayed and unwritten block.  A partial cluster meeting that
23909fe67149SEric Whitney  * requirement will have a pending reservation.  If so, the
23919fe67149SEric Whitney  * RERESERVE_CLUSTER flag is used when calling ext4_free_blocks() to
23929fe67149SEric Whitney  * defer reserved and allocated space accounting to a subsequent call
23939fe67149SEric Whitney  * to this function.
23949fe67149SEric Whitney  */
23959fe67149SEric Whitney static void ext4_rereserve_cluster(struct inode *inode, ext4_lblk_t lblk)
23969fe67149SEric Whitney {
23979fe67149SEric Whitney 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
23989fe67149SEric Whitney 	struct ext4_inode_info *ei = EXT4_I(inode);
23999fe67149SEric Whitney 
24009fe67149SEric Whitney 	dquot_reclaim_block(inode, EXT4_C2B(sbi, 1));
24019fe67149SEric Whitney 
24029fe67149SEric Whitney 	spin_lock(&ei->i_block_reservation_lock);
24039fe67149SEric Whitney 	ei->i_reserved_data_blocks++;
24049fe67149SEric Whitney 	percpu_counter_add(&sbi->s_dirtyclusters_counter, 1);
24059fe67149SEric Whitney 	spin_unlock(&ei->i_block_reservation_lock);
24069fe67149SEric Whitney 
24079fe67149SEric Whitney 	percpu_counter_add(&sbi->s_freeclusters_counter, 1);
24089fe67149SEric Whitney 	ext4_remove_pending(inode, lblk);
24099fe67149SEric Whitney }
24109fe67149SEric Whitney 
2411a86c6181SAlex Tomas static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
2412a86c6181SAlex Tomas 			      struct ext4_extent *ex,
24139fe67149SEric Whitney 			      struct partial_cluster *partial,
2414725d26d3SAneesh Kumar K.V 			      ext4_lblk_t from, ext4_lblk_t to)
2415a86c6181SAlex Tomas {
24160aa06000STheodore Ts'o 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2417a2df2a63SAmit Arora 	unsigned short ee_len = ext4_ext_get_actual_len(ex);
24189fe67149SEric Whitney 	ext4_fsblk_t last_pblk, pblk;
24199fe67149SEric Whitney 	ext4_lblk_t num;
24209fe67149SEric Whitney 	int flags;
242118888cf0SAndrey Sidorov 
24229fe67149SEric Whitney 	/* only extent tail removal is allowed */
24239fe67149SEric Whitney 	if (from < le32_to_cpu(ex->ee_block) ||
24249fe67149SEric Whitney 	    to != le32_to_cpu(ex->ee_block) + ee_len - 1) {
24259fe67149SEric Whitney 		ext4_error(sbi->s_sb,
24269fe67149SEric Whitney 			   "strange request: removal(2) %u-%u from %u:%u",
24279fe67149SEric Whitney 			   from, to, le32_to_cpu(ex->ee_block), ee_len);
24289fe67149SEric Whitney 		return 0;
24290aa06000STheodore Ts'o 	}
24300aa06000STheodore Ts'o 
2431a86c6181SAlex Tomas #ifdef EXTENTS_STATS
2432a86c6181SAlex Tomas 	spin_lock(&sbi->s_ext_stats_lock);
2433a86c6181SAlex Tomas 	sbi->s_ext_blocks += ee_len;
2434a86c6181SAlex Tomas 	sbi->s_ext_extents++;
2435a86c6181SAlex Tomas 	if (ee_len < sbi->s_ext_min)
2436a86c6181SAlex Tomas 		sbi->s_ext_min = ee_len;
2437a86c6181SAlex Tomas 	if (ee_len > sbi->s_ext_max)
2438a86c6181SAlex Tomas 		sbi->s_ext_max = ee_len;
2439a86c6181SAlex Tomas 	if (ext_depth(inode) > sbi->s_depth_max)
2440a86c6181SAlex Tomas 		sbi->s_depth_max = ext_depth(inode);
2441a86c6181SAlex Tomas 	spin_unlock(&sbi->s_ext_stats_lock);
2442a86c6181SAlex Tomas #endif
24439fe67149SEric Whitney 
24449fe67149SEric Whitney 	trace_ext4_remove_blocks(inode, ex, from, to, partial);
24459fe67149SEric Whitney 
24469fe67149SEric Whitney 	/*
24479fe67149SEric Whitney 	 * if we have a partial cluster, and it's different from the
24489fe67149SEric Whitney 	 * cluster of the last block in the extent, we free it
24499fe67149SEric Whitney 	 */
24509fe67149SEric Whitney 	last_pblk = ext4_ext_pblock(ex) + ee_len - 1;
24519fe67149SEric Whitney 
24529fe67149SEric Whitney 	if (partial->state != initial &&
24539fe67149SEric Whitney 	    partial->pclu != EXT4_B2C(sbi, last_pblk)) {
24549fe67149SEric Whitney 		if (partial->state == tofree) {
24559fe67149SEric Whitney 			flags = get_default_free_blocks_flags(inode);
24569fe67149SEric Whitney 			if (ext4_is_pending(inode, partial->lblk))
24579fe67149SEric Whitney 				flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
24589fe67149SEric Whitney 			ext4_free_blocks(handle, inode, NULL,
24599fe67149SEric Whitney 					 EXT4_C2B(sbi, partial->pclu),
24609fe67149SEric Whitney 					 sbi->s_cluster_ratio, flags);
24619fe67149SEric Whitney 			if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
24629fe67149SEric Whitney 				ext4_rereserve_cluster(inode, partial->lblk);
24639fe67149SEric Whitney 		}
24649fe67149SEric Whitney 		partial->state = initial;
24659fe67149SEric Whitney 	}
2466725d26d3SAneesh Kumar K.V 
2467a2df2a63SAmit Arora 	num = le32_to_cpu(ex->ee_block) + ee_len - from;
24680aa06000STheodore Ts'o 	pblk = ext4_ext_pblock(ex) + ee_len - num;
24699fe67149SEric Whitney 
2470d23142c6SLukas Czerner 	/*
24719fe67149SEric Whitney 	 * We free the partial cluster at the end of the extent (if any),
24729fe67149SEric Whitney 	 * unless the cluster is used by another extent (partial_cluster
24739fe67149SEric Whitney 	 * state is nofree).  If a partial cluster exists here, it must be
24749fe67149SEric Whitney 	 * shared with the last block in the extent.
2475d23142c6SLukas Czerner 	 */
24769fe67149SEric Whitney 	flags = get_default_free_blocks_flags(inode);
24779fe67149SEric Whitney 
24789fe67149SEric Whitney 	/* partial, left end cluster aligned, right end unaligned */
24799fe67149SEric Whitney 	if ((EXT4_LBLK_COFF(sbi, to) != sbi->s_cluster_ratio - 1) &&
24809fe67149SEric Whitney 	    (EXT4_LBLK_CMASK(sbi, to) >= from) &&
24819fe67149SEric Whitney 	    (partial->state != nofree)) {
24829fe67149SEric Whitney 		if (ext4_is_pending(inode, to))
24839fe67149SEric Whitney 			flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
24849fe67149SEric Whitney 		ext4_free_blocks(handle, inode, NULL,
24859fe67149SEric Whitney 				 EXT4_PBLK_CMASK(sbi, last_pblk),
24869fe67149SEric Whitney 				 sbi->s_cluster_ratio, flags);
24879fe67149SEric Whitney 		if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
24889fe67149SEric Whitney 			ext4_rereserve_cluster(inode, to);
24899fe67149SEric Whitney 		partial->state = initial;
24909fe67149SEric Whitney 		flags = get_default_free_blocks_flags(inode);
24919fe67149SEric Whitney 	}
24929fe67149SEric Whitney 
2493d23142c6SLukas Czerner 	flags |= EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER;
2494d23142c6SLukas Czerner 
24950aa06000STheodore Ts'o 	/*
24969fe67149SEric Whitney 	 * For bigalloc file systems, we never free a partial cluster
24979fe67149SEric Whitney 	 * at the beginning of the extent.  Instead, we check to see if we
24989fe67149SEric Whitney 	 * need to free it on a subsequent call to ext4_remove_blocks,
24999fe67149SEric Whitney 	 * or at the end of ext4_ext_rm_leaf or ext4_ext_remove_space.
25000aa06000STheodore Ts'o 	 */
25019fe67149SEric Whitney 	flags |= EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER;
25029fe67149SEric Whitney 	ext4_free_blocks(handle, inode, NULL, pblk, num, flags);
25039fe67149SEric Whitney 
25049fe67149SEric Whitney 	/* reset the partial cluster if we've freed past it */
25059fe67149SEric Whitney 	if (partial->state != initial && partial->pclu != EXT4_B2C(sbi, pblk))
25069fe67149SEric Whitney 		partial->state = initial;
25079fe67149SEric Whitney 
25089fe67149SEric Whitney 	/*
25099fe67149SEric Whitney 	 * If we've freed the entire extent but the beginning is not left
25109fe67149SEric Whitney 	 * cluster aligned and is not marked as ineligible for freeing we
25119fe67149SEric Whitney 	 * record the partial cluster at the beginning of the extent.  It
25129fe67149SEric Whitney 	 * wasn't freed by the preceding ext4_free_blocks() call, and we
25139fe67149SEric Whitney 	 * need to look farther to the left to determine if it's to be freed
25149fe67149SEric Whitney 	 * (not shared with another extent). Else, reset the partial
25159fe67149SEric Whitney 	 * cluster - we're either  done freeing or the beginning of the
25169fe67149SEric Whitney 	 * extent is left cluster aligned.
25179fe67149SEric Whitney 	 */
25189fe67149SEric Whitney 	if (EXT4_LBLK_COFF(sbi, from) && num == ee_len) {
25199fe67149SEric Whitney 		if (partial->state == initial) {
25209fe67149SEric Whitney 			partial->pclu = EXT4_B2C(sbi, pblk);
25219fe67149SEric Whitney 			partial->lblk = from;
25229fe67149SEric Whitney 			partial->state = tofree;
2523345ee947SEric Whitney 		}
25249fe67149SEric Whitney 	} else {
25259fe67149SEric Whitney 		partial->state = initial;
2526a86c6181SAlex Tomas 	}
2527a86c6181SAlex Tomas 
25289fe67149SEric Whitney 	return 0;
25299fe67149SEric Whitney }
2530d583fb87SAllison Henderson 
2531d583fb87SAllison Henderson /*
2532d583fb87SAllison Henderson  * ext4_ext_rm_leaf() Removes the extents associated with the
25335bf43760SEric Whitney  * blocks appearing between "start" and "end".  Both "start"
25345bf43760SEric Whitney  * and "end" must appear in the same extent or EIO is returned.
2535d583fb87SAllison Henderson  *
2536d583fb87SAllison Henderson  * @handle: The journal handle
2537d583fb87SAllison Henderson  * @inode:  The files inode
2538d583fb87SAllison Henderson  * @path:   The path to the leaf
2539d23142c6SLukas Czerner  * @partial_cluster: The cluster which we'll have to free if all extents
25405bf43760SEric Whitney  *                   has been released from it.  However, if this value is
25415bf43760SEric Whitney  *                   negative, it's a cluster just to the right of the
25425bf43760SEric Whitney  *                   punched region and it must not be freed.
2543d583fb87SAllison Henderson  * @start:  The first block to remove
2544d583fb87SAllison Henderson  * @end:   The last block to remove
2545d583fb87SAllison Henderson  */
2546a86c6181SAlex Tomas static int
2547a86c6181SAlex Tomas ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
2548d23142c6SLukas Czerner 		 struct ext4_ext_path *path,
25499fe67149SEric Whitney 		 struct partial_cluster *partial,
25500aa06000STheodore Ts'o 		 ext4_lblk_t start, ext4_lblk_t end)
2551a86c6181SAlex Tomas {
25520aa06000STheodore Ts'o 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2553a86c6181SAlex Tomas 	int err = 0, correct_index = 0;
255483448bdfSJan Kara 	int depth = ext_depth(inode), credits, revoke_credits;
2555a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
2556750c9c47SDmitry Monakhov 	ext4_lblk_t a, b;
2557725d26d3SAneesh Kumar K.V 	unsigned num;
2558725d26d3SAneesh Kumar K.V 	ext4_lblk_t ex_ee_block;
2559a86c6181SAlex Tomas 	unsigned short ex_ee_len;
2560556615dcSLukas Czerner 	unsigned unwritten = 0;
2561a86c6181SAlex Tomas 	struct ext4_extent *ex;
2562d23142c6SLukas Czerner 	ext4_fsblk_t pblk;
2563a86c6181SAlex Tomas 
2564c29c0ae7SAlex Tomas 	/* the header must be checked already in ext4_ext_remove_space() */
25655f95d21fSLukas Czerner 	ext_debug("truncate since %u in leaf to %u\n", start, end);
2566a86c6181SAlex Tomas 	if (!path[depth].p_hdr)
2567a86c6181SAlex Tomas 		path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);
2568a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
2569273df556SFrank Mayhar 	if (unlikely(path[depth].p_hdr == NULL)) {
2570273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
25716a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
2572273df556SFrank Mayhar 	}
2573a86c6181SAlex Tomas 	/* find where to start removing */
25746ae06ff5SAshish Sangwan 	ex = path[depth].p_ext;
25756ae06ff5SAshish Sangwan 	if (!ex)
2576a86c6181SAlex Tomas 		ex = EXT_LAST_EXTENT(eh);
2577a86c6181SAlex Tomas 
2578a86c6181SAlex Tomas 	ex_ee_block = le32_to_cpu(ex->ee_block);
2579a2df2a63SAmit Arora 	ex_ee_len = ext4_ext_get_actual_len(ex);
2580a86c6181SAlex Tomas 
25819fe67149SEric Whitney 	trace_ext4_ext_rm_leaf(inode, start, ex, partial);
2582d8990240SAditya Kali 
2583a86c6181SAlex Tomas 	while (ex >= EXT_FIRST_EXTENT(eh) &&
2584a86c6181SAlex Tomas 			ex_ee_block + ex_ee_len > start) {
2585a41f2071SAneesh Kumar K.V 
2586556615dcSLukas Czerner 		if (ext4_ext_is_unwritten(ex))
2587556615dcSLukas Czerner 			unwritten = 1;
2588a41f2071SAneesh Kumar K.V 		else
2589556615dcSLukas Czerner 			unwritten = 0;
2590a41f2071SAneesh Kumar K.V 
2591553f9008SMingming 		ext_debug("remove ext %u:[%d]%d\n", ex_ee_block,
2592556615dcSLukas Czerner 			  unwritten, ex_ee_len);
2593a86c6181SAlex Tomas 		path[depth].p_ext = ex;
2594a86c6181SAlex Tomas 
2595a86c6181SAlex Tomas 		a = ex_ee_block > start ? ex_ee_block : start;
2596d583fb87SAllison Henderson 		b = ex_ee_block+ex_ee_len - 1 < end ?
2597d583fb87SAllison Henderson 			ex_ee_block+ex_ee_len - 1 : end;
2598a86c6181SAlex Tomas 
2599a86c6181SAlex Tomas 		ext_debug("  border %u:%u\n", a, b);
2600a86c6181SAlex Tomas 
2601d583fb87SAllison Henderson 		/* If this extent is beyond the end of the hole, skip it */
26025f95d21fSLukas Czerner 		if (end < ex_ee_block) {
2603d23142c6SLukas Czerner 			/*
2604d23142c6SLukas Czerner 			 * We're going to skip this extent and move to another,
2605f4226d9eSEric Whitney 			 * so note that its first cluster is in use to avoid
2606f4226d9eSEric Whitney 			 * freeing it when removing blocks.  Eventually, the
2607f4226d9eSEric Whitney 			 * right edge of the truncated/punched region will
2608f4226d9eSEric Whitney 			 * be just to the left.
2609d23142c6SLukas Czerner 			 */
2610f4226d9eSEric Whitney 			if (sbi->s_cluster_ratio > 1) {
2611d23142c6SLukas Czerner 				pblk = ext4_ext_pblock(ex);
26129fe67149SEric Whitney 				partial->pclu = EXT4_B2C(sbi, pblk);
26139fe67149SEric Whitney 				partial->state = nofree;
2614f4226d9eSEric Whitney 			}
2615d583fb87SAllison Henderson 			ex--;
2616d583fb87SAllison Henderson 			ex_ee_block = le32_to_cpu(ex->ee_block);
2617d583fb87SAllison Henderson 			ex_ee_len = ext4_ext_get_actual_len(ex);
2618d583fb87SAllison Henderson 			continue;
2619750c9c47SDmitry Monakhov 		} else if (b != ex_ee_block + ex_ee_len - 1) {
2620dc1841d6SLukas Czerner 			EXT4_ERROR_INODE(inode,
2621dc1841d6SLukas Czerner 					 "can not handle truncate %u:%u "
2622dc1841d6SLukas Czerner 					 "on extent %u:%u",
2623dc1841d6SLukas Czerner 					 start, end, ex_ee_block,
2624dc1841d6SLukas Czerner 					 ex_ee_block + ex_ee_len - 1);
26256a797d27SDarrick J. Wong 			err = -EFSCORRUPTED;
2626d583fb87SAllison Henderson 			goto out;
2627a86c6181SAlex Tomas 		} else if (a != ex_ee_block) {
2628a86c6181SAlex Tomas 			/* remove tail of the extent */
2629750c9c47SDmitry Monakhov 			num = a - ex_ee_block;
2630a86c6181SAlex Tomas 		} else {
2631a86c6181SAlex Tomas 			/* remove whole extent: excellent! */
2632a86c6181SAlex Tomas 			num = 0;
2633d583fb87SAllison Henderson 		}
263434071da7STheodore Ts'o 		/*
263534071da7STheodore Ts'o 		 * 3 for leaf, sb, and inode plus 2 (bmap and group
263634071da7STheodore Ts'o 		 * descriptor) for each block group; assume two block
263734071da7STheodore Ts'o 		 * groups plus ex_ee_len/blocks_per_block_group for
263834071da7STheodore Ts'o 		 * the worst case
263934071da7STheodore Ts'o 		 */
264034071da7STheodore Ts'o 		credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
2641a86c6181SAlex Tomas 		if (ex == EXT_FIRST_EXTENT(eh)) {
2642a86c6181SAlex Tomas 			correct_index = 1;
2643a86c6181SAlex Tomas 			credits += (ext_depth(inode)) + 1;
2644a86c6181SAlex Tomas 		}
26455aca07ebSDmitry Monakhov 		credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
264683448bdfSJan Kara 		/*
264783448bdfSJan Kara 		 * We may end up freeing some index blocks and data from the
264883448bdfSJan Kara 		 * punched range. Note that partial clusters are accounted for
264983448bdfSJan Kara 		 * by ext4_free_data_revoke_credits().
265083448bdfSJan Kara 		 */
265183448bdfSJan Kara 		revoke_credits =
265283448bdfSJan Kara 			ext4_free_metadata_revoke_credits(inode->i_sb,
265383448bdfSJan Kara 							  ext_depth(inode)) +
265483448bdfSJan Kara 			ext4_free_data_revoke_credits(inode, b - a + 1);
2655a86c6181SAlex Tomas 
2656a4130367SJan Kara 		err = ext4_datasem_ensure_credits(handle, inode, credits,
265783448bdfSJan Kara 						  credits, revoke_credits);
2658a4130367SJan Kara 		if (err) {
2659a4130367SJan Kara 			if (err > 0)
2660a4130367SJan Kara 				err = -EAGAIN;
2661a86c6181SAlex Tomas 			goto out;
2662a4130367SJan Kara 		}
2663a86c6181SAlex Tomas 
2664a86c6181SAlex Tomas 		err = ext4_ext_get_access(handle, inode, path + depth);
2665a86c6181SAlex Tomas 		if (err)
2666a86c6181SAlex Tomas 			goto out;
2667a86c6181SAlex Tomas 
26689fe67149SEric Whitney 		err = ext4_remove_blocks(handle, inode, ex, partial, a, b);
2669a86c6181SAlex Tomas 		if (err)
2670a86c6181SAlex Tomas 			goto out;
2671a86c6181SAlex Tomas 
2672750c9c47SDmitry Monakhov 		if (num == 0)
2673d0d856e8SRandy Dunlap 			/* this extent is removed; mark slot entirely unused */
2674f65e6fbaSAlex Tomas 			ext4_ext_store_pblock(ex, 0);
2675a86c6181SAlex Tomas 
2676a86c6181SAlex Tomas 		ex->ee_len = cpu_to_le16(num);
2677749269faSAmit Arora 		/*
2678556615dcSLukas Czerner 		 * Do not mark unwritten if all the blocks in the
2679749269faSAmit Arora 		 * extent have been removed.
2680749269faSAmit Arora 		 */
2681556615dcSLukas Czerner 		if (unwritten && num)
2682556615dcSLukas Czerner 			ext4_ext_mark_unwritten(ex);
2683d583fb87SAllison Henderson 		/*
2684d583fb87SAllison Henderson 		 * If the extent was completely released,
2685d583fb87SAllison Henderson 		 * we need to remove it from the leaf
2686d583fb87SAllison Henderson 		 */
2687d583fb87SAllison Henderson 		if (num == 0) {
2688f17722f9SLukas Czerner 			if (end != EXT_MAX_BLOCKS - 1) {
2689d583fb87SAllison Henderson 				/*
2690d583fb87SAllison Henderson 				 * For hole punching, we need to scoot all the
2691d583fb87SAllison Henderson 				 * extents up when an extent is removed so that
2692d583fb87SAllison Henderson 				 * we dont have blank extents in the middle
2693d583fb87SAllison Henderson 				 */
2694d583fb87SAllison Henderson 				memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) *
2695d583fb87SAllison Henderson 					sizeof(struct ext4_extent));
2696d583fb87SAllison Henderson 
2697d583fb87SAllison Henderson 				/* Now get rid of the one at the end */
2698d583fb87SAllison Henderson 				memset(EXT_LAST_EXTENT(eh), 0,
2699d583fb87SAllison Henderson 					sizeof(struct ext4_extent));
2700d583fb87SAllison Henderson 			}
2701d583fb87SAllison Henderson 			le16_add_cpu(&eh->eh_entries, -1);
27025bf43760SEric Whitney 		}
2703d583fb87SAllison Henderson 
2704750c9c47SDmitry Monakhov 		err = ext4_ext_dirty(handle, inode, path + depth);
2705750c9c47SDmitry Monakhov 		if (err)
2706750c9c47SDmitry Monakhov 			goto out;
2707750c9c47SDmitry Monakhov 
2708bf52c6f7SYongqiang Yang 		ext_debug("new extent: %u:%u:%llu\n", ex_ee_block, num,
2709bf89d16fSTheodore Ts'o 				ext4_ext_pblock(ex));
2710a86c6181SAlex Tomas 		ex--;
2711a86c6181SAlex Tomas 		ex_ee_block = le32_to_cpu(ex->ee_block);
2712a2df2a63SAmit Arora 		ex_ee_len = ext4_ext_get_actual_len(ex);
2713a86c6181SAlex Tomas 	}
2714a86c6181SAlex Tomas 
2715a86c6181SAlex Tomas 	if (correct_index && eh->eh_entries)
2716a86c6181SAlex Tomas 		err = ext4_ext_correct_indexes(handle, inode, path);
2717a86c6181SAlex Tomas 
27180aa06000STheodore Ts'o 	/*
2719ad6599abSEric Whitney 	 * If there's a partial cluster and at least one extent remains in
2720ad6599abSEric Whitney 	 * the leaf, free the partial cluster if it isn't shared with the
27215bf43760SEric Whitney 	 * current extent.  If it is shared with the current extent
27229fe67149SEric Whitney 	 * we reset the partial cluster because we've reached the start of the
27235bf43760SEric Whitney 	 * truncated/punched region and we're done removing blocks.
27240aa06000STheodore Ts'o 	 */
27259fe67149SEric Whitney 	if (partial->state == tofree && ex >= EXT_FIRST_EXTENT(eh)) {
27265bf43760SEric Whitney 		pblk = ext4_ext_pblock(ex) + ex_ee_len - 1;
27279fe67149SEric Whitney 		if (partial->pclu != EXT4_B2C(sbi, pblk)) {
27289fe67149SEric Whitney 			int flags = get_default_free_blocks_flags(inode);
27299fe67149SEric Whitney 
27309fe67149SEric Whitney 			if (ext4_is_pending(inode, partial->lblk))
27319fe67149SEric Whitney 				flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
27320aa06000STheodore Ts'o 			ext4_free_blocks(handle, inode, NULL,
27339fe67149SEric Whitney 					 EXT4_C2B(sbi, partial->pclu),
27349fe67149SEric Whitney 					 sbi->s_cluster_ratio, flags);
27359fe67149SEric Whitney 			if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
27369fe67149SEric Whitney 				ext4_rereserve_cluster(inode, partial->lblk);
27375bf43760SEric Whitney 		}
27389fe67149SEric Whitney 		partial->state = initial;
27390aa06000STheodore Ts'o 	}
27400aa06000STheodore Ts'o 
2741a86c6181SAlex Tomas 	/* if this leaf is free, then we should
2742a86c6181SAlex Tomas 	 * remove it from index block above */
2743a86c6181SAlex Tomas 	if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
2744c36575e6SForrest Liu 		err = ext4_ext_rm_idx(handle, inode, path, depth);
2745a86c6181SAlex Tomas 
2746a86c6181SAlex Tomas out:
2747a86c6181SAlex Tomas 	return err;
2748a86c6181SAlex Tomas }
2749a86c6181SAlex Tomas 
2750a86c6181SAlex Tomas /*
2751d0d856e8SRandy Dunlap  * ext4_ext_more_to_rm:
2752d0d856e8SRandy Dunlap  * returns 1 if current index has to be freed (even partial)
2753a86c6181SAlex Tomas  */
275409b88252SAvantika Mathur static int
2755a86c6181SAlex Tomas ext4_ext_more_to_rm(struct ext4_ext_path *path)
2756a86c6181SAlex Tomas {
2757a86c6181SAlex Tomas 	BUG_ON(path->p_idx == NULL);
2758a86c6181SAlex Tomas 
2759a86c6181SAlex Tomas 	if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr))
2760a86c6181SAlex Tomas 		return 0;
2761a86c6181SAlex Tomas 
2762a86c6181SAlex Tomas 	/*
2763d0d856e8SRandy Dunlap 	 * if truncate on deeper level happened, it wasn't partial,
2764a86c6181SAlex Tomas 	 * so we have to consider current index for truncation
2765a86c6181SAlex Tomas 	 */
2766a86c6181SAlex Tomas 	if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)
2767a86c6181SAlex Tomas 		return 0;
2768a86c6181SAlex Tomas 	return 1;
2769a86c6181SAlex Tomas }
2770a86c6181SAlex Tomas 
277126a4c0c6STheodore Ts'o int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
27725f95d21fSLukas Czerner 			  ext4_lblk_t end)
2773a86c6181SAlex Tomas {
2774f4226d9eSEric Whitney 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2775a86c6181SAlex Tomas 	int depth = ext_depth(inode);
2776968dee77SAshish Sangwan 	struct ext4_ext_path *path = NULL;
27779fe67149SEric Whitney 	struct partial_cluster partial;
2778a86c6181SAlex Tomas 	handle_t *handle;
27796f2080e6SDmitry Monakhov 	int i = 0, err = 0;
2780a86c6181SAlex Tomas 
27819fe67149SEric Whitney 	partial.pclu = 0;
27829fe67149SEric Whitney 	partial.lblk = 0;
27839fe67149SEric Whitney 	partial.state = initial;
27849fe67149SEric Whitney 
27855f95d21fSLukas Czerner 	ext_debug("truncate since %u to %u\n", start, end);
2786a86c6181SAlex Tomas 
2787a86c6181SAlex Tomas 	/* probably first extent we're gonna free will be last in block */
278883448bdfSJan Kara 	handle = ext4_journal_start_with_revoke(inode, EXT4_HT_TRUNCATE,
278983448bdfSJan Kara 			depth + 1,
279083448bdfSJan Kara 			ext4_free_metadata_revoke_credits(inode->i_sb, depth));
2791a86c6181SAlex Tomas 	if (IS_ERR(handle))
2792a86c6181SAlex Tomas 		return PTR_ERR(handle);
2793a86c6181SAlex Tomas 
27940617b83fSDmitry Monakhov again:
279561801325SLukas Czerner 	trace_ext4_ext_remove_space(inode, start, end, depth);
2796d8990240SAditya Kali 
2797a86c6181SAlex Tomas 	/*
27985f95d21fSLukas Czerner 	 * Check if we are removing extents inside the extent tree. If that
27995f95d21fSLukas Czerner 	 * is the case, we are going to punch a hole inside the extent tree
28005f95d21fSLukas Czerner 	 * so we have to check whether we need to split the extent covering
28015f95d21fSLukas Czerner 	 * the last block to remove so we can easily remove the part of it
28025f95d21fSLukas Czerner 	 * in ext4_ext_rm_leaf().
28035f95d21fSLukas Czerner 	 */
28045f95d21fSLukas Czerner 	if (end < EXT_MAX_BLOCKS - 1) {
28055f95d21fSLukas Czerner 		struct ext4_extent *ex;
2806f4226d9eSEric Whitney 		ext4_lblk_t ee_block, ex_end, lblk;
2807f4226d9eSEric Whitney 		ext4_fsblk_t pblk;
28085f95d21fSLukas Czerner 
2809f4226d9eSEric Whitney 		/* find extent for or closest extent to this block */
281073c384c0STheodore Ts'o 		path = ext4_find_extent(inode, end, NULL,
281173c384c0STheodore Ts'o 					EXT4_EX_NOCACHE | EXT4_EX_NOFAIL);
28125f95d21fSLukas Czerner 		if (IS_ERR(path)) {
28135f95d21fSLukas Czerner 			ext4_journal_stop(handle);
28145f95d21fSLukas Czerner 			return PTR_ERR(path);
28155f95d21fSLukas Czerner 		}
28165f95d21fSLukas Czerner 		depth = ext_depth(inode);
28176f2080e6SDmitry Monakhov 		/* Leaf not may not exist only if inode has no blocks at all */
28185f95d21fSLukas Czerner 		ex = path[depth].p_ext;
2819968dee77SAshish Sangwan 		if (!ex) {
28206f2080e6SDmitry Monakhov 			if (depth) {
28216f2080e6SDmitry Monakhov 				EXT4_ERROR_INODE(inode,
28226f2080e6SDmitry Monakhov 						 "path[%d].p_hdr == NULL",
28236f2080e6SDmitry Monakhov 						 depth);
28246a797d27SDarrick J. Wong 				err = -EFSCORRUPTED;
28256f2080e6SDmitry Monakhov 			}
28266f2080e6SDmitry Monakhov 			goto out;
2827968dee77SAshish Sangwan 		}
28285f95d21fSLukas Czerner 
28295f95d21fSLukas Czerner 		ee_block = le32_to_cpu(ex->ee_block);
2830f4226d9eSEric Whitney 		ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1;
28315f95d21fSLukas Czerner 
28325f95d21fSLukas Czerner 		/*
28335f95d21fSLukas Czerner 		 * See if the last block is inside the extent, if so split
28345f95d21fSLukas Czerner 		 * the extent at 'end' block so we can easily remove the
28355f95d21fSLukas Czerner 		 * tail of the first part of the split extent in
28365f95d21fSLukas Czerner 		 * ext4_ext_rm_leaf().
28375f95d21fSLukas Czerner 		 */
2838f4226d9eSEric Whitney 		if (end >= ee_block && end < ex_end) {
2839f4226d9eSEric Whitney 
2840f4226d9eSEric Whitney 			/*
2841f4226d9eSEric Whitney 			 * If we're going to split the extent, note that
2842f4226d9eSEric Whitney 			 * the cluster containing the block after 'end' is
2843f4226d9eSEric Whitney 			 * in use to avoid freeing it when removing blocks.
2844f4226d9eSEric Whitney 			 */
2845f4226d9eSEric Whitney 			if (sbi->s_cluster_ratio > 1) {
2846f4226d9eSEric Whitney 				pblk = ext4_ext_pblock(ex) + end - ee_block + 2;
28479fe67149SEric Whitney 				partial.pclu = EXT4_B2C(sbi, pblk);
28489fe67149SEric Whitney 				partial.state = nofree;
2849f4226d9eSEric Whitney 			}
2850f4226d9eSEric Whitney 
28515f95d21fSLukas Czerner 			/*
28525f95d21fSLukas Czerner 			 * Split the extent in two so that 'end' is the last
285327dd4385SLukas Czerner 			 * block in the first new extent. Also we should not
285427dd4385SLukas Czerner 			 * fail removing space due to ENOSPC so try to use
285527dd4385SLukas Czerner 			 * reserved block if that happens.
28565f95d21fSLukas Czerner 			 */
2857dfe50809STheodore Ts'o 			err = ext4_force_split_extent_at(handle, inode, &path,
2858fcf6b1b7SDmitry Monakhov 							 end + 1, 1);
28595f95d21fSLukas Czerner 			if (err < 0)
28605f95d21fSLukas Czerner 				goto out;
2861f4226d9eSEric Whitney 
28627bd75230SEric Whitney 		} else if (sbi->s_cluster_ratio > 1 && end >= ex_end &&
28637bd75230SEric Whitney 			   partial.state == initial) {
2864f4226d9eSEric Whitney 			/*
28657bd75230SEric Whitney 			 * If we're punching, there's an extent to the right.
28667bd75230SEric Whitney 			 * If the partial cluster hasn't been set, set it to
28677bd75230SEric Whitney 			 * that extent's first cluster and its state to nofree
28687bd75230SEric Whitney 			 * so it won't be freed should it contain blocks to be
28697bd75230SEric Whitney 			 * removed. If it's already set (tofree/nofree), we're
28707bd75230SEric Whitney 			 * retrying and keep the original partial cluster info
28717bd75230SEric Whitney 			 * so a cluster marked tofree as a result of earlier
28727bd75230SEric Whitney 			 * extent removal is not lost.
2873f4226d9eSEric Whitney 			 */
2874f4226d9eSEric Whitney 			lblk = ex_end + 1;
2875f4226d9eSEric Whitney 			err = ext4_ext_search_right(inode, path, &lblk, &pblk,
2876f4226d9eSEric Whitney 						    &ex);
2877f4226d9eSEric Whitney 			if (err)
2878f4226d9eSEric Whitney 				goto out;
28799fe67149SEric Whitney 			if (pblk) {
28809fe67149SEric Whitney 				partial.pclu = EXT4_B2C(sbi, pblk);
28819fe67149SEric Whitney 				partial.state = nofree;
28829fe67149SEric Whitney 			}
28835f95d21fSLukas Czerner 		}
28845f95d21fSLukas Czerner 	}
28855f95d21fSLukas Czerner 	/*
2886d0d856e8SRandy Dunlap 	 * We start scanning from right side, freeing all the blocks
2887d0d856e8SRandy Dunlap 	 * after i_size and walking into the tree depth-wise.
2888a86c6181SAlex Tomas 	 */
28890617b83fSDmitry Monakhov 	depth = ext_depth(inode);
2890968dee77SAshish Sangwan 	if (path) {
2891968dee77SAshish Sangwan 		int k = i = depth;
2892968dee77SAshish Sangwan 		while (--k > 0)
2893968dee77SAshish Sangwan 			path[k].p_block =
2894968dee77SAshish Sangwan 				le16_to_cpu(path[k].p_hdr->eh_entries)+1;
2895968dee77SAshish Sangwan 	} else {
28966396bb22SKees Cook 		path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
289773c384c0STheodore Ts'o 			       GFP_NOFS | __GFP_NOFAIL);
2898a86c6181SAlex Tomas 		if (path == NULL) {
2899a86c6181SAlex Tomas 			ext4_journal_stop(handle);
2900a86c6181SAlex Tomas 			return -ENOMEM;
2901a86c6181SAlex Tomas 		}
290210809df8STheodore Ts'o 		path[0].p_maxdepth = path[0].p_depth = depth;
2903a86c6181SAlex Tomas 		path[0].p_hdr = ext_inode_hdr(inode);
290489a4e48fSTheodore Ts'o 		i = 0;
29055f95d21fSLukas Czerner 
2906c349179bSTheodore Ts'o 		if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
29076a797d27SDarrick J. Wong 			err = -EFSCORRUPTED;
2908a86c6181SAlex Tomas 			goto out;
2909a86c6181SAlex Tomas 		}
2910968dee77SAshish Sangwan 	}
2911968dee77SAshish Sangwan 	err = 0;
2912a86c6181SAlex Tomas 
2913a86c6181SAlex Tomas 	while (i >= 0 && err == 0) {
2914a86c6181SAlex Tomas 		if (i == depth) {
2915a86c6181SAlex Tomas 			/* this is leaf block */
2916d583fb87SAllison Henderson 			err = ext4_ext_rm_leaf(handle, inode, path,
29179fe67149SEric Whitney 					       &partial, start, end);
2918d0d856e8SRandy Dunlap 			/* root level has p_bh == NULL, brelse() eats this */
2919a86c6181SAlex Tomas 			brelse(path[i].p_bh);
2920a86c6181SAlex Tomas 			path[i].p_bh = NULL;
2921a86c6181SAlex Tomas 			i--;
2922a86c6181SAlex Tomas 			continue;
2923a86c6181SAlex Tomas 		}
2924a86c6181SAlex Tomas 
2925a86c6181SAlex Tomas 		/* this is index block */
2926a86c6181SAlex Tomas 		if (!path[i].p_hdr) {
2927a86c6181SAlex Tomas 			ext_debug("initialize header\n");
2928a86c6181SAlex Tomas 			path[i].p_hdr = ext_block_hdr(path[i].p_bh);
2929a86c6181SAlex Tomas 		}
2930a86c6181SAlex Tomas 
2931a86c6181SAlex Tomas 		if (!path[i].p_idx) {
2932d0d856e8SRandy Dunlap 			/* this level hasn't been touched yet */
2933a86c6181SAlex Tomas 			path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
2934a86c6181SAlex Tomas 			path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
2935a86c6181SAlex Tomas 			ext_debug("init index ptr: hdr 0x%p, num %d\n",
2936a86c6181SAlex Tomas 				  path[i].p_hdr,
2937a86c6181SAlex Tomas 				  le16_to_cpu(path[i].p_hdr->eh_entries));
2938a86c6181SAlex Tomas 		} else {
2939d0d856e8SRandy Dunlap 			/* we were already here, see at next index */
2940a86c6181SAlex Tomas 			path[i].p_idx--;
2941a86c6181SAlex Tomas 		}
2942a86c6181SAlex Tomas 
2943a86c6181SAlex Tomas 		ext_debug("level %d - index, first 0x%p, cur 0x%p\n",
2944a86c6181SAlex Tomas 				i, EXT_FIRST_INDEX(path[i].p_hdr),
2945a86c6181SAlex Tomas 				path[i].p_idx);
2946a86c6181SAlex Tomas 		if (ext4_ext_more_to_rm(path + i)) {
2947c29c0ae7SAlex Tomas 			struct buffer_head *bh;
2948a86c6181SAlex Tomas 			/* go to the next level */
29492ae02107SMingming Cao 			ext_debug("move to level %d (block %llu)\n",
2950bf89d16fSTheodore Ts'o 				  i + 1, ext4_idx_pblock(path[i].p_idx));
2951a86c6181SAlex Tomas 			memset(path + i + 1, 0, sizeof(*path));
29527d7ea89eSTheodore Ts'o 			bh = read_extent_tree_block(inode,
2953107a7bd3STheodore Ts'o 				ext4_idx_pblock(path[i].p_idx), depth - i - 1,
2954107a7bd3STheodore Ts'o 				EXT4_EX_NOCACHE);
29557d7ea89eSTheodore Ts'o 			if (IS_ERR(bh)) {
2956a86c6181SAlex Tomas 				/* should we reset i_size? */
29577d7ea89eSTheodore Ts'o 				err = PTR_ERR(bh);
2958a86c6181SAlex Tomas 				break;
2959a86c6181SAlex Tomas 			}
296076828c88STheodore Ts'o 			/* Yield here to deal with large extent trees.
296176828c88STheodore Ts'o 			 * Should be a no-op if we did IO above. */
296276828c88STheodore Ts'o 			cond_resched();
2963c29c0ae7SAlex Tomas 			if (WARN_ON(i + 1 > depth)) {
29646a797d27SDarrick J. Wong 				err = -EFSCORRUPTED;
2965c29c0ae7SAlex Tomas 				break;
2966c29c0ae7SAlex Tomas 			}
2967c29c0ae7SAlex Tomas 			path[i + 1].p_bh = bh;
2968a86c6181SAlex Tomas 
2969d0d856e8SRandy Dunlap 			/* save actual number of indexes since this
2970d0d856e8SRandy Dunlap 			 * number is changed at the next iteration */
2971a86c6181SAlex Tomas 			path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
2972a86c6181SAlex Tomas 			i++;
2973a86c6181SAlex Tomas 		} else {
2974d0d856e8SRandy Dunlap 			/* we finished processing this index, go up */
2975a86c6181SAlex Tomas 			if (path[i].p_hdr->eh_entries == 0 && i > 0) {
2976d0d856e8SRandy Dunlap 				/* index is empty, remove it;
2977a86c6181SAlex Tomas 				 * handle must be already prepared by the
2978a86c6181SAlex Tomas 				 * truncatei_leaf() */
2979c36575e6SForrest Liu 				err = ext4_ext_rm_idx(handle, inode, path, i);
2980a86c6181SAlex Tomas 			}
2981d0d856e8SRandy Dunlap 			/* root level has p_bh == NULL, brelse() eats this */
2982a86c6181SAlex Tomas 			brelse(path[i].p_bh);
2983a86c6181SAlex Tomas 			path[i].p_bh = NULL;
2984a86c6181SAlex Tomas 			i--;
2985a86c6181SAlex Tomas 			ext_debug("return to level %d\n", i);
2986a86c6181SAlex Tomas 		}
2987a86c6181SAlex Tomas 	}
2988a86c6181SAlex Tomas 
29899fe67149SEric Whitney 	trace_ext4_ext_remove_space_done(inode, start, end, depth, &partial,
29909fe67149SEric Whitney 					 path->p_hdr->eh_entries);
2991d8990240SAditya Kali 
29920756b908SEric Whitney 	/*
29939fe67149SEric Whitney 	 * if there's a partial cluster and we have removed the first extent
29949fe67149SEric Whitney 	 * in the file, then we also free the partial cluster, if any
29950756b908SEric Whitney 	 */
29969fe67149SEric Whitney 	if (partial.state == tofree && err == 0) {
29979fe67149SEric Whitney 		int flags = get_default_free_blocks_flags(inode);
29989fe67149SEric Whitney 
29999fe67149SEric Whitney 		if (ext4_is_pending(inode, partial.lblk))
30009fe67149SEric Whitney 			flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
30017b415bf6SAditya Kali 		ext4_free_blocks(handle, inode, NULL,
30029fe67149SEric Whitney 				 EXT4_C2B(sbi, partial.pclu),
30039fe67149SEric Whitney 				 sbi->s_cluster_ratio, flags);
30049fe67149SEric Whitney 		if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
30059fe67149SEric Whitney 			ext4_rereserve_cluster(inode, partial.lblk);
30069fe67149SEric Whitney 		partial.state = initial;
30077b415bf6SAditya Kali 	}
30087b415bf6SAditya Kali 
3009a86c6181SAlex Tomas 	/* TODO: flexible tree reduction should be here */
3010a86c6181SAlex Tomas 	if (path->p_hdr->eh_entries == 0) {
3011a86c6181SAlex Tomas 		/*
3012d0d856e8SRandy Dunlap 		 * truncate to zero freed all the tree,
3013d0d856e8SRandy Dunlap 		 * so we need to correct eh_depth
3014a86c6181SAlex Tomas 		 */
3015a86c6181SAlex Tomas 		err = ext4_ext_get_access(handle, inode, path);
3016a86c6181SAlex Tomas 		if (err == 0) {
3017a86c6181SAlex Tomas 			ext_inode_hdr(inode)->eh_depth = 0;
3018a86c6181SAlex Tomas 			ext_inode_hdr(inode)->eh_max =
301955ad63bfSTheodore Ts'o 				cpu_to_le16(ext4_ext_space_root(inode, 0));
3020a86c6181SAlex Tomas 			err = ext4_ext_dirty(handle, inode, path);
3021a86c6181SAlex Tomas 		}
3022a86c6181SAlex Tomas 	}
3023a86c6181SAlex Tomas out:
3024a86c6181SAlex Tomas 	ext4_ext_drop_refs(path);
3025a86c6181SAlex Tomas 	kfree(path);
3026968dee77SAshish Sangwan 	path = NULL;
3027dfe50809STheodore Ts'o 	if (err == -EAGAIN)
3028dfe50809STheodore Ts'o 		goto again;
3029a86c6181SAlex Tomas 	ext4_journal_stop(handle);
3030a86c6181SAlex Tomas 
3031a86c6181SAlex Tomas 	return err;
3032a86c6181SAlex Tomas }
3033a86c6181SAlex Tomas 
3034a86c6181SAlex Tomas /*
3035a86c6181SAlex Tomas  * called at mount time
3036a86c6181SAlex Tomas  */
3037a86c6181SAlex Tomas void ext4_ext_init(struct super_block *sb)
3038a86c6181SAlex Tomas {
3039a86c6181SAlex Tomas 	/*
3040a86c6181SAlex Tomas 	 * possible initialization would be here
3041a86c6181SAlex Tomas 	 */
3042a86c6181SAlex Tomas 
3043e2b911c5SDarrick J. Wong 	if (ext4_has_feature_extents(sb)) {
304490576c0bSTheodore Ts'o #if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS)
304592b97816STheodore Ts'o 		printk(KERN_INFO "EXT4-fs: file extents enabled"
3046bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
304792b97816STheodore Ts'o 		       ", aggressive tests"
3048a86c6181SAlex Tomas #endif
3049a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH
305092b97816STheodore Ts'o 		       ", check binsearch"
3051a86c6181SAlex Tomas #endif
3052a86c6181SAlex Tomas #ifdef EXTENTS_STATS
305392b97816STheodore Ts'o 		       ", stats"
3054a86c6181SAlex Tomas #endif
305592b97816STheodore Ts'o 		       "\n");
305690576c0bSTheodore Ts'o #endif
3057a86c6181SAlex Tomas #ifdef EXTENTS_STATS
3058a86c6181SAlex Tomas 		spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock);
3059a86c6181SAlex Tomas 		EXT4_SB(sb)->s_ext_min = 1 << 30;
3060a86c6181SAlex Tomas 		EXT4_SB(sb)->s_ext_max = 0;
3061a86c6181SAlex Tomas #endif
3062a86c6181SAlex Tomas 	}
3063a86c6181SAlex Tomas }
3064a86c6181SAlex Tomas 
3065a86c6181SAlex Tomas /*
3066a86c6181SAlex Tomas  * called at umount time
3067a86c6181SAlex Tomas  */
3068a86c6181SAlex Tomas void ext4_ext_release(struct super_block *sb)
3069a86c6181SAlex Tomas {
3070e2b911c5SDarrick J. Wong 	if (!ext4_has_feature_extents(sb))
3071a86c6181SAlex Tomas 		return;
3072a86c6181SAlex Tomas 
3073a86c6181SAlex Tomas #ifdef EXTENTS_STATS
3074a86c6181SAlex Tomas 	if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) {
3075a86c6181SAlex Tomas 		struct ext4_sb_info *sbi = EXT4_SB(sb);
3076a86c6181SAlex Tomas 		printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n",
3077a86c6181SAlex Tomas 			sbi->s_ext_blocks, sbi->s_ext_extents,
3078a86c6181SAlex Tomas 			sbi->s_ext_blocks / sbi->s_ext_extents);
3079a86c6181SAlex Tomas 		printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n",
3080a86c6181SAlex Tomas 			sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max);
3081a86c6181SAlex Tomas 	}
3082a86c6181SAlex Tomas #endif
3083a86c6181SAlex Tomas }
3084a86c6181SAlex Tomas 
3085d7b2a00cSZheng Liu static int ext4_zeroout_es(struct inode *inode, struct ext4_extent *ex)
3086d7b2a00cSZheng Liu {
3087d7b2a00cSZheng Liu 	ext4_lblk_t  ee_block;
3088d7b2a00cSZheng Liu 	ext4_fsblk_t ee_pblock;
3089d7b2a00cSZheng Liu 	unsigned int ee_len;
3090d7b2a00cSZheng Liu 
3091d7b2a00cSZheng Liu 	ee_block  = le32_to_cpu(ex->ee_block);
3092d7b2a00cSZheng Liu 	ee_len    = ext4_ext_get_actual_len(ex);
3093d7b2a00cSZheng Liu 	ee_pblock = ext4_ext_pblock(ex);
3094d7b2a00cSZheng Liu 
3095d7b2a00cSZheng Liu 	if (ee_len == 0)
3096d7b2a00cSZheng Liu 		return 0;
3097d7b2a00cSZheng Liu 
3098d7b2a00cSZheng Liu 	return ext4_es_insert_extent(inode, ee_block, ee_len, ee_pblock,
3099d7b2a00cSZheng Liu 				     EXTENT_STATUS_WRITTEN);
3100d7b2a00cSZheng Liu }
3101d7b2a00cSZheng Liu 
3102093a088bSAneesh Kumar K.V /* FIXME!! we need to try to merge to left or right after zero-out  */
3103093a088bSAneesh Kumar K.V static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
3104093a088bSAneesh Kumar K.V {
31052407518dSLukas Czerner 	ext4_fsblk_t ee_pblock;
31062407518dSLukas Czerner 	unsigned int ee_len;
3107093a088bSAneesh Kumar K.V 
3108093a088bSAneesh Kumar K.V 	ee_len    = ext4_ext_get_actual_len(ex);
3109bf89d16fSTheodore Ts'o 	ee_pblock = ext4_ext_pblock(ex);
311053085facSJan Kara 	return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,
311153085facSJan Kara 				  ee_len);
3112093a088bSAneesh Kumar K.V }
3113093a088bSAneesh Kumar K.V 
311447ea3bb5SYongqiang Yang /*
311547ea3bb5SYongqiang Yang  * ext4_split_extent_at() splits an extent at given block.
311647ea3bb5SYongqiang Yang  *
311747ea3bb5SYongqiang Yang  * @handle: the journal handle
311847ea3bb5SYongqiang Yang  * @inode: the file inode
311947ea3bb5SYongqiang Yang  * @path: the path to the extent
312047ea3bb5SYongqiang Yang  * @split: the logical block where the extent is splitted.
312147ea3bb5SYongqiang Yang  * @split_flags: indicates if the extent could be zeroout if split fails, and
3122556615dcSLukas Czerner  *		 the states(init or unwritten) of new extents.
312347ea3bb5SYongqiang Yang  * @flags: flags used to insert new extent to extent tree.
312447ea3bb5SYongqiang Yang  *
312547ea3bb5SYongqiang Yang  *
312647ea3bb5SYongqiang Yang  * Splits extent [a, b] into two extents [a, @split) and [@split, b], states
312747ea3bb5SYongqiang Yang  * of which are deterimined by split_flag.
312847ea3bb5SYongqiang Yang  *
312947ea3bb5SYongqiang Yang  * There are two cases:
313047ea3bb5SYongqiang Yang  *  a> the extent are splitted into two extent.
313147ea3bb5SYongqiang Yang  *  b> split is not needed, and just mark the extent.
313247ea3bb5SYongqiang Yang  *
313347ea3bb5SYongqiang Yang  * return 0 on success.
313447ea3bb5SYongqiang Yang  */
313547ea3bb5SYongqiang Yang static int ext4_split_extent_at(handle_t *handle,
313647ea3bb5SYongqiang Yang 			     struct inode *inode,
3137dfe50809STheodore Ts'o 			     struct ext4_ext_path **ppath,
313847ea3bb5SYongqiang Yang 			     ext4_lblk_t split,
313947ea3bb5SYongqiang Yang 			     int split_flag,
314047ea3bb5SYongqiang Yang 			     int flags)
314147ea3bb5SYongqiang Yang {
3142dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
314347ea3bb5SYongqiang Yang 	ext4_fsblk_t newblock;
314447ea3bb5SYongqiang Yang 	ext4_lblk_t ee_block;
3145adb23551SZheng Liu 	struct ext4_extent *ex, newex, orig_ex, zero_ex;
314647ea3bb5SYongqiang Yang 	struct ext4_extent *ex2 = NULL;
314747ea3bb5SYongqiang Yang 	unsigned int ee_len, depth;
314847ea3bb5SYongqiang Yang 	int err = 0;
314947ea3bb5SYongqiang Yang 
3150dee1f973SDmitry Monakhov 	BUG_ON((split_flag & (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2)) ==
3151dee1f973SDmitry Monakhov 	       (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2));
3152dee1f973SDmitry Monakhov 
315347ea3bb5SYongqiang Yang 	ext_debug("ext4_split_extents_at: inode %lu, logical"
315447ea3bb5SYongqiang Yang 		"block %llu\n", inode->i_ino, (unsigned long long)split);
315547ea3bb5SYongqiang Yang 
315647ea3bb5SYongqiang Yang 	ext4_ext_show_leaf(inode, path);
315747ea3bb5SYongqiang Yang 
315847ea3bb5SYongqiang Yang 	depth = ext_depth(inode);
315947ea3bb5SYongqiang Yang 	ex = path[depth].p_ext;
316047ea3bb5SYongqiang Yang 	ee_block = le32_to_cpu(ex->ee_block);
316147ea3bb5SYongqiang Yang 	ee_len = ext4_ext_get_actual_len(ex);
316247ea3bb5SYongqiang Yang 	newblock = split - ee_block + ext4_ext_pblock(ex);
316347ea3bb5SYongqiang Yang 
316447ea3bb5SYongqiang Yang 	BUG_ON(split < ee_block || split >= (ee_block + ee_len));
3165556615dcSLukas Czerner 	BUG_ON(!ext4_ext_is_unwritten(ex) &&
3166357b66fdSDmitry Monakhov 	       split_flag & (EXT4_EXT_MAY_ZEROOUT |
3167556615dcSLukas Czerner 			     EXT4_EXT_MARK_UNWRIT1 |
3168556615dcSLukas Czerner 			     EXT4_EXT_MARK_UNWRIT2));
316947ea3bb5SYongqiang Yang 
317047ea3bb5SYongqiang Yang 	err = ext4_ext_get_access(handle, inode, path + depth);
317147ea3bb5SYongqiang Yang 	if (err)
317247ea3bb5SYongqiang Yang 		goto out;
317347ea3bb5SYongqiang Yang 
317447ea3bb5SYongqiang Yang 	if (split == ee_block) {
317547ea3bb5SYongqiang Yang 		/*
317647ea3bb5SYongqiang Yang 		 * case b: block @split is the block that the extent begins with
317747ea3bb5SYongqiang Yang 		 * then we just change the state of the extent, and splitting
317847ea3bb5SYongqiang Yang 		 * is not needed.
317947ea3bb5SYongqiang Yang 		 */
3180556615dcSLukas Czerner 		if (split_flag & EXT4_EXT_MARK_UNWRIT2)
3181556615dcSLukas Czerner 			ext4_ext_mark_unwritten(ex);
318247ea3bb5SYongqiang Yang 		else
318347ea3bb5SYongqiang Yang 			ext4_ext_mark_initialized(ex);
318447ea3bb5SYongqiang Yang 
318547ea3bb5SYongqiang Yang 		if (!(flags & EXT4_GET_BLOCKS_PRE_IO))
3186ecb94f5fSTheodore Ts'o 			ext4_ext_try_to_merge(handle, inode, path, ex);
318747ea3bb5SYongqiang Yang 
3188ecb94f5fSTheodore Ts'o 		err = ext4_ext_dirty(handle, inode, path + path->p_depth);
318947ea3bb5SYongqiang Yang 		goto out;
319047ea3bb5SYongqiang Yang 	}
319147ea3bb5SYongqiang Yang 
319247ea3bb5SYongqiang Yang 	/* case a */
319347ea3bb5SYongqiang Yang 	memcpy(&orig_ex, ex, sizeof(orig_ex));
319447ea3bb5SYongqiang Yang 	ex->ee_len = cpu_to_le16(split - ee_block);
3195556615dcSLukas Czerner 	if (split_flag & EXT4_EXT_MARK_UNWRIT1)
3196556615dcSLukas Czerner 		ext4_ext_mark_unwritten(ex);
319747ea3bb5SYongqiang Yang 
319847ea3bb5SYongqiang Yang 	/*
319947ea3bb5SYongqiang Yang 	 * path may lead to new leaf, not to original leaf any more
320047ea3bb5SYongqiang Yang 	 * after ext4_ext_insert_extent() returns,
320147ea3bb5SYongqiang Yang 	 */
320247ea3bb5SYongqiang Yang 	err = ext4_ext_dirty(handle, inode, path + depth);
320347ea3bb5SYongqiang Yang 	if (err)
320447ea3bb5SYongqiang Yang 		goto fix_extent_len;
320547ea3bb5SYongqiang Yang 
320647ea3bb5SYongqiang Yang 	ex2 = &newex;
320747ea3bb5SYongqiang Yang 	ex2->ee_block = cpu_to_le32(split);
320847ea3bb5SYongqiang Yang 	ex2->ee_len   = cpu_to_le16(ee_len - (split - ee_block));
320947ea3bb5SYongqiang Yang 	ext4_ext_store_pblock(ex2, newblock);
3210556615dcSLukas Czerner 	if (split_flag & EXT4_EXT_MARK_UNWRIT2)
3211556615dcSLukas Czerner 		ext4_ext_mark_unwritten(ex2);
321247ea3bb5SYongqiang Yang 
3213dfe50809STheodore Ts'o 	err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags);
321447ea3bb5SYongqiang Yang 	if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) {
3215dee1f973SDmitry Monakhov 		if (split_flag & (EXT4_EXT_DATA_VALID1|EXT4_EXT_DATA_VALID2)) {
3216adb23551SZheng Liu 			if (split_flag & EXT4_EXT_DATA_VALID1) {
3217dee1f973SDmitry Monakhov 				err = ext4_ext_zeroout(inode, ex2);
3218adb23551SZheng Liu 				zero_ex.ee_block = ex2->ee_block;
32198cde7ad1SZheng Liu 				zero_ex.ee_len = cpu_to_le16(
32208cde7ad1SZheng Liu 						ext4_ext_get_actual_len(ex2));
3221adb23551SZheng Liu 				ext4_ext_store_pblock(&zero_ex,
3222adb23551SZheng Liu 						      ext4_ext_pblock(ex2));
3223adb23551SZheng Liu 			} else {
3224dee1f973SDmitry Monakhov 				err = ext4_ext_zeroout(inode, ex);
3225adb23551SZheng Liu 				zero_ex.ee_block = ex->ee_block;
32268cde7ad1SZheng Liu 				zero_ex.ee_len = cpu_to_le16(
32278cde7ad1SZheng Liu 						ext4_ext_get_actual_len(ex));
3228adb23551SZheng Liu 				ext4_ext_store_pblock(&zero_ex,
3229adb23551SZheng Liu 						      ext4_ext_pblock(ex));
3230adb23551SZheng Liu 			}
3231adb23551SZheng Liu 		} else {
323247ea3bb5SYongqiang Yang 			err = ext4_ext_zeroout(inode, &orig_ex);
3233adb23551SZheng Liu 			zero_ex.ee_block = orig_ex.ee_block;
32348cde7ad1SZheng Liu 			zero_ex.ee_len = cpu_to_le16(
32358cde7ad1SZheng Liu 						ext4_ext_get_actual_len(&orig_ex));
3236adb23551SZheng Liu 			ext4_ext_store_pblock(&zero_ex,
3237adb23551SZheng Liu 					      ext4_ext_pblock(&orig_ex));
3238adb23551SZheng Liu 		}
3239dee1f973SDmitry Monakhov 
324047ea3bb5SYongqiang Yang 		if (err)
324147ea3bb5SYongqiang Yang 			goto fix_extent_len;
324247ea3bb5SYongqiang Yang 		/* update the extent length and mark as initialized */
3243af1584f5SAl Viro 		ex->ee_len = cpu_to_le16(ee_len);
3244ecb94f5fSTheodore Ts'o 		ext4_ext_try_to_merge(handle, inode, path, ex);
3245ecb94f5fSTheodore Ts'o 		err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3246adb23551SZheng Liu 		if (err)
3247adb23551SZheng Liu 			goto fix_extent_len;
3248adb23551SZheng Liu 
3249adb23551SZheng Liu 		/* update extent status tree */
3250d7b2a00cSZheng Liu 		err = ext4_zeroout_es(inode, &zero_ex);
3251adb23551SZheng Liu 
325247ea3bb5SYongqiang Yang 		goto out;
325347ea3bb5SYongqiang Yang 	} else if (err)
325447ea3bb5SYongqiang Yang 		goto fix_extent_len;
325547ea3bb5SYongqiang Yang 
325647ea3bb5SYongqiang Yang out:
325747ea3bb5SYongqiang Yang 	ext4_ext_show_leaf(inode, path);
325847ea3bb5SYongqiang Yang 	return err;
325947ea3bb5SYongqiang Yang 
326047ea3bb5SYongqiang Yang fix_extent_len:
326147ea3bb5SYongqiang Yang 	ex->ee_len = orig_ex.ee_len;
3262b60ca334SHarshad Shirwadkar 	/*
3263b60ca334SHarshad Shirwadkar 	 * Ignore ext4_ext_dirty return value since we are already in error path
3264b60ca334SHarshad Shirwadkar 	 * and err is a non-zero error code.
3265b60ca334SHarshad Shirwadkar 	 */
326629faed16SDmitry Monakhov 	ext4_ext_dirty(handle, inode, path + path->p_depth);
326747ea3bb5SYongqiang Yang 	return err;
326847ea3bb5SYongqiang Yang }
326947ea3bb5SYongqiang Yang 
327047ea3bb5SYongqiang Yang /*
327147ea3bb5SYongqiang Yang  * ext4_split_extents() splits an extent and mark extent which is covered
327247ea3bb5SYongqiang Yang  * by @map as split_flags indicates
327347ea3bb5SYongqiang Yang  *
327447ea3bb5SYongqiang Yang  * It may result in splitting the extent into multiple extents (up to three)
327547ea3bb5SYongqiang Yang  * There are three possibilities:
327647ea3bb5SYongqiang Yang  *   a> There is no split required
327747ea3bb5SYongqiang Yang  *   b> Splits in two extents: Split is happening at either end of the extent
327847ea3bb5SYongqiang Yang  *   c> Splits in three extents: Somone is splitting in middle of the extent
327947ea3bb5SYongqiang Yang  *
328047ea3bb5SYongqiang Yang  */
328147ea3bb5SYongqiang Yang static int ext4_split_extent(handle_t *handle,
328247ea3bb5SYongqiang Yang 			      struct inode *inode,
3283dfe50809STheodore Ts'o 			      struct ext4_ext_path **ppath,
328447ea3bb5SYongqiang Yang 			      struct ext4_map_blocks *map,
328547ea3bb5SYongqiang Yang 			      int split_flag,
328647ea3bb5SYongqiang Yang 			      int flags)
328747ea3bb5SYongqiang Yang {
3288dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
328947ea3bb5SYongqiang Yang 	ext4_lblk_t ee_block;
329047ea3bb5SYongqiang Yang 	struct ext4_extent *ex;
329147ea3bb5SYongqiang Yang 	unsigned int ee_len, depth;
329247ea3bb5SYongqiang Yang 	int err = 0;
3293556615dcSLukas Czerner 	int unwritten;
329447ea3bb5SYongqiang Yang 	int split_flag1, flags1;
32953a225670SZheng Liu 	int allocated = map->m_len;
329647ea3bb5SYongqiang Yang 
329747ea3bb5SYongqiang Yang 	depth = ext_depth(inode);
329847ea3bb5SYongqiang Yang 	ex = path[depth].p_ext;
329947ea3bb5SYongqiang Yang 	ee_block = le32_to_cpu(ex->ee_block);
330047ea3bb5SYongqiang Yang 	ee_len = ext4_ext_get_actual_len(ex);
3301556615dcSLukas Czerner 	unwritten = ext4_ext_is_unwritten(ex);
330247ea3bb5SYongqiang Yang 
330347ea3bb5SYongqiang Yang 	if (map->m_lblk + map->m_len < ee_block + ee_len) {
3304dee1f973SDmitry Monakhov 		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT;
330547ea3bb5SYongqiang Yang 		flags1 = flags | EXT4_GET_BLOCKS_PRE_IO;
3306556615dcSLukas Czerner 		if (unwritten)
3307556615dcSLukas Czerner 			split_flag1 |= EXT4_EXT_MARK_UNWRIT1 |
3308556615dcSLukas Czerner 				       EXT4_EXT_MARK_UNWRIT2;
3309dee1f973SDmitry Monakhov 		if (split_flag & EXT4_EXT_DATA_VALID2)
3310dee1f973SDmitry Monakhov 			split_flag1 |= EXT4_EXT_DATA_VALID1;
3311dfe50809STheodore Ts'o 		err = ext4_split_extent_at(handle, inode, ppath,
331247ea3bb5SYongqiang Yang 				map->m_lblk + map->m_len, split_flag1, flags1);
331393917411SYongqiang Yang 		if (err)
331493917411SYongqiang Yang 			goto out;
33153a225670SZheng Liu 	} else {
33163a225670SZheng Liu 		allocated = ee_len - (map->m_lblk - ee_block);
331747ea3bb5SYongqiang Yang 	}
3318357b66fdSDmitry Monakhov 	/*
3319357b66fdSDmitry Monakhov 	 * Update path is required because previous ext4_split_extent_at() may
3320357b66fdSDmitry Monakhov 	 * result in split of original leaf or extent zeroout.
3321357b66fdSDmitry Monakhov 	 */
332273c384c0STheodore Ts'o 	path = ext4_find_extent(inode, map->m_lblk, ppath, flags);
332347ea3bb5SYongqiang Yang 	if (IS_ERR(path))
332447ea3bb5SYongqiang Yang 		return PTR_ERR(path);
3325357b66fdSDmitry Monakhov 	depth = ext_depth(inode);
3326357b66fdSDmitry Monakhov 	ex = path[depth].p_ext;
3327a18ed359SDmitry Monakhov 	if (!ex) {
3328a18ed359SDmitry Monakhov 		EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3329a18ed359SDmitry Monakhov 				 (unsigned long) map->m_lblk);
33306a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
3331a18ed359SDmitry Monakhov 	}
3332556615dcSLukas Czerner 	unwritten = ext4_ext_is_unwritten(ex);
3333357b66fdSDmitry Monakhov 	split_flag1 = 0;
333447ea3bb5SYongqiang Yang 
333547ea3bb5SYongqiang Yang 	if (map->m_lblk >= ee_block) {
3336357b66fdSDmitry Monakhov 		split_flag1 = split_flag & EXT4_EXT_DATA_VALID2;
3337556615dcSLukas Czerner 		if (unwritten) {
3338556615dcSLukas Czerner 			split_flag1 |= EXT4_EXT_MARK_UNWRIT1;
3339357b66fdSDmitry Monakhov 			split_flag1 |= split_flag & (EXT4_EXT_MAY_ZEROOUT |
3340556615dcSLukas Czerner 						     EXT4_EXT_MARK_UNWRIT2);
3341357b66fdSDmitry Monakhov 		}
3342dfe50809STheodore Ts'o 		err = ext4_split_extent_at(handle, inode, ppath,
334347ea3bb5SYongqiang Yang 				map->m_lblk, split_flag1, flags);
334447ea3bb5SYongqiang Yang 		if (err)
334547ea3bb5SYongqiang Yang 			goto out;
334647ea3bb5SYongqiang Yang 	}
334747ea3bb5SYongqiang Yang 
334847ea3bb5SYongqiang Yang 	ext4_ext_show_leaf(inode, path);
334947ea3bb5SYongqiang Yang out:
33503a225670SZheng Liu 	return err ? err : allocated;
335147ea3bb5SYongqiang Yang }
335247ea3bb5SYongqiang Yang 
335356055d3aSAmit Arora /*
3354e35fd660STheodore Ts'o  * This function is called by ext4_ext_map_blocks() if someone tries to write
3355556615dcSLukas Czerner  * to an unwritten extent. It may result in splitting the unwritten
335656055d3aSAmit Arora  * extent into multiple extents (up to three - one initialized and two
3357556615dcSLukas Czerner  * unwritten).
335856055d3aSAmit Arora  * There are three possibilities:
335956055d3aSAmit Arora  *   a> There is no split required: Entire extent should be initialized
336056055d3aSAmit Arora  *   b> Splits in two extents: Write is happening at either end of the extent
336156055d3aSAmit Arora  *   c> Splits in three extents: Somone is writing in middle of the extent
33626f91bc5fSEric Gouriou  *
33636f91bc5fSEric Gouriou  * Pre-conditions:
3364556615dcSLukas Czerner  *  - The extent pointed to by 'path' is unwritten.
33656f91bc5fSEric Gouriou  *  - The extent pointed to by 'path' contains a superset
33666f91bc5fSEric Gouriou  *    of the logical span [map->m_lblk, map->m_lblk + map->m_len).
33676f91bc5fSEric Gouriou  *
33686f91bc5fSEric Gouriou  * Post-conditions on success:
33696f91bc5fSEric Gouriou  *  - the returned value is the number of blocks beyond map->l_lblk
33706f91bc5fSEric Gouriou  *    that are allocated and initialized.
33716f91bc5fSEric Gouriou  *    It is guaranteed to be >= map->m_len.
337256055d3aSAmit Arora  */
3373725d26d3SAneesh Kumar K.V static int ext4_ext_convert_to_initialized(handle_t *handle,
3374725d26d3SAneesh Kumar K.V 					   struct inode *inode,
3375e35fd660STheodore Ts'o 					   struct ext4_map_blocks *map,
3376dfe50809STheodore Ts'o 					   struct ext4_ext_path **ppath,
337727dd4385SLukas Czerner 					   int flags)
337856055d3aSAmit Arora {
3379dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
338067a5da56SZheng Liu 	struct ext4_sb_info *sbi;
33816f91bc5fSEric Gouriou 	struct ext4_extent_header *eh;
3382667eff35SYongqiang Yang 	struct ext4_map_blocks split_map;
33834f8caa60SJan Kara 	struct ext4_extent zero_ex1, zero_ex2;
3384bc2d9db4SLukas Czerner 	struct ext4_extent *ex, *abut_ex;
338521ca087aSDmitry Monakhov 	ext4_lblk_t ee_block, eof_block;
3386bc2d9db4SLukas Czerner 	unsigned int ee_len, depth, map_len = map->m_len;
3387bc2d9db4SLukas Czerner 	int allocated = 0, max_zeroout = 0;
338856055d3aSAmit Arora 	int err = 0;
33894f8caa60SJan Kara 	int split_flag = EXT4_EXT_DATA_VALID2;
339021ca087aSDmitry Monakhov 
339121ca087aSDmitry Monakhov 	ext_debug("ext4_ext_convert_to_initialized: inode %lu, logical"
339221ca087aSDmitry Monakhov 		"block %llu, max_blocks %u\n", inode->i_ino,
3393bc2d9db4SLukas Czerner 		(unsigned long long)map->m_lblk, map_len);
339421ca087aSDmitry Monakhov 
339567a5da56SZheng Liu 	sbi = EXT4_SB(inode->i_sb);
3396801674f3SJan Kara 	eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3397801674f3SJan Kara 			>> inode->i_sb->s_blocksize_bits;
3398bc2d9db4SLukas Czerner 	if (eof_block < map->m_lblk + map_len)
3399bc2d9db4SLukas Czerner 		eof_block = map->m_lblk + map_len;
340056055d3aSAmit Arora 
340156055d3aSAmit Arora 	depth = ext_depth(inode);
34026f91bc5fSEric Gouriou 	eh = path[depth].p_hdr;
340356055d3aSAmit Arora 	ex = path[depth].p_ext;
340456055d3aSAmit Arora 	ee_block = le32_to_cpu(ex->ee_block);
340556055d3aSAmit Arora 	ee_len = ext4_ext_get_actual_len(ex);
34064f8caa60SJan Kara 	zero_ex1.ee_len = 0;
34074f8caa60SJan Kara 	zero_ex2.ee_len = 0;
340821ca087aSDmitry Monakhov 
34096f91bc5fSEric Gouriou 	trace_ext4_ext_convert_to_initialized_enter(inode, map, ex);
34106f91bc5fSEric Gouriou 
34116f91bc5fSEric Gouriou 	/* Pre-conditions */
3412556615dcSLukas Czerner 	BUG_ON(!ext4_ext_is_unwritten(ex));
34136f91bc5fSEric Gouriou 	BUG_ON(!in_range(map->m_lblk, ee_block, ee_len));
34146f91bc5fSEric Gouriou 
34156f91bc5fSEric Gouriou 	/*
34166f91bc5fSEric Gouriou 	 * Attempt to transfer newly initialized blocks from the currently
3417556615dcSLukas Czerner 	 * unwritten extent to its neighbor. This is much cheaper
34186f91bc5fSEric Gouriou 	 * than an insertion followed by a merge as those involve costly
3419bc2d9db4SLukas Czerner 	 * memmove() calls. Transferring to the left is the common case in
3420bc2d9db4SLukas Czerner 	 * steady state for workloads doing fallocate(FALLOC_FL_KEEP_SIZE)
3421bc2d9db4SLukas Czerner 	 * followed by append writes.
34226f91bc5fSEric Gouriou 	 *
34236f91bc5fSEric Gouriou 	 * Limitations of the current logic:
3424bc2d9db4SLukas Czerner 	 *  - L1: we do not deal with writes covering the whole extent.
34256f91bc5fSEric Gouriou 	 *    This would require removing the extent if the transfer
34266f91bc5fSEric Gouriou 	 *    is possible.
3427bc2d9db4SLukas Czerner 	 *  - L2: we only attempt to merge with an extent stored in the
34286f91bc5fSEric Gouriou 	 *    same extent tree node.
34296f91bc5fSEric Gouriou 	 */
3430bc2d9db4SLukas Czerner 	if ((map->m_lblk == ee_block) &&
3431bc2d9db4SLukas Czerner 		/* See if we can merge left */
3432bc2d9db4SLukas Czerner 		(map_len < ee_len) &&		/*L1*/
3433bc2d9db4SLukas Czerner 		(ex > EXT_FIRST_EXTENT(eh))) {	/*L2*/
34346f91bc5fSEric Gouriou 		ext4_lblk_t prev_lblk;
34356f91bc5fSEric Gouriou 		ext4_fsblk_t prev_pblk, ee_pblk;
3436bc2d9db4SLukas Czerner 		unsigned int prev_len;
34376f91bc5fSEric Gouriou 
3438bc2d9db4SLukas Czerner 		abut_ex = ex - 1;
3439bc2d9db4SLukas Czerner 		prev_lblk = le32_to_cpu(abut_ex->ee_block);
3440bc2d9db4SLukas Czerner 		prev_len = ext4_ext_get_actual_len(abut_ex);
3441bc2d9db4SLukas Czerner 		prev_pblk = ext4_ext_pblock(abut_ex);
34426f91bc5fSEric Gouriou 		ee_pblk = ext4_ext_pblock(ex);
34436f91bc5fSEric Gouriou 
34446f91bc5fSEric Gouriou 		/*
3445bc2d9db4SLukas Czerner 		 * A transfer of blocks from 'ex' to 'abut_ex' is allowed
34466f91bc5fSEric Gouriou 		 * upon those conditions:
3447bc2d9db4SLukas Czerner 		 * - C1: abut_ex is initialized,
3448bc2d9db4SLukas Czerner 		 * - C2: abut_ex is logically abutting ex,
3449bc2d9db4SLukas Czerner 		 * - C3: abut_ex is physically abutting ex,
3450bc2d9db4SLukas Czerner 		 * - C4: abut_ex can receive the additional blocks without
34516f91bc5fSEric Gouriou 		 *   overflowing the (initialized) length limit.
34526f91bc5fSEric Gouriou 		 */
3453556615dcSLukas Czerner 		if ((!ext4_ext_is_unwritten(abut_ex)) &&		/*C1*/
34546f91bc5fSEric Gouriou 			((prev_lblk + prev_len) == ee_block) &&		/*C2*/
34556f91bc5fSEric Gouriou 			((prev_pblk + prev_len) == ee_pblk) &&		/*C3*/
3456bc2d9db4SLukas Czerner 			(prev_len < (EXT_INIT_MAX_LEN - map_len))) {	/*C4*/
34576f91bc5fSEric Gouriou 			err = ext4_ext_get_access(handle, inode, path + depth);
34586f91bc5fSEric Gouriou 			if (err)
34596f91bc5fSEric Gouriou 				goto out;
34606f91bc5fSEric Gouriou 
34616f91bc5fSEric Gouriou 			trace_ext4_ext_convert_to_initialized_fastpath(inode,
3462bc2d9db4SLukas Czerner 				map, ex, abut_ex);
34636f91bc5fSEric Gouriou 
3464bc2d9db4SLukas Czerner 			/* Shift the start of ex by 'map_len' blocks */
3465bc2d9db4SLukas Czerner 			ex->ee_block = cpu_to_le32(ee_block + map_len);
3466bc2d9db4SLukas Czerner 			ext4_ext_store_pblock(ex, ee_pblk + map_len);
3467bc2d9db4SLukas Czerner 			ex->ee_len = cpu_to_le16(ee_len - map_len);
3468556615dcSLukas Czerner 			ext4_ext_mark_unwritten(ex); /* Restore the flag */
34696f91bc5fSEric Gouriou 
3470bc2d9db4SLukas Czerner 			/* Extend abut_ex by 'map_len' blocks */
3471bc2d9db4SLukas Czerner 			abut_ex->ee_len = cpu_to_le16(prev_len + map_len);
34726f91bc5fSEric Gouriou 
3473bc2d9db4SLukas Czerner 			/* Result: number of initialized blocks past m_lblk */
3474bc2d9db4SLukas Czerner 			allocated = map_len;
3475bc2d9db4SLukas Czerner 		}
3476bc2d9db4SLukas Czerner 	} else if (((map->m_lblk + map_len) == (ee_block + ee_len)) &&
3477bc2d9db4SLukas Czerner 		   (map_len < ee_len) &&	/*L1*/
3478bc2d9db4SLukas Czerner 		   ex < EXT_LAST_EXTENT(eh)) {	/*L2*/
3479bc2d9db4SLukas Czerner 		/* See if we can merge right */
3480bc2d9db4SLukas Czerner 		ext4_lblk_t next_lblk;
3481bc2d9db4SLukas Czerner 		ext4_fsblk_t next_pblk, ee_pblk;
3482bc2d9db4SLukas Czerner 		unsigned int next_len;
3483bc2d9db4SLukas Czerner 
3484bc2d9db4SLukas Czerner 		abut_ex = ex + 1;
3485bc2d9db4SLukas Czerner 		next_lblk = le32_to_cpu(abut_ex->ee_block);
3486bc2d9db4SLukas Czerner 		next_len = ext4_ext_get_actual_len(abut_ex);
3487bc2d9db4SLukas Czerner 		next_pblk = ext4_ext_pblock(abut_ex);
3488bc2d9db4SLukas Czerner 		ee_pblk = ext4_ext_pblock(ex);
3489bc2d9db4SLukas Czerner 
3490bc2d9db4SLukas Czerner 		/*
3491bc2d9db4SLukas Czerner 		 * A transfer of blocks from 'ex' to 'abut_ex' is allowed
3492bc2d9db4SLukas Czerner 		 * upon those conditions:
3493bc2d9db4SLukas Czerner 		 * - C1: abut_ex is initialized,
3494bc2d9db4SLukas Czerner 		 * - C2: abut_ex is logically abutting ex,
3495bc2d9db4SLukas Czerner 		 * - C3: abut_ex is physically abutting ex,
3496bc2d9db4SLukas Czerner 		 * - C4: abut_ex can receive the additional blocks without
3497bc2d9db4SLukas Czerner 		 *   overflowing the (initialized) length limit.
3498bc2d9db4SLukas Czerner 		 */
3499556615dcSLukas Czerner 		if ((!ext4_ext_is_unwritten(abut_ex)) &&		/*C1*/
3500bc2d9db4SLukas Czerner 		    ((map->m_lblk + map_len) == next_lblk) &&		/*C2*/
3501bc2d9db4SLukas Czerner 		    ((ee_pblk + ee_len) == next_pblk) &&		/*C3*/
3502bc2d9db4SLukas Czerner 		    (next_len < (EXT_INIT_MAX_LEN - map_len))) {	/*C4*/
3503bc2d9db4SLukas Czerner 			err = ext4_ext_get_access(handle, inode, path + depth);
3504bc2d9db4SLukas Czerner 			if (err)
3505bc2d9db4SLukas Czerner 				goto out;
3506bc2d9db4SLukas Czerner 
3507bc2d9db4SLukas Czerner 			trace_ext4_ext_convert_to_initialized_fastpath(inode,
3508bc2d9db4SLukas Czerner 				map, ex, abut_ex);
3509bc2d9db4SLukas Czerner 
3510bc2d9db4SLukas Czerner 			/* Shift the start of abut_ex by 'map_len' blocks */
3511bc2d9db4SLukas Czerner 			abut_ex->ee_block = cpu_to_le32(next_lblk - map_len);
3512bc2d9db4SLukas Czerner 			ext4_ext_store_pblock(abut_ex, next_pblk - map_len);
3513bc2d9db4SLukas Czerner 			ex->ee_len = cpu_to_le16(ee_len - map_len);
3514556615dcSLukas Czerner 			ext4_ext_mark_unwritten(ex); /* Restore the flag */
3515bc2d9db4SLukas Czerner 
3516bc2d9db4SLukas Czerner 			/* Extend abut_ex by 'map_len' blocks */
3517bc2d9db4SLukas Czerner 			abut_ex->ee_len = cpu_to_le16(next_len + map_len);
3518bc2d9db4SLukas Czerner 
3519bc2d9db4SLukas Czerner 			/* Result: number of initialized blocks past m_lblk */
3520bc2d9db4SLukas Czerner 			allocated = map_len;
3521bc2d9db4SLukas Czerner 		}
3522bc2d9db4SLukas Czerner 	}
3523bc2d9db4SLukas Czerner 	if (allocated) {
35246f91bc5fSEric Gouriou 		/* Mark the block containing both extents as dirty */
3525b60ca334SHarshad Shirwadkar 		err = ext4_ext_dirty(handle, inode, path + depth);
35266f91bc5fSEric Gouriou 
35276f91bc5fSEric Gouriou 		/* Update path to point to the right extent */
3528bc2d9db4SLukas Czerner 		path[depth].p_ext = abut_ex;
35296f91bc5fSEric Gouriou 		goto out;
3530bc2d9db4SLukas Czerner 	} else
3531bc2d9db4SLukas Czerner 		allocated = ee_len - (map->m_lblk - ee_block);
35326f91bc5fSEric Gouriou 
3533667eff35SYongqiang Yang 	WARN_ON(map->m_lblk < ee_block);
353421ca087aSDmitry Monakhov 	/*
353521ca087aSDmitry Monakhov 	 * It is safe to convert extent to initialized via explicit
35369e740568SYongqiang Yang 	 * zeroout only if extent is fully inside i_size or new_size.
353721ca087aSDmitry Monakhov 	 */
3538667eff35SYongqiang Yang 	split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0;
353921ca087aSDmitry Monakhov 
354067a5da56SZheng Liu 	if (EXT4_EXT_MAY_ZEROOUT & split_flag)
354167a5da56SZheng Liu 		max_zeroout = sbi->s_extent_max_zeroout_kb >>
35424f42f80aSLukas Czerner 			(inode->i_sb->s_blocksize_bits - 10);
354367a5da56SZheng Liu 
3544667eff35SYongqiang Yang 	/*
35454f8caa60SJan Kara 	 * five cases:
3546667eff35SYongqiang Yang 	 * 1. split the extent into three extents.
35474f8caa60SJan Kara 	 * 2. split the extent into two extents, zeroout the head of the first
35484f8caa60SJan Kara 	 *    extent.
35494f8caa60SJan Kara 	 * 3. split the extent into two extents, zeroout the tail of the second
35504f8caa60SJan Kara 	 *    extent.
3551667eff35SYongqiang Yang 	 * 4. split the extent into two extents with out zeroout.
35524f8caa60SJan Kara 	 * 5. no splitting needed, just possibly zeroout the head and / or the
35534f8caa60SJan Kara 	 *    tail of the extent.
3554667eff35SYongqiang Yang 	 */
3555667eff35SYongqiang Yang 	split_map.m_lblk = map->m_lblk;
3556667eff35SYongqiang Yang 	split_map.m_len = map->m_len;
3557667eff35SYongqiang Yang 
35584f8caa60SJan Kara 	if (max_zeroout && (allocated > split_map.m_len)) {
355967a5da56SZheng Liu 		if (allocated <= max_zeroout) {
35604f8caa60SJan Kara 			/* case 3 or 5 */
35614f8caa60SJan Kara 			zero_ex1.ee_block =
35624f8caa60SJan Kara 				 cpu_to_le32(split_map.m_lblk +
35634f8caa60SJan Kara 					     split_map.m_len);
35644f8caa60SJan Kara 			zero_ex1.ee_len =
35654f8caa60SJan Kara 				cpu_to_le16(allocated - split_map.m_len);
35664f8caa60SJan Kara 			ext4_ext_store_pblock(&zero_ex1,
35674f8caa60SJan Kara 				ext4_ext_pblock(ex) + split_map.m_lblk +
35684f8caa60SJan Kara 				split_map.m_len - ee_block);
35694f8caa60SJan Kara 			err = ext4_ext_zeroout(inode, &zero_ex1);
3570667eff35SYongqiang Yang 			if (err)
3571667eff35SYongqiang Yang 				goto out;
3572667eff35SYongqiang Yang 			split_map.m_len = allocated;
35734f8caa60SJan Kara 		}
35744f8caa60SJan Kara 		if (split_map.m_lblk - ee_block + split_map.m_len <
35754f8caa60SJan Kara 								max_zeroout) {
35764f8caa60SJan Kara 			/* case 2 or 5 */
35774f8caa60SJan Kara 			if (split_map.m_lblk != ee_block) {
35784f8caa60SJan Kara 				zero_ex2.ee_block = ex->ee_block;
35794f8caa60SJan Kara 				zero_ex2.ee_len = cpu_to_le16(split_map.m_lblk -
3580667eff35SYongqiang Yang 							ee_block);
35814f8caa60SJan Kara 				ext4_ext_store_pblock(&zero_ex2,
3582667eff35SYongqiang Yang 						      ext4_ext_pblock(ex));
35834f8caa60SJan Kara 				err = ext4_ext_zeroout(inode, &zero_ex2);
3584667eff35SYongqiang Yang 				if (err)
3585667eff35SYongqiang Yang 					goto out;
3586667eff35SYongqiang Yang 			}
3587667eff35SYongqiang Yang 
35884f8caa60SJan Kara 			split_map.m_len += split_map.m_lblk - ee_block;
3589667eff35SYongqiang Yang 			split_map.m_lblk = ee_block;
35909b940f8eSAllison Henderson 			allocated = map->m_len;
3591667eff35SYongqiang Yang 		}
3592667eff35SYongqiang Yang 	}
3593667eff35SYongqiang Yang 
3594ae9e9c6aSJan Kara 	err = ext4_split_extent(handle, inode, ppath, &split_map, split_flag,
3595ae9e9c6aSJan Kara 				flags);
3596ae9e9c6aSJan Kara 	if (err > 0)
3597ae9e9c6aSJan Kara 		err = 0;
3598667eff35SYongqiang Yang out:
3599adb23551SZheng Liu 	/* If we have gotten a failure, don't zero out status tree */
36004f8caa60SJan Kara 	if (!err) {
36014f8caa60SJan Kara 		err = ext4_zeroout_es(inode, &zero_ex1);
3602adb23551SZheng Liu 		if (!err)
36034f8caa60SJan Kara 			err = ext4_zeroout_es(inode, &zero_ex2);
36044f8caa60SJan Kara 	}
3605667eff35SYongqiang Yang 	return err ? err : allocated;
360656055d3aSAmit Arora }
360756055d3aSAmit Arora 
3608c278bfecSAneesh Kumar K.V /*
3609e35fd660STheodore Ts'o  * This function is called by ext4_ext_map_blocks() from
36100031462bSMingming Cao  * ext4_get_blocks_dio_write() when DIO to write
3611556615dcSLukas Czerner  * to an unwritten extent.
36120031462bSMingming Cao  *
3613556615dcSLukas Czerner  * Writing to an unwritten extent may result in splitting the unwritten
3614556615dcSLukas Czerner  * extent into multiple initialized/unwritten extents (up to three)
36150031462bSMingming Cao  * There are three possibilities:
3616556615dcSLukas Czerner  *   a> There is no split required: Entire extent should be unwritten
36170031462bSMingming Cao  *   b> Splits in two extents: Write is happening at either end of the extent
36180031462bSMingming Cao  *   c> Splits in three extents: Somone is writing in middle of the extent
36190031462bSMingming Cao  *
3620b8a86845SLukas Czerner  * This works the same way in the case of initialized -> unwritten conversion.
3621b8a86845SLukas Czerner  *
36220031462bSMingming Cao  * One of more index blocks maybe needed if the extent tree grow after
3623556615dcSLukas Czerner  * the unwritten extent split. To prevent ENOSPC occur at the IO
3624556615dcSLukas Czerner  * complete, we need to split the unwritten extent before DIO submit
3625556615dcSLukas Czerner  * the IO. The unwritten extent called at this time will be split
3626556615dcSLukas Czerner  * into three unwritten extent(at most). After IO complete, the part
36270031462bSMingming Cao  * being filled will be convert to initialized by the end_io callback function
36280031462bSMingming Cao  * via ext4_convert_unwritten_extents().
3629ba230c3fSMingming  *
3630556615dcSLukas Czerner  * Returns the size of unwritten extent to be written on success.
36310031462bSMingming Cao  */
3632b8a86845SLukas Czerner static int ext4_split_convert_extents(handle_t *handle,
36330031462bSMingming Cao 					struct inode *inode,
3634e35fd660STheodore Ts'o 					struct ext4_map_blocks *map,
3635dfe50809STheodore Ts'o 					struct ext4_ext_path **ppath,
36360031462bSMingming Cao 					int flags)
36370031462bSMingming Cao {
3638dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
3639667eff35SYongqiang Yang 	ext4_lblk_t eof_block;
3640667eff35SYongqiang Yang 	ext4_lblk_t ee_block;
3641667eff35SYongqiang Yang 	struct ext4_extent *ex;
3642667eff35SYongqiang Yang 	unsigned int ee_len;
3643667eff35SYongqiang Yang 	int split_flag = 0, depth;
36440031462bSMingming Cao 
3645b8a86845SLukas Czerner 	ext_debug("%s: inode %lu, logical block %llu, max_blocks %u\n",
3646b8a86845SLukas Czerner 		  __func__, inode->i_ino,
3647e35fd660STheodore Ts'o 		  (unsigned long long)map->m_lblk, map->m_len);
364821ca087aSDmitry Monakhov 
3649801674f3SJan Kara 	eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3650801674f3SJan Kara 			>> inode->i_sb->s_blocksize_bits;
3651e35fd660STheodore Ts'o 	if (eof_block < map->m_lblk + map->m_len)
3652e35fd660STheodore Ts'o 		eof_block = map->m_lblk + map->m_len;
36530031462bSMingming Cao 	/*
365421ca087aSDmitry Monakhov 	 * It is safe to convert extent to initialized via explicit
365521ca087aSDmitry Monakhov 	 * zeroout only if extent is fully insde i_size or new_size.
365621ca087aSDmitry Monakhov 	 */
3657667eff35SYongqiang Yang 	depth = ext_depth(inode);
36580031462bSMingming Cao 	ex = path[depth].p_ext;
3659667eff35SYongqiang Yang 	ee_block = le32_to_cpu(ex->ee_block);
3660667eff35SYongqiang Yang 	ee_len = ext4_ext_get_actual_len(ex);
36610031462bSMingming Cao 
3662b8a86845SLukas Czerner 	/* Convert to unwritten */
3663b8a86845SLukas Czerner 	if (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN) {
3664b8a86845SLukas Czerner 		split_flag |= EXT4_EXT_DATA_VALID1;
3665b8a86845SLukas Czerner 	/* Convert to initialized */
3666b8a86845SLukas Czerner 	} else if (flags & EXT4_GET_BLOCKS_CONVERT) {
3667b8a86845SLukas Czerner 		split_flag |= ee_block + ee_len <= eof_block ?
3668b8a86845SLukas Czerner 			      EXT4_EXT_MAY_ZEROOUT : 0;
3669556615dcSLukas Czerner 		split_flag |= (EXT4_EXT_MARK_UNWRIT2 | EXT4_EXT_DATA_VALID2);
3670b8a86845SLukas Czerner 	}
3671667eff35SYongqiang Yang 	flags |= EXT4_GET_BLOCKS_PRE_IO;
3672dfe50809STheodore Ts'o 	return ext4_split_extent(handle, inode, ppath, map, split_flag, flags);
36730031462bSMingming Cao }
3674197217a5SYongqiang Yang 
3675c7064ef1SJiaying Zhang static int ext4_convert_unwritten_extents_endio(handle_t *handle,
36760031462bSMingming Cao 						struct inode *inode,
3677dee1f973SDmitry Monakhov 						struct ext4_map_blocks *map,
3678dfe50809STheodore Ts'o 						struct ext4_ext_path **ppath)
36790031462bSMingming Cao {
3680dfe50809STheodore Ts'o 	struct ext4_ext_path *path = *ppath;
36810031462bSMingming Cao 	struct ext4_extent *ex;
3682dee1f973SDmitry Monakhov 	ext4_lblk_t ee_block;
3683dee1f973SDmitry Monakhov 	unsigned int ee_len;
36840031462bSMingming Cao 	int depth;
36850031462bSMingming Cao 	int err = 0;
36860031462bSMingming Cao 
36870031462bSMingming Cao 	depth = ext_depth(inode);
36880031462bSMingming Cao 	ex = path[depth].p_ext;
3689dee1f973SDmitry Monakhov 	ee_block = le32_to_cpu(ex->ee_block);
3690dee1f973SDmitry Monakhov 	ee_len = ext4_ext_get_actual_len(ex);
36910031462bSMingming Cao 
3692197217a5SYongqiang Yang 	ext_debug("ext4_convert_unwritten_extents_endio: inode %lu, logical"
3693197217a5SYongqiang Yang 		"block %llu, max_blocks %u\n", inode->i_ino,
3694dee1f973SDmitry Monakhov 		  (unsigned long long)ee_block, ee_len);
3695dee1f973SDmitry Monakhov 
3696ff95ec22SDmitry Monakhov 	/* If extent is larger than requested it is a clear sign that we still
3697ff95ec22SDmitry Monakhov 	 * have some extent state machine issues left. So extent_split is still
3698ff95ec22SDmitry Monakhov 	 * required.
3699ff95ec22SDmitry Monakhov 	 * TODO: Once all related issues will be fixed this situation should be
3700ff95ec22SDmitry Monakhov 	 * illegal.
3701ff95ec22SDmitry Monakhov 	 */
3702dee1f973SDmitry Monakhov 	if (ee_block != map->m_lblk || ee_len > map->m_len) {
3703e3d550c2SRakesh Pandit #ifdef CONFIG_EXT4_DEBUG
3704e3d550c2SRakesh Pandit 		ext4_warning(inode->i_sb, "Inode (%ld) finished: extent logical block %llu,"
37058d2ae1cbSJakub Wilk 			     " len %u; IO logical block %llu, len %u",
3706ff95ec22SDmitry Monakhov 			     inode->i_ino, (unsigned long long)ee_block, ee_len,
3707ff95ec22SDmitry Monakhov 			     (unsigned long long)map->m_lblk, map->m_len);
3708ff95ec22SDmitry Monakhov #endif
3709dfe50809STheodore Ts'o 		err = ext4_split_convert_extents(handle, inode, map, ppath,
3710dee1f973SDmitry Monakhov 						 EXT4_GET_BLOCKS_CONVERT);
3711dee1f973SDmitry Monakhov 		if (err < 0)
3712dfe50809STheodore Ts'o 			return err;
3713ed8a1a76STheodore Ts'o 		path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3714dfe50809STheodore Ts'o 		if (IS_ERR(path))
3715dfe50809STheodore Ts'o 			return PTR_ERR(path);
3716dee1f973SDmitry Monakhov 		depth = ext_depth(inode);
3717dee1f973SDmitry Monakhov 		ex = path[depth].p_ext;
3718dee1f973SDmitry Monakhov 	}
3719197217a5SYongqiang Yang 
37200031462bSMingming Cao 	err = ext4_ext_get_access(handle, inode, path + depth);
37210031462bSMingming Cao 	if (err)
37220031462bSMingming Cao 		goto out;
37230031462bSMingming Cao 	/* first mark the extent as initialized */
37240031462bSMingming Cao 	ext4_ext_mark_initialized(ex);
37250031462bSMingming Cao 
3726197217a5SYongqiang Yang 	/* note: ext4_ext_correct_indexes() isn't needed here because
3727197217a5SYongqiang Yang 	 * borders are not changed
37280031462bSMingming Cao 	 */
3729ecb94f5fSTheodore Ts'o 	ext4_ext_try_to_merge(handle, inode, path, ex);
3730197217a5SYongqiang Yang 
37310031462bSMingming Cao 	/* Mark modified extent as dirty */
3732ecb94f5fSTheodore Ts'o 	err = ext4_ext_dirty(handle, inode, path + path->p_depth);
37330031462bSMingming Cao out:
37340031462bSMingming Cao 	ext4_ext_show_leaf(inode, path);
37350031462bSMingming Cao 	return err;
37360031462bSMingming Cao }
37370031462bSMingming Cao 
37380031462bSMingming Cao static int
3739e8b83d93STheodore Ts'o convert_initialized_extent(handle_t *handle, struct inode *inode,
3740b8a86845SLukas Czerner 			   struct ext4_map_blocks *map,
374129c6eaffSEric Whitney 			   struct ext4_ext_path **ppath,
3742f064a9d6SEric Whitney 			   unsigned int *allocated)
3743b8a86845SLukas Czerner {
37444f224b8bSTheodore Ts'o 	struct ext4_ext_path *path = *ppath;
3745e8b83d93STheodore Ts'o 	struct ext4_extent *ex;
3746e8b83d93STheodore Ts'o 	ext4_lblk_t ee_block;
3747e8b83d93STheodore Ts'o 	unsigned int ee_len;
3748e8b83d93STheodore Ts'o 	int depth;
3749b8a86845SLukas Czerner 	int err = 0;
3750b8a86845SLukas Czerner 
3751b8a86845SLukas Czerner 	/*
3752b8a86845SLukas Czerner 	 * Make sure that the extent is no bigger than we support with
3753556615dcSLukas Czerner 	 * unwritten extent
3754b8a86845SLukas Czerner 	 */
3755556615dcSLukas Czerner 	if (map->m_len > EXT_UNWRITTEN_MAX_LEN)
3756556615dcSLukas Czerner 		map->m_len = EXT_UNWRITTEN_MAX_LEN / 2;
3757b8a86845SLukas Czerner 
3758e8b83d93STheodore Ts'o 	depth = ext_depth(inode);
3759e8b83d93STheodore Ts'o 	ex = path[depth].p_ext;
3760e8b83d93STheodore Ts'o 	ee_block = le32_to_cpu(ex->ee_block);
3761e8b83d93STheodore Ts'o 	ee_len = ext4_ext_get_actual_len(ex);
3762e8b83d93STheodore Ts'o 
3763e8b83d93STheodore Ts'o 	ext_debug("%s: inode %lu, logical"
3764e8b83d93STheodore Ts'o 		"block %llu, max_blocks %u\n", __func__, inode->i_ino,
3765e8b83d93STheodore Ts'o 		  (unsigned long long)ee_block, ee_len);
3766e8b83d93STheodore Ts'o 
3767e8b83d93STheodore Ts'o 	if (ee_block != map->m_lblk || ee_len > map->m_len) {
3768dfe50809STheodore Ts'o 		err = ext4_split_convert_extents(handle, inode, map, ppath,
3769e8b83d93STheodore Ts'o 				EXT4_GET_BLOCKS_CONVERT_UNWRITTEN);
3770e8b83d93STheodore Ts'o 		if (err < 0)
3771e8b83d93STheodore Ts'o 			return err;
3772ed8a1a76STheodore Ts'o 		path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3773e8b83d93STheodore Ts'o 		if (IS_ERR(path))
3774e8b83d93STheodore Ts'o 			return PTR_ERR(path);
3775e8b83d93STheodore Ts'o 		depth = ext_depth(inode);
3776e8b83d93STheodore Ts'o 		ex = path[depth].p_ext;
3777e8b83d93STheodore Ts'o 		if (!ex) {
3778e8b83d93STheodore Ts'o 			EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3779e8b83d93STheodore Ts'o 					 (unsigned long) map->m_lblk);
37806a797d27SDarrick J. Wong 			return -EFSCORRUPTED;
3781e8b83d93STheodore Ts'o 		}
3782e8b83d93STheodore Ts'o 	}
3783e8b83d93STheodore Ts'o 
3784e8b83d93STheodore Ts'o 	err = ext4_ext_get_access(handle, inode, path + depth);
3785e8b83d93STheodore Ts'o 	if (err)
3786e8b83d93STheodore Ts'o 		return err;
3787e8b83d93STheodore Ts'o 	/* first mark the extent as unwritten */
3788e8b83d93STheodore Ts'o 	ext4_ext_mark_unwritten(ex);
3789e8b83d93STheodore Ts'o 
3790e8b83d93STheodore Ts'o 	/* note: ext4_ext_correct_indexes() isn't needed here because
3791e8b83d93STheodore Ts'o 	 * borders are not changed
3792e8b83d93STheodore Ts'o 	 */
3793e8b83d93STheodore Ts'o 	ext4_ext_try_to_merge(handle, inode, path, ex);
3794e8b83d93STheodore Ts'o 
3795e8b83d93STheodore Ts'o 	/* Mark modified extent as dirty */
3796e8b83d93STheodore Ts'o 	err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3797e8b83d93STheodore Ts'o 	if (err)
3798e8b83d93STheodore Ts'o 		return err;
3799e8b83d93STheodore Ts'o 	ext4_ext_show_leaf(inode, path);
3800e8b83d93STheodore Ts'o 
3801b8a86845SLukas Czerner 	ext4_update_inode_fsync_trans(handle, inode, 1);
38024337ecd1SEric Whitney 
3803b8a86845SLukas Czerner 	map->m_flags |= EXT4_MAP_UNWRITTEN;
3804f064a9d6SEric Whitney 	if (*allocated > map->m_len)
3805f064a9d6SEric Whitney 		*allocated = map->m_len;
3806f064a9d6SEric Whitney 	map->m_len = *allocated;
3807f064a9d6SEric Whitney 	return 0;
3808b8a86845SLukas Czerner }
3809b8a86845SLukas Czerner 
3810b8a86845SLukas Czerner static int
3811556615dcSLukas Czerner ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode,
3812e35fd660STheodore Ts'o 			struct ext4_map_blocks *map,
3813dfe50809STheodore Ts'o 			struct ext4_ext_path **ppath, int flags,
3814e35fd660STheodore Ts'o 			unsigned int allocated, ext4_fsblk_t newblock)
38150031462bSMingming Cao {
3816*8ec2d31bSRitesh Harjani 	struct ext4_ext_path __maybe_unused *path = *ppath;
38170031462bSMingming Cao 	int ret = 0;
38180031462bSMingming Cao 	int err = 0;
38190031462bSMingming Cao 
3820556615dcSLukas Czerner 	ext_debug("ext4_ext_handle_unwritten_extents: inode %lu, logical "
382188635ca2SZheng Liu 		  "block %llu, max_blocks %u, flags %x, allocated %u\n",
3822e35fd660STheodore Ts'o 		  inode->i_ino, (unsigned long long)map->m_lblk, map->m_len,
38230031462bSMingming Cao 		  flags, allocated);
38240031462bSMingming Cao 	ext4_ext_show_leaf(inode, path);
38250031462bSMingming Cao 
382627dd4385SLukas Czerner 	/*
3827556615dcSLukas Czerner 	 * When writing into unwritten space, we should not fail to
382827dd4385SLukas Czerner 	 * allocate metadata blocks for the new extent block if needed.
382927dd4385SLukas Czerner 	 */
383027dd4385SLukas Czerner 	flags |= EXT4_GET_BLOCKS_METADATA_NOFAIL;
383127dd4385SLukas Czerner 
3832556615dcSLukas Czerner 	trace_ext4_ext_handle_unwritten_extents(inode, map, flags,
3833b5645534SZheng Liu 						    allocated, newblock);
3834d8990240SAditya Kali 
3835779e2651SEric Whitney 	/* get_block() before submitting IO, split the extent */
3836c8b459f4SLukas Czerner 	if (flags & EXT4_GET_BLOCKS_PRE_IO) {
3837dfe50809STheodore Ts'o 		ret = ext4_split_convert_extents(handle, inode, map, ppath,
3838dfe50809STheodore Ts'o 					 flags | EXT4_GET_BLOCKS_CONVERT);
3839779e2651SEric Whitney 		if (ret < 0) {
3840779e2651SEric Whitney 			err = ret;
3841779e2651SEric Whitney 			goto out2;
3842779e2651SEric Whitney 		}
3843779e2651SEric Whitney 		/*
3844779e2651SEric Whitney 		 * shouldn't get a 0 return when splitting an extent unless
3845779e2651SEric Whitney 		 * m_len is 0 (bug) or extent has been corrupted
3846779e2651SEric Whitney 		 */
3847779e2651SEric Whitney 		if (unlikely(ret == 0)) {
3848779e2651SEric Whitney 			EXT4_ERROR_INODE(inode,
3849779e2651SEric Whitney 					 "unexpected ret == 0, m_len = %u",
3850779e2651SEric Whitney 					 map->m_len);
3851779e2651SEric Whitney 			err = -EFSCORRUPTED;
3852779e2651SEric Whitney 			goto out2;
3853779e2651SEric Whitney 		}
3854a25a4e1aSZheng Liu 		map->m_flags |= EXT4_MAP_UNWRITTEN;
38550031462bSMingming Cao 		goto out;
38560031462bSMingming Cao 	}
3857c7064ef1SJiaying Zhang 	/* IO end_io complete, convert the filled extent to written */
3858c8b459f4SLukas Czerner 	if (flags & EXT4_GET_BLOCKS_CONVERT) {
3859bee6cf00SEric Whitney 		err = ext4_convert_unwritten_extents_endio(handle, inode, map,
3860dfe50809STheodore Ts'o 							   ppath);
3861bee6cf00SEric Whitney 		if (err < 0)
38620031462bSMingming Cao 			goto out2;
3863bee6cf00SEric Whitney 		ext4_update_inode_fsync_trans(handle, inode, 1);
3864bee6cf00SEric Whitney 		goto map_out;
38650031462bSMingming Cao 	}
3866bee6cf00SEric Whitney 	/* buffered IO cases */
38670031462bSMingming Cao 	/*
38680031462bSMingming Cao 	 * repeat fallocate creation request
38690031462bSMingming Cao 	 * we already have an unwritten extent
38700031462bSMingming Cao 	 */
3871556615dcSLukas Czerner 	if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT) {
3872a25a4e1aSZheng Liu 		map->m_flags |= EXT4_MAP_UNWRITTEN;
38730031462bSMingming Cao 		goto map_out;
3874a25a4e1aSZheng Liu 	}
38750031462bSMingming Cao 
38760031462bSMingming Cao 	/* buffered READ or buffered write_begin() lookup */
38770031462bSMingming Cao 	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
38780031462bSMingming Cao 		/*
38790031462bSMingming Cao 		 * We have blocks reserved already.  We
38800031462bSMingming Cao 		 * return allocated blocks so that delalloc
38810031462bSMingming Cao 		 * won't do block reservation for us.  But
38820031462bSMingming Cao 		 * the buffer head will be unmapped so that
38830031462bSMingming Cao 		 * a read from the block returns 0s.
38840031462bSMingming Cao 		 */
3885e35fd660STheodore Ts'o 		map->m_flags |= EXT4_MAP_UNWRITTEN;
38860031462bSMingming Cao 		goto out1;
38870031462bSMingming Cao 	}
38880031462bSMingming Cao 
3889be809e12SEric Whitney 	/*
3890be809e12SEric Whitney 	 * Default case when (flags & EXT4_GET_BLOCKS_CREATE) == 1.
3891be809e12SEric Whitney 	 * For buffered writes, at writepage time, etc.  Convert a
3892be809e12SEric Whitney 	 * discovered unwritten extent to written.
3893be809e12SEric Whitney 	 */
3894dfe50809STheodore Ts'o 	ret = ext4_ext_convert_to_initialized(handle, inode, map, ppath, flags);
3895be809e12SEric Whitney 	if (ret < 0) {
38960031462bSMingming Cao 		err = ret;
38970031462bSMingming Cao 		goto out2;
3898779e2651SEric Whitney 	}
3899be809e12SEric Whitney 	ext4_update_inode_fsync_trans(handle, inode, 1);
3900be809e12SEric Whitney 	/*
3901be809e12SEric Whitney 	 * shouldn't get a 0 return when converting an unwritten extent
3902be809e12SEric Whitney 	 * unless m_len is 0 (bug) or extent has been corrupted
3903be809e12SEric Whitney 	 */
3904be809e12SEric Whitney 	if (unlikely(ret == 0)) {
3905be809e12SEric Whitney 		EXT4_ERROR_INODE(inode, "unexpected ret == 0, m_len = %u",
3906be809e12SEric Whitney 				 map->m_len);
3907be809e12SEric Whitney 		err = -EFSCORRUPTED;
3908be809e12SEric Whitney 		goto out2;
3909be809e12SEric Whitney 	}
3910be809e12SEric Whitney 
3911779e2651SEric Whitney out:
39120031462bSMingming Cao 	allocated = ret;
3913e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_NEW;
39140031462bSMingming Cao map_out:
3915e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_MAPPED;
39160031462bSMingming Cao out1:
3917bee6cf00SEric Whitney 	map->m_pblk = newblock;
3918e35fd660STheodore Ts'o 	if (allocated > map->m_len)
3919e35fd660STheodore Ts'o 		allocated = map->m_len;
3920e35fd660STheodore Ts'o 	map->m_len = allocated;
3921bee6cf00SEric Whitney 	ext4_ext_show_leaf(inode, path);
39220031462bSMingming Cao out2:
39230031462bSMingming Cao 	return err ? err : allocated;
39240031462bSMingming Cao }
392558590b06STheodore Ts'o 
39260031462bSMingming Cao /*
39274d33b1efSTheodore Ts'o  * get_implied_cluster_alloc - check to see if the requested
39284d33b1efSTheodore Ts'o  * allocation (in the map structure) overlaps with a cluster already
39294d33b1efSTheodore Ts'o  * allocated in an extent.
3930d8990240SAditya Kali  *	@sb	The filesystem superblock structure
39314d33b1efSTheodore Ts'o  *	@map	The requested lblk->pblk mapping
39324d33b1efSTheodore Ts'o  *	@ex	The extent structure which might contain an implied
39334d33b1efSTheodore Ts'o  *			cluster allocation
39344d33b1efSTheodore Ts'o  *
39354d33b1efSTheodore Ts'o  * This function is called by ext4_ext_map_blocks() after we failed to
39364d33b1efSTheodore Ts'o  * find blocks that were already in the inode's extent tree.  Hence,
39374d33b1efSTheodore Ts'o  * we know that the beginning of the requested region cannot overlap
39384d33b1efSTheodore Ts'o  * the extent from the inode's extent tree.  There are three cases we
39394d33b1efSTheodore Ts'o  * want to catch.  The first is this case:
39404d33b1efSTheodore Ts'o  *
39414d33b1efSTheodore Ts'o  *		 |--- cluster # N--|
39424d33b1efSTheodore Ts'o  *    |--- extent ---|	|---- requested region ---|
39434d33b1efSTheodore Ts'o  *			|==========|
39444d33b1efSTheodore Ts'o  *
39454d33b1efSTheodore Ts'o  * The second case that we need to test for is this one:
39464d33b1efSTheodore Ts'o  *
39474d33b1efSTheodore Ts'o  *   |--------- cluster # N ----------------|
39484d33b1efSTheodore Ts'o  *	   |--- requested region --|   |------- extent ----|
39494d33b1efSTheodore Ts'o  *	   |=======================|
39504d33b1efSTheodore Ts'o  *
39514d33b1efSTheodore Ts'o  * The third case is when the requested region lies between two extents
39524d33b1efSTheodore Ts'o  * within the same cluster:
39534d33b1efSTheodore Ts'o  *          |------------- cluster # N-------------|
39544d33b1efSTheodore Ts'o  * |----- ex -----|                  |---- ex_right ----|
39554d33b1efSTheodore Ts'o  *                  |------ requested region ------|
39564d33b1efSTheodore Ts'o  *                  |================|
39574d33b1efSTheodore Ts'o  *
39584d33b1efSTheodore Ts'o  * In each of the above cases, we need to set the map->m_pblk and
39594d33b1efSTheodore Ts'o  * map->m_len so it corresponds to the return the extent labelled as
39604d33b1efSTheodore Ts'o  * "|====|" from cluster #N, since it is already in use for data in
39614d33b1efSTheodore Ts'o  * cluster EXT4_B2C(sbi, map->m_lblk).	We will then return 1 to
39624d33b1efSTheodore Ts'o  * signal to ext4_ext_map_blocks() that map->m_pblk should be treated
39634d33b1efSTheodore Ts'o  * as a new "allocated" block region.  Otherwise, we will return 0 and
39644d33b1efSTheodore Ts'o  * ext4_ext_map_blocks() will then allocate one or more new clusters
39654d33b1efSTheodore Ts'o  * by calling ext4_mb_new_blocks().
39664d33b1efSTheodore Ts'o  */
3967d8990240SAditya Kali static int get_implied_cluster_alloc(struct super_block *sb,
39684d33b1efSTheodore Ts'o 				     struct ext4_map_blocks *map,
39694d33b1efSTheodore Ts'o 				     struct ext4_extent *ex,
39704d33b1efSTheodore Ts'o 				     struct ext4_ext_path *path)
39714d33b1efSTheodore Ts'o {
3972d8990240SAditya Kali 	struct ext4_sb_info *sbi = EXT4_SB(sb);
3973f5a44db5STheodore Ts'o 	ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
39744d33b1efSTheodore Ts'o 	ext4_lblk_t ex_cluster_start, ex_cluster_end;
397514d7f3efSCurt Wohlgemuth 	ext4_lblk_t rr_cluster_start;
39764d33b1efSTheodore Ts'o 	ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
39774d33b1efSTheodore Ts'o 	ext4_fsblk_t ee_start = ext4_ext_pblock(ex);
39784d33b1efSTheodore Ts'o 	unsigned short ee_len = ext4_ext_get_actual_len(ex);
39794d33b1efSTheodore Ts'o 
39804d33b1efSTheodore Ts'o 	/* The extent passed in that we are trying to match */
39814d33b1efSTheodore Ts'o 	ex_cluster_start = EXT4_B2C(sbi, ee_block);
39824d33b1efSTheodore Ts'o 	ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1);
39834d33b1efSTheodore Ts'o 
39844d33b1efSTheodore Ts'o 	/* The requested region passed into ext4_map_blocks() */
39854d33b1efSTheodore Ts'o 	rr_cluster_start = EXT4_B2C(sbi, map->m_lblk);
39864d33b1efSTheodore Ts'o 
39874d33b1efSTheodore Ts'o 	if ((rr_cluster_start == ex_cluster_end) ||
39884d33b1efSTheodore Ts'o 	    (rr_cluster_start == ex_cluster_start)) {
39894d33b1efSTheodore Ts'o 		if (rr_cluster_start == ex_cluster_end)
39904d33b1efSTheodore Ts'o 			ee_start += ee_len - 1;
3991f5a44db5STheodore Ts'o 		map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset;
39924d33b1efSTheodore Ts'o 		map->m_len = min(map->m_len,
39934d33b1efSTheodore Ts'o 				 (unsigned) sbi->s_cluster_ratio - c_offset);
39944d33b1efSTheodore Ts'o 		/*
39954d33b1efSTheodore Ts'o 		 * Check for and handle this case:
39964d33b1efSTheodore Ts'o 		 *
39974d33b1efSTheodore Ts'o 		 *   |--------- cluster # N-------------|
39984d33b1efSTheodore Ts'o 		 *		       |------- extent ----|
39994d33b1efSTheodore Ts'o 		 *	   |--- requested region ---|
40004d33b1efSTheodore Ts'o 		 *	   |===========|
40014d33b1efSTheodore Ts'o 		 */
40024d33b1efSTheodore Ts'o 
40034d33b1efSTheodore Ts'o 		if (map->m_lblk < ee_block)
40044d33b1efSTheodore Ts'o 			map->m_len = min(map->m_len, ee_block - map->m_lblk);
40054d33b1efSTheodore Ts'o 
40064d33b1efSTheodore Ts'o 		/*
40074d33b1efSTheodore Ts'o 		 * Check for the case where there is already another allocated
40084d33b1efSTheodore Ts'o 		 * block to the right of 'ex' but before the end of the cluster.
40094d33b1efSTheodore Ts'o 		 *
40104d33b1efSTheodore Ts'o 		 *          |------------- cluster # N-------------|
40114d33b1efSTheodore Ts'o 		 * |----- ex -----|                  |---- ex_right ----|
40124d33b1efSTheodore Ts'o 		 *                  |------ requested region ------|
40134d33b1efSTheodore Ts'o 		 *                  |================|
40144d33b1efSTheodore Ts'o 		 */
40154d33b1efSTheodore Ts'o 		if (map->m_lblk > ee_block) {
40164d33b1efSTheodore Ts'o 			ext4_lblk_t next = ext4_ext_next_allocated_block(path);
40174d33b1efSTheodore Ts'o 			map->m_len = min(map->m_len, next - map->m_lblk);
40184d33b1efSTheodore Ts'o 		}
4019d8990240SAditya Kali 
4020d8990240SAditya Kali 		trace_ext4_get_implied_cluster_alloc_exit(sb, map, 1);
40214d33b1efSTheodore Ts'o 		return 1;
40224d33b1efSTheodore Ts'o 	}
4023d8990240SAditya Kali 
4024d8990240SAditya Kali 	trace_ext4_get_implied_cluster_alloc_exit(sb, map, 0);
40254d33b1efSTheodore Ts'o 	return 0;
40264d33b1efSTheodore Ts'o }
40274d33b1efSTheodore Ts'o 
40284d33b1efSTheodore Ts'o 
40294d33b1efSTheodore Ts'o /*
4030f5ab0d1fSMingming Cao  * Block allocation/map/preallocation routine for extents based files
4031f5ab0d1fSMingming Cao  *
4032f5ab0d1fSMingming Cao  *
4033c278bfecSAneesh Kumar K.V  * Need to be called with
40340e855ac8SAneesh Kumar K.V  * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
40350e855ac8SAneesh Kumar K.V  * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
4036f5ab0d1fSMingming Cao  *
4037f5ab0d1fSMingming Cao  * return > 0, number of of blocks already mapped/allocated
4038f5ab0d1fSMingming Cao  *          if create == 0 and these are pre-allocated blocks
4039f5ab0d1fSMingming Cao  *          	buffer head is unmapped
4040f5ab0d1fSMingming Cao  *          otherwise blocks are mapped
4041f5ab0d1fSMingming Cao  *
4042f5ab0d1fSMingming Cao  * return = 0, if plain look up failed (blocks have not been allocated)
4043f5ab0d1fSMingming Cao  *          buffer head is unmapped
4044f5ab0d1fSMingming Cao  *
4045f5ab0d1fSMingming Cao  * return < 0, error case.
4046c278bfecSAneesh Kumar K.V  */
4047e35fd660STheodore Ts'o int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
4048e35fd660STheodore Ts'o 			struct ext4_map_blocks *map, int flags)
4049a86c6181SAlex Tomas {
4050a86c6181SAlex Tomas 	struct ext4_ext_path *path = NULL;
40514d33b1efSTheodore Ts'o 	struct ext4_extent newex, *ex, *ex2;
40524d33b1efSTheodore Ts'o 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
40530562e0baSJiaying Zhang 	ext4_fsblk_t newblock = 0;
405434990461SEric Whitney 	int err = 0, depth, ret;
40554d33b1efSTheodore Ts'o 	unsigned int allocated = 0, offset = 0;
405681fdbb4aSYongqiang Yang 	unsigned int allocated_clusters = 0;
4057c9de560dSAlex Tomas 	struct ext4_allocation_request ar;
40584d33b1efSTheodore Ts'o 	ext4_lblk_t cluster_offset;
4059a86c6181SAlex Tomas 
406084fe3befSMingming 	ext_debug("blocks %u/%u requested for inode %lu\n",
4061e35fd660STheodore Ts'o 		  map->m_lblk, map->m_len, inode->i_ino);
40620562e0baSJiaying Zhang 	trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
4063a86c6181SAlex Tomas 
4064a86c6181SAlex Tomas 	/* find extent for this block */
4065ed8a1a76STheodore Ts'o 	path = ext4_find_extent(inode, map->m_lblk, NULL, 0);
4066a86c6181SAlex Tomas 	if (IS_ERR(path)) {
4067a86c6181SAlex Tomas 		err = PTR_ERR(path);
4068a86c6181SAlex Tomas 		path = NULL;
4069a86c6181SAlex Tomas 		goto out2;
4070a86c6181SAlex Tomas 	}
4071a86c6181SAlex Tomas 
4072a86c6181SAlex Tomas 	depth = ext_depth(inode);
4073a86c6181SAlex Tomas 
4074a86c6181SAlex Tomas 	/*
4075d0d856e8SRandy Dunlap 	 * consistent leaf must not be empty;
4076d0d856e8SRandy Dunlap 	 * this situation is possible, though, _during_ tree modification;
4077ed8a1a76STheodore Ts'o 	 * this is why assert can't be put in ext4_find_extent()
4078a86c6181SAlex Tomas 	 */
4079273df556SFrank Mayhar 	if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
4080273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "bad extent address "
4081f70f362bSTheodore Ts'o 				 "lblock: %lu, depth: %d pblock %lld",
4082f70f362bSTheodore Ts'o 				 (unsigned long) map->m_lblk, depth,
4083f70f362bSTheodore Ts'o 				 path[depth].p_block);
40846a797d27SDarrick J. Wong 		err = -EFSCORRUPTED;
4085034fb4c9SSurbhi Palande 		goto out2;
4086034fb4c9SSurbhi Palande 	}
4087a86c6181SAlex Tomas 
40887e028976SAvantika Mathur 	ex = path[depth].p_ext;
40897e028976SAvantika Mathur 	if (ex) {
4090725d26d3SAneesh Kumar K.V 		ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
4091bf89d16fSTheodore Ts'o 		ext4_fsblk_t ee_start = ext4_ext_pblock(ex);
4092a2df2a63SAmit Arora 		unsigned short ee_len;
4093471d4011SSuparna Bhattacharya 
4094b8a86845SLukas Czerner 
4095471d4011SSuparna Bhattacharya 		/*
4096556615dcSLukas Czerner 		 * unwritten extents are treated as holes, except that
409756055d3aSAmit Arora 		 * we split out initialized portions during a write.
4098471d4011SSuparna Bhattacharya 		 */
4099a2df2a63SAmit Arora 		ee_len = ext4_ext_get_actual_len(ex);
4100d8990240SAditya Kali 
4101d8990240SAditya Kali 		trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len);
4102d8990240SAditya Kali 
4103d0d856e8SRandy Dunlap 		/* if found extent covers block, simply return it */
4104e35fd660STheodore Ts'o 		if (in_range(map->m_lblk, ee_block, ee_len)) {
4105e35fd660STheodore Ts'o 			newblock = map->m_lblk - ee_block + ee_start;
4106d0d856e8SRandy Dunlap 			/* number of remaining blocks in the extent */
4107e35fd660STheodore Ts'o 			allocated = ee_len - (map->m_lblk - ee_block);
4108e35fd660STheodore Ts'o 			ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk,
4109a86c6181SAlex Tomas 				  ee_block, ee_len, newblock);
411056055d3aSAmit Arora 
4111b8a86845SLukas Czerner 			/*
4112b8a86845SLukas Czerner 			 * If the extent is initialized check whether the
4113b8a86845SLukas Czerner 			 * caller wants to convert it to unwritten.
4114b8a86845SLukas Czerner 			 */
4115556615dcSLukas Czerner 			if ((!ext4_ext_is_unwritten(ex)) &&
4116b8a86845SLukas Czerner 			    (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN)) {
4117f064a9d6SEric Whitney 				err = convert_initialized_extent(handle,
4118f064a9d6SEric Whitney 					inode, map, &path, &allocated);
4119b8a86845SLukas Czerner 				goto out2;
4120f064a9d6SEric Whitney 			} else if (!ext4_ext_is_unwritten(ex)) {
4121a86c6181SAlex Tomas 				goto out;
4122f064a9d6SEric Whitney 			}
412369eb33dcSZheng Liu 
4124556615dcSLukas Czerner 			ret = ext4_ext_handle_unwritten_extents(
4125dfe50809STheodore Ts'o 				handle, inode, map, &path, flags,
4126e861304bSAllison Henderson 				allocated, newblock);
4127ce37c429SEric Whitney 			if (ret < 0)
4128ce37c429SEric Whitney 				err = ret;
4129ce37c429SEric Whitney 			else
4130ce37c429SEric Whitney 				allocated = ret;
413131cf0f2cSEric Whitney 			goto out2;
413256055d3aSAmit Arora 		}
4133a86c6181SAlex Tomas 	}
4134a86c6181SAlex Tomas 
4135a86c6181SAlex Tomas 	/*
4136d0d856e8SRandy Dunlap 	 * requested block isn't allocated yet;
4137a86c6181SAlex Tomas 	 * we couldn't try to create block if create flag is zero
4138a86c6181SAlex Tomas 	 */
4139c2177057STheodore Ts'o 	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
4140140a5250SJan Kara 		ext4_lblk_t hole_start, hole_len;
4141140a5250SJan Kara 
4142facab4d9SJan Kara 		hole_start = map->m_lblk;
4143facab4d9SJan Kara 		hole_len = ext4_ext_determine_hole(inode, path, &hole_start);
414456055d3aSAmit Arora 		/*
414556055d3aSAmit Arora 		 * put just found gap into cache to speed up
414656055d3aSAmit Arora 		 * subsequent requests
414756055d3aSAmit Arora 		 */
4148140a5250SJan Kara 		ext4_ext_put_gap_in_cache(inode, hole_start, hole_len);
4149facab4d9SJan Kara 
4150facab4d9SJan Kara 		/* Update hole_len to reflect hole size after map->m_lblk */
4151facab4d9SJan Kara 		if (hole_start != map->m_lblk)
4152facab4d9SJan Kara 			hole_len -= map->m_lblk - hole_start;
4153facab4d9SJan Kara 		map->m_pblk = 0;
4154facab4d9SJan Kara 		map->m_len = min_t(unsigned int, map->m_len, hole_len);
4155facab4d9SJan Kara 
4156a86c6181SAlex Tomas 		goto out2;
4157a86c6181SAlex Tomas 	}
41584d33b1efSTheodore Ts'o 
4159a86c6181SAlex Tomas 	/*
4160c2ea3fdeSTheodore Ts'o 	 * Okay, we need to do block allocation.
4161a86c6181SAlex Tomas 	 */
41624d33b1efSTheodore Ts'o 	newex.ee_block = cpu_to_le32(map->m_lblk);
4163d0abafacSEric Whitney 	cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
41644d33b1efSTheodore Ts'o 
41654d33b1efSTheodore Ts'o 	/*
41664d33b1efSTheodore Ts'o 	 * If we are doing bigalloc, check to see if the extent returned
4167ed8a1a76STheodore Ts'o 	 * by ext4_find_extent() implies a cluster we can use.
41684d33b1efSTheodore Ts'o 	 */
41694d33b1efSTheodore Ts'o 	if (cluster_offset && ex &&
4170d8990240SAditya Kali 	    get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {
41714d33b1efSTheodore Ts'o 		ar.len = allocated = map->m_len;
41724d33b1efSTheodore Ts'o 		newblock = map->m_pblk;
41734d33b1efSTheodore Ts'o 		goto got_allocated_blocks;
41744d33b1efSTheodore Ts'o 	}
4175a86c6181SAlex Tomas 
4176c9de560dSAlex Tomas 	/* find neighbour allocated blocks */
4177e35fd660STheodore Ts'o 	ar.lleft = map->m_lblk;
4178c9de560dSAlex Tomas 	err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
4179c9de560dSAlex Tomas 	if (err)
4180c9de560dSAlex Tomas 		goto out2;
4181e35fd660STheodore Ts'o 	ar.lright = map->m_lblk;
41824d33b1efSTheodore Ts'o 	ex2 = NULL;
41834d33b1efSTheodore Ts'o 	err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2);
4184c9de560dSAlex Tomas 	if (err)
4185c9de560dSAlex Tomas 		goto out2;
418625d14f98SAmit Arora 
41874d33b1efSTheodore Ts'o 	/* Check if the extent after searching to the right implies a
41884d33b1efSTheodore Ts'o 	 * cluster we can use. */
41894d33b1efSTheodore Ts'o 	if ((sbi->s_cluster_ratio > 1) && ex2 &&
4190d8990240SAditya Kali 	    get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) {
41914d33b1efSTheodore Ts'o 		ar.len = allocated = map->m_len;
41924d33b1efSTheodore Ts'o 		newblock = map->m_pblk;
41934d33b1efSTheodore Ts'o 		goto got_allocated_blocks;
41944d33b1efSTheodore Ts'o 	}
41954d33b1efSTheodore Ts'o 
4196749269faSAmit Arora 	/*
4197749269faSAmit Arora 	 * See if request is beyond maximum number of blocks we can have in
4198749269faSAmit Arora 	 * a single extent. For an initialized extent this limit is
4199556615dcSLukas Czerner 	 * EXT_INIT_MAX_LEN and for an unwritten extent this limit is
4200556615dcSLukas Czerner 	 * EXT_UNWRITTEN_MAX_LEN.
4201749269faSAmit Arora 	 */
4202e35fd660STheodore Ts'o 	if (map->m_len > EXT_INIT_MAX_LEN &&
4203556615dcSLukas Czerner 	    !(flags & EXT4_GET_BLOCKS_UNWRIT_EXT))
4204e35fd660STheodore Ts'o 		map->m_len = EXT_INIT_MAX_LEN;
4205556615dcSLukas Czerner 	else if (map->m_len > EXT_UNWRITTEN_MAX_LEN &&
4206556615dcSLukas Czerner 		 (flags & EXT4_GET_BLOCKS_UNWRIT_EXT))
4207556615dcSLukas Czerner 		map->m_len = EXT_UNWRITTEN_MAX_LEN;
4208749269faSAmit Arora 
4209e35fd660STheodore Ts'o 	/* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */
4210e35fd660STheodore Ts'o 	newex.ee_len = cpu_to_le16(map->m_len);
42114d33b1efSTheodore Ts'o 	err = ext4_ext_check_overlap(sbi, inode, &newex, path);
421225d14f98SAmit Arora 	if (err)
4213b939e376SAneesh Kumar K.V 		allocated = ext4_ext_get_actual_len(&newex);
421425d14f98SAmit Arora 	else
4215e35fd660STheodore Ts'o 		allocated = map->m_len;
4216c9de560dSAlex Tomas 
4217c9de560dSAlex Tomas 	/* allocate new block */
4218c9de560dSAlex Tomas 	ar.inode = inode;
4219e35fd660STheodore Ts'o 	ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);
4220e35fd660STheodore Ts'o 	ar.logical = map->m_lblk;
42214d33b1efSTheodore Ts'o 	/*
42224d33b1efSTheodore Ts'o 	 * We calculate the offset from the beginning of the cluster
42234d33b1efSTheodore Ts'o 	 * for the logical block number, since when we allocate a
42244d33b1efSTheodore Ts'o 	 * physical cluster, the physical block should start at the
42254d33b1efSTheodore Ts'o 	 * same offset from the beginning of the cluster.  This is
42264d33b1efSTheodore Ts'o 	 * needed so that future calls to get_implied_cluster_alloc()
42274d33b1efSTheodore Ts'o 	 * work correctly.
42284d33b1efSTheodore Ts'o 	 */
4229f5a44db5STheodore Ts'o 	offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
42304d33b1efSTheodore Ts'o 	ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
42314d33b1efSTheodore Ts'o 	ar.goal -= offset;
42324d33b1efSTheodore Ts'o 	ar.logical -= offset;
4233c9de560dSAlex Tomas 	if (S_ISREG(inode->i_mode))
4234c9de560dSAlex Tomas 		ar.flags = EXT4_MB_HINT_DATA;
4235c9de560dSAlex Tomas 	else
4236c9de560dSAlex Tomas 		/* disable in-core preallocation for non-regular files */
4237c9de560dSAlex Tomas 		ar.flags = 0;
4238556b27abSVivek Haldar 	if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE)
4239556b27abSVivek Haldar 		ar.flags |= EXT4_MB_HINT_NOPREALLOC;
4240e3cf5d5dSTheodore Ts'o 	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
4241e3cf5d5dSTheodore Ts'o 		ar.flags |= EXT4_MB_DELALLOC_RESERVED;
4242c5e298aeSTheodore Ts'o 	if (flags & EXT4_GET_BLOCKS_METADATA_NOFAIL)
4243c5e298aeSTheodore Ts'o 		ar.flags |= EXT4_MB_USE_RESERVED;
4244c9de560dSAlex Tomas 	newblock = ext4_mb_new_blocks(handle, &ar, &err);
4245a86c6181SAlex Tomas 	if (!newblock)
4246a86c6181SAlex Tomas 		goto out2;
42477b415bf6SAditya Kali 	allocated_clusters = ar.len;
42484d33b1efSTheodore Ts'o 	ar.len = EXT4_C2B(sbi, ar.len) - offset;
4249ec8c60beSRitesh Harjani 	ext_debug("allocate new block: goal %llu, found %llu/%u, requested %u\n",
4250ec8c60beSRitesh Harjani 		  ar.goal, newblock, ar.len, allocated);
42514d33b1efSTheodore Ts'o 	if (ar.len > allocated)
42524d33b1efSTheodore Ts'o 		ar.len = allocated;
4253a86c6181SAlex Tomas 
42544d33b1efSTheodore Ts'o got_allocated_blocks:
4255a86c6181SAlex Tomas 	/* try to insert new extent into found leaf and return */
42564d33b1efSTheodore Ts'o 	ext4_ext_store_pblock(&newex, newblock + offset);
4257c9de560dSAlex Tomas 	newex.ee_len = cpu_to_le16(ar.len);
4258556615dcSLukas Czerner 	/* Mark unwritten */
4259556615dcSLukas Czerner 	if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT) {
4260556615dcSLukas Czerner 		ext4_ext_mark_unwritten(&newex);
4261a25a4e1aSZheng Liu 		map->m_flags |= EXT4_MAP_UNWRITTEN;
42628d5d02e6SMingming Cao 	}
4263c8d46e41SJiaying Zhang 
42644337ecd1SEric Whitney 	err = ext4_ext_insert_extent(handle, inode, &path, &newex, flags);
426534990461SEric Whitney 	if (err) {
426634990461SEric Whitney 		if (allocated_clusters) {
426734990461SEric Whitney 			int fb_flags = 0;
426882e54229SDmitry Monakhov 
426934990461SEric Whitney 			/*
427034990461SEric Whitney 			 * free data blocks we just allocated.
427134990461SEric Whitney 			 * not a good idea to call discard here directly,
427234990461SEric Whitney 			 * but otherwise we'd need to call it every free().
427334990461SEric Whitney 			 */
4274c2ea3fdeSTheodore Ts'o 			ext4_discard_preallocations(inode);
427534990461SEric Whitney 			if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
427634990461SEric Whitney 				fb_flags = EXT4_FREE_BLOCKS_NO_QUOT_UPDATE;
4277c8e15130STheodore Ts'o 			ext4_free_blocks(handle, inode, NULL, newblock,
427834990461SEric Whitney 					 EXT4_C2B(sbi, allocated_clusters),
427934990461SEric Whitney 					 fb_flags);
428034990461SEric Whitney 		}
4281a86c6181SAlex Tomas 		goto out2;
4282315054f0SAlex Tomas 	}
4283a86c6181SAlex Tomas 
4284a86c6181SAlex Tomas 	/* previous routine could use block we allocated */
4285bf89d16fSTheodore Ts'o 	newblock = ext4_ext_pblock(&newex);
4286b939e376SAneesh Kumar K.V 	allocated = ext4_ext_get_actual_len(&newex);
4287e35fd660STheodore Ts'o 	if (allocated > map->m_len)
4288e35fd660STheodore Ts'o 		allocated = map->m_len;
4289e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_NEW;
4290a86c6181SAlex Tomas 
4291b436b9beSJan Kara 	/*
4292b6bf9171SEric Whitney 	 * Reduce the reserved cluster count to reflect successful deferred
4293b6bf9171SEric Whitney 	 * allocation of delayed allocated clusters or direct allocation of
4294b6bf9171SEric Whitney 	 * clusters discovered to be delayed allocated.  Once allocated, a
4295b6bf9171SEric Whitney 	 * cluster is not included in the reserved count.
42965f634d06SAneesh Kumar K.V 	 */
42972971148dSEric Whitney 	if (test_opt(inode->i_sb, DELALLOC) && allocated_clusters) {
42987b415bf6SAditya Kali 		if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
42997b415bf6SAditya Kali 			/*
4300b6bf9171SEric Whitney 			 * When allocating delayed allocated clusters, simply
4301b6bf9171SEric Whitney 			 * reduce the reserved cluster count and claim quota
4302232ec872SLukas Czerner 			 */
4303232ec872SLukas Czerner 			ext4_da_update_reserve_space(inode, allocated_clusters,
4304232ec872SLukas Czerner 							1);
4305b6bf9171SEric Whitney 		} else {
4306b6bf9171SEric Whitney 			ext4_lblk_t lblk, len;
4307b6bf9171SEric Whitney 			unsigned int n;
4308b6bf9171SEric Whitney 
4309b6bf9171SEric Whitney 			/*
4310b6bf9171SEric Whitney 			 * When allocating non-delayed allocated clusters
4311b6bf9171SEric Whitney 			 * (from fallocate, filemap, DIO, or clusters
4312b6bf9171SEric Whitney 			 * allocated when delalloc has been disabled by
4313b6bf9171SEric Whitney 			 * ext4_nonda_switch), reduce the reserved cluster
4314b6bf9171SEric Whitney 			 * count by the number of allocated clusters that
4315b6bf9171SEric Whitney 			 * have previously been delayed allocated.  Quota
4316b6bf9171SEric Whitney 			 * has been claimed by ext4_mb_new_blocks() above,
4317b6bf9171SEric Whitney 			 * so release the quota reservations made for any
4318b6bf9171SEric Whitney 			 * previously delayed allocated clusters.
4319b6bf9171SEric Whitney 			 */
4320b6bf9171SEric Whitney 			lblk = EXT4_LBLK_CMASK(sbi, map->m_lblk);
4321b6bf9171SEric Whitney 			len = allocated_clusters << sbi->s_cluster_bits;
4322b6bf9171SEric Whitney 			n = ext4_es_delayed_clu(inode, lblk, len);
4323b6bf9171SEric Whitney 			if (n > 0)
4324b6bf9171SEric Whitney 				ext4_da_update_reserve_space(inode, (int) n, 0);
43257b415bf6SAditya Kali 		}
43267b415bf6SAditya Kali 	}
43275f634d06SAneesh Kumar K.V 
43285f634d06SAneesh Kumar K.V 	/*
4329b436b9beSJan Kara 	 * Cache the extent and update transaction to commit on fdatasync only
4330556615dcSLukas Czerner 	 * when it is _not_ an unwritten extent.
4331b436b9beSJan Kara 	 */
4332556615dcSLukas Czerner 	if ((flags & EXT4_GET_BLOCKS_UNWRIT_EXT) == 0)
4333b436b9beSJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 1);
433469eb33dcSZheng Liu 	else
4335b436b9beSJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 0);
4336a86c6181SAlex Tomas out:
4337e35fd660STheodore Ts'o 	if (allocated > map->m_len)
4338e35fd660STheodore Ts'o 		allocated = map->m_len;
4339a86c6181SAlex Tomas 	ext4_ext_show_leaf(inode, path);
4340e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_MAPPED;
4341e35fd660STheodore Ts'o 	map->m_pblk = newblock;
4342e35fd660STheodore Ts'o 	map->m_len = allocated;
4343a86c6181SAlex Tomas out2:
4344a86c6181SAlex Tomas 	ext4_ext_drop_refs(path);
4345a86c6181SAlex Tomas 	kfree(path);
4346e861304bSAllison Henderson 
434763b99968STheodore Ts'o 	trace_ext4_ext_map_blocks_exit(inode, flags, map,
434863b99968STheodore Ts'o 				       err ? err : allocated);
43497877191cSLukas Czerner 	return err ? err : allocated;
4350a86c6181SAlex Tomas }
4351a86c6181SAlex Tomas 
4352d0abb36dSTheodore Ts'o int ext4_ext_truncate(handle_t *handle, struct inode *inode)
4353a86c6181SAlex Tomas {
4354a86c6181SAlex Tomas 	struct super_block *sb = inode->i_sb;
4355725d26d3SAneesh Kumar K.V 	ext4_lblk_t last_block;
4356a86c6181SAlex Tomas 	int err = 0;
4357a86c6181SAlex Tomas 
4358a86c6181SAlex Tomas 	/*
4359d0d856e8SRandy Dunlap 	 * TODO: optimization is possible here.
4360d0d856e8SRandy Dunlap 	 * Probably we need not scan at all,
4361d0d856e8SRandy Dunlap 	 * because page truncation is enough.
4362a86c6181SAlex Tomas 	 */
4363a86c6181SAlex Tomas 
4364a86c6181SAlex Tomas 	/* we have to know where to truncate from in crash case */
4365a86c6181SAlex Tomas 	EXT4_I(inode)->i_disksize = inode->i_size;
4366d0abb36dSTheodore Ts'o 	err = ext4_mark_inode_dirty(handle, inode);
4367d0abb36dSTheodore Ts'o 	if (err)
4368d0abb36dSTheodore Ts'o 		return err;
4369a86c6181SAlex Tomas 
4370a86c6181SAlex Tomas 	last_block = (inode->i_size + sb->s_blocksize - 1)
4371a86c6181SAlex Tomas 			>> EXT4_BLOCK_SIZE_BITS(sb);
43728acd5e9bSTheodore Ts'o retry:
437351865fdaSZheng Liu 	err = ext4_es_remove_extent(inode, last_block,
437451865fdaSZheng Liu 				    EXT_MAX_BLOCKS - last_block);
437594eec0fcSTheodore Ts'o 	if (err == -ENOMEM) {
43768acd5e9bSTheodore Ts'o 		cond_resched();
43778acd5e9bSTheodore Ts'o 		congestion_wait(BLK_RW_ASYNC, HZ/50);
43788acd5e9bSTheodore Ts'o 		goto retry;
43798acd5e9bSTheodore Ts'o 	}
4380d0abb36dSTheodore Ts'o 	if (err)
4381d0abb36dSTheodore Ts'o 		return err;
438273c384c0STheodore Ts'o retry_remove_space:
438373c384c0STheodore Ts'o 	err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1);
438473c384c0STheodore Ts'o 	if (err == -ENOMEM) {
438573c384c0STheodore Ts'o 		cond_resched();
438673c384c0STheodore Ts'o 		congestion_wait(BLK_RW_ASYNC, HZ/50);
438773c384c0STheodore Ts'o 		goto retry_remove_space;
438873c384c0STheodore Ts'o 	}
438973c384c0STheodore Ts'o 	return err;
4390a86c6181SAlex Tomas }
4391a86c6181SAlex Tomas 
43920e8b6879SLukas Czerner static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset,
4393c174e6d6SDmitry Monakhov 				  ext4_lblk_t len, loff_t new_size,
439477a2e84dSTahsin Erdogan 				  int flags)
4395a2df2a63SAmit Arora {
4396496ad9aaSAl Viro 	struct inode *inode = file_inode(file);
4397a2df2a63SAmit Arora 	handle_t *handle;
4398a2df2a63SAmit Arora 	int ret = 0;
43994209ae12SHarshad Shirwadkar 	int ret2 = 0, ret3 = 0;
4400a2df2a63SAmit Arora 	int retries = 0;
44014134f5c8SLukas Czerner 	int depth = 0;
44022ed88685STheodore Ts'o 	struct ext4_map_blocks map;
44030e8b6879SLukas Czerner 	unsigned int credits;
4404c174e6d6SDmitry Monakhov 	loff_t epos;
4405a2df2a63SAmit Arora 
4406c3fe493cSFabian Frederick 	BUG_ON(!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS));
44070e8b6879SLukas Czerner 	map.m_lblk = offset;
4408c174e6d6SDmitry Monakhov 	map.m_len = len;
44093c6fe770SGreg Harm 	/*
44103c6fe770SGreg Harm 	 * Don't normalize the request if it can fit in one extent so
44113c6fe770SGreg Harm 	 * that it doesn't get unnecessarily split into multiple
44123c6fe770SGreg Harm 	 * extents.
44133c6fe770SGreg Harm 	 */
4414556615dcSLukas Czerner 	if (len <= EXT_UNWRITTEN_MAX_LEN)
44153c6fe770SGreg Harm 		flags |= EXT4_GET_BLOCKS_NO_NORMALIZE;
441660d4616fSDmitry Monakhov 
44170e8b6879SLukas Czerner 	/*
44180e8b6879SLukas Czerner 	 * credits to insert 1 extent into extent tree
44190e8b6879SLukas Czerner 	 */
44200e8b6879SLukas Czerner 	credits = ext4_chunk_trans_blocks(inode, len);
44214134f5c8SLukas Czerner 	depth = ext_depth(inode);
44220e8b6879SLukas Czerner 
4423a2df2a63SAmit Arora retry:
4424c174e6d6SDmitry Monakhov 	while (ret >= 0 && len) {
44254134f5c8SLukas Czerner 		/*
44264134f5c8SLukas Czerner 		 * Recalculate credits when extent tree depth changes.
44274134f5c8SLukas Czerner 		 */
4428011c88e3SDan Carpenter 		if (depth != ext_depth(inode)) {
44294134f5c8SLukas Czerner 			credits = ext4_chunk_trans_blocks(inode, len);
44304134f5c8SLukas Czerner 			depth = ext_depth(inode);
44314134f5c8SLukas Czerner 		}
44324134f5c8SLukas Czerner 
44339924a92aSTheodore Ts'o 		handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
44349924a92aSTheodore Ts'o 					    credits);
4435a2df2a63SAmit Arora 		if (IS_ERR(handle)) {
4436a2df2a63SAmit Arora 			ret = PTR_ERR(handle);
4437a2df2a63SAmit Arora 			break;
4438a2df2a63SAmit Arora 		}
4439a4e5d88bSDmitry Monakhov 		ret = ext4_map_blocks(handle, inode, &map, flags);
4440221879c9SAneesh Kumar K.V 		if (ret <= 0) {
4441f282ac19SLukas Czerner 			ext4_debug("inode #%lu: block %u: len %u: "
4442b06acd38SLukas Czerner 				   "ext4_ext_map_blocks returned %d",
4443b06acd38SLukas Czerner 				   inode->i_ino, map.m_lblk,
4444b06acd38SLukas Czerner 				   map.m_len, ret);
4445a2df2a63SAmit Arora 			ext4_mark_inode_dirty(handle, inode);
4446a2df2a63SAmit Arora 			ret2 = ext4_journal_stop(handle);
4447a2df2a63SAmit Arora 			break;
4448a2df2a63SAmit Arora 		}
4449c174e6d6SDmitry Monakhov 		map.m_lblk += ret;
4450c174e6d6SDmitry Monakhov 		map.m_len = len = len - ret;
4451c174e6d6SDmitry Monakhov 		epos = (loff_t)map.m_lblk << inode->i_blkbits;
4452eeca7ea1SDeepa Dinamani 		inode->i_ctime = current_time(inode);
4453c174e6d6SDmitry Monakhov 		if (new_size) {
4454c174e6d6SDmitry Monakhov 			if (epos > new_size)
4455c174e6d6SDmitry Monakhov 				epos = new_size;
4456c174e6d6SDmitry Monakhov 			if (ext4_update_inode_size(inode, epos) & 0x1)
4457c174e6d6SDmitry Monakhov 				inode->i_mtime = inode->i_ctime;
4458c174e6d6SDmitry Monakhov 		}
44594209ae12SHarshad Shirwadkar 		ret2 = ext4_mark_inode_dirty(handle, inode);
4460c894aa97SEryu Guan 		ext4_update_inode_fsync_trans(handle, inode, 1);
44614209ae12SHarshad Shirwadkar 		ret3 = ext4_journal_stop(handle);
44624209ae12SHarshad Shirwadkar 		ret2 = ret3 ? ret3 : ret2;
44634209ae12SHarshad Shirwadkar 		if (unlikely(ret2))
4464a2df2a63SAmit Arora 			break;
4465a2df2a63SAmit Arora 	}
4466fd28784aSAneesh Kumar K.V 	if (ret == -ENOSPC &&
4467fd28784aSAneesh Kumar K.V 			ext4_should_retry_alloc(inode->i_sb, &retries)) {
4468fd28784aSAneesh Kumar K.V 		ret = 0;
4469a2df2a63SAmit Arora 		goto retry;
4470a2df2a63SAmit Arora 	}
4471f282ac19SLukas Czerner 
44720e8b6879SLukas Czerner 	return ret > 0 ? ret2 : ret;
44730e8b6879SLukas Czerner }
44740e8b6879SLukas Czerner 
447543f81677SEric Biggers static int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len);
447643f81677SEric Biggers 
447743f81677SEric Biggers static int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len);
447843f81677SEric Biggers 
4479b8a86845SLukas Czerner static long ext4_zero_range(struct file *file, loff_t offset,
4480b8a86845SLukas Czerner 			    loff_t len, int mode)
4481b8a86845SLukas Czerner {
4482b8a86845SLukas Czerner 	struct inode *inode = file_inode(file);
4483b8a86845SLukas Czerner 	handle_t *handle = NULL;
4484b8a86845SLukas Czerner 	unsigned int max_blocks;
4485b8a86845SLukas Czerner 	loff_t new_size = 0;
4486b8a86845SLukas Czerner 	int ret = 0;
4487b8a86845SLukas Czerner 	int flags;
448869dc9536SDmitry Monakhov 	int credits;
4489c174e6d6SDmitry Monakhov 	int partial_begin, partial_end;
4490b8a86845SLukas Czerner 	loff_t start, end;
4491b8a86845SLukas Czerner 	ext4_lblk_t lblk;
4492b8a86845SLukas Czerner 	unsigned int blkbits = inode->i_blkbits;
4493b8a86845SLukas Czerner 
4494b8a86845SLukas Czerner 	trace_ext4_zero_range(inode, offset, len, mode);
4495b8a86845SLukas Czerner 
4496e1ee60fdSNamjae Jeon 	/* Call ext4_force_commit to flush all data in case of data=journal. */
4497e1ee60fdSNamjae Jeon 	if (ext4_should_journal_data(inode)) {
4498e1ee60fdSNamjae Jeon 		ret = ext4_force_commit(inode->i_sb);
4499e1ee60fdSNamjae Jeon 		if (ret)
4500e1ee60fdSNamjae Jeon 			return ret;
4501e1ee60fdSNamjae Jeon 	}
4502e1ee60fdSNamjae Jeon 
4503b8a86845SLukas Czerner 	/*
4504b8a86845SLukas Czerner 	 * Round up offset. This is not fallocate, we neet to zero out
4505b8a86845SLukas Czerner 	 * blocks, so convert interior block aligned part of the range to
4506b8a86845SLukas Czerner 	 * unwritten and possibly manually zero out unaligned parts of the
4507b8a86845SLukas Czerner 	 * range.
4508b8a86845SLukas Czerner 	 */
4509b8a86845SLukas Czerner 	start = round_up(offset, 1 << blkbits);
4510b8a86845SLukas Czerner 	end = round_down((offset + len), 1 << blkbits);
4511b8a86845SLukas Czerner 
4512b8a86845SLukas Czerner 	if (start < offset || end > offset + len)
4513b8a86845SLukas Czerner 		return -EINVAL;
4514c174e6d6SDmitry Monakhov 	partial_begin = offset & ((1 << blkbits) - 1);
4515c174e6d6SDmitry Monakhov 	partial_end = (offset + len) & ((1 << blkbits) - 1);
4516b8a86845SLukas Czerner 
4517b8a86845SLukas Czerner 	lblk = start >> blkbits;
4518b8a86845SLukas Czerner 	max_blocks = (end >> blkbits);
4519b8a86845SLukas Czerner 	if (max_blocks < lblk)
4520b8a86845SLukas Czerner 		max_blocks = 0;
4521b8a86845SLukas Czerner 	else
4522b8a86845SLukas Czerner 		max_blocks -= lblk;
4523b8a86845SLukas Czerner 
45245955102cSAl Viro 	inode_lock(inode);
4525b8a86845SLukas Czerner 
4526b8a86845SLukas Czerner 	/*
452780dd4978SChristophe JAILLET 	 * Indirect files do not support unwritten extents
4528b8a86845SLukas Czerner 	 */
4529b8a86845SLukas Czerner 	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4530b8a86845SLukas Czerner 		ret = -EOPNOTSUPP;
4531b8a86845SLukas Czerner 		goto out_mutex;
4532b8a86845SLukas Czerner 	}
4533b8a86845SLukas Czerner 
4534b8a86845SLukas Czerner 	if (!(mode & FALLOC_FL_KEEP_SIZE) &&
45359b02e498SEric Biggers 	    (offset + len > inode->i_size ||
453651e3ae81STheodore Ts'o 	     offset + len > EXT4_I(inode)->i_disksize)) {
4537b8a86845SLukas Czerner 		new_size = offset + len;
4538b8a86845SLukas Czerner 		ret = inode_newsize_ok(inode, new_size);
4539b8a86845SLukas Czerner 		if (ret)
4540b8a86845SLukas Czerner 			goto out_mutex;
4541b8a86845SLukas Czerner 	}
4542b8a86845SLukas Czerner 
45430f2af21aSLukas Czerner 	flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
45440f2af21aSLukas Czerner 
454517048e8aSJan Kara 	/* Wait all existing dio workers, newcomers will block on i_mutex */
454617048e8aSJan Kara 	inode_dio_wait(inode);
454717048e8aSJan Kara 
45480f2af21aSLukas Czerner 	/* Preallocate the range including the unaligned edges */
45490f2af21aSLukas Czerner 	if (partial_begin || partial_end) {
45500f2af21aSLukas Czerner 		ret = ext4_alloc_file_blocks(file,
45510f2af21aSLukas Czerner 				round_down(offset, 1 << blkbits) >> blkbits,
45520f2af21aSLukas Czerner 				(round_up((offset + len), 1 << blkbits) -
45530f2af21aSLukas Czerner 				 round_down(offset, 1 << blkbits)) >> blkbits,
455477a2e84dSTahsin Erdogan 				new_size, flags);
45550f2af21aSLukas Czerner 		if (ret)
45561d39834fSNikolay Borisov 			goto out_mutex;
45570f2af21aSLukas Czerner 
45580f2af21aSLukas Czerner 	}
45590f2af21aSLukas Czerner 
45600f2af21aSLukas Czerner 	/* Zero range excluding the unaligned edges */
4561b8a86845SLukas Czerner 	if (max_blocks > 0) {
45620f2af21aSLukas Czerner 		flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
45630f2af21aSLukas Czerner 			  EXT4_EX_NOCACHE);
4564b8a86845SLukas Czerner 
4565ea3d7209SJan Kara 		/*
4566ea3d7209SJan Kara 		 * Prevent page faults from reinstantiating pages we have
4567ea3d7209SJan Kara 		 * released from page cache.
4568ea3d7209SJan Kara 		 */
4569ea3d7209SJan Kara 		down_write(&EXT4_I(inode)->i_mmap_sem);
4570430657b6SRoss Zwisler 
4571430657b6SRoss Zwisler 		ret = ext4_break_layouts(inode);
4572430657b6SRoss Zwisler 		if (ret) {
4573430657b6SRoss Zwisler 			up_write(&EXT4_I(inode)->i_mmap_sem);
4574430657b6SRoss Zwisler 			goto out_mutex;
4575430657b6SRoss Zwisler 		}
4576430657b6SRoss Zwisler 
457701127848SJan Kara 		ret = ext4_update_disksize_before_punch(inode, offset, len);
457801127848SJan Kara 		if (ret) {
457901127848SJan Kara 			up_write(&EXT4_I(inode)->i_mmap_sem);
45801d39834fSNikolay Borisov 			goto out_mutex;
458101127848SJan Kara 		}
4582ea3d7209SJan Kara 		/* Now release the pages and zero block aligned part of pages */
4583ea3d7209SJan Kara 		truncate_pagecache_range(inode, start, end - 1);
4584eeca7ea1SDeepa Dinamani 		inode->i_mtime = inode->i_ctime = current_time(inode);
4585ea3d7209SJan Kara 
4586c174e6d6SDmitry Monakhov 		ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
458777a2e84dSTahsin Erdogan 					     flags);
4588ea3d7209SJan Kara 		up_write(&EXT4_I(inode)->i_mmap_sem);
4589b8a86845SLukas Czerner 		if (ret)
45901d39834fSNikolay Borisov 			goto out_mutex;
4591b8a86845SLukas Czerner 	}
4592c174e6d6SDmitry Monakhov 	if (!partial_begin && !partial_end)
45931d39834fSNikolay Borisov 		goto out_mutex;
4594c174e6d6SDmitry Monakhov 
459569dc9536SDmitry Monakhov 	/*
459669dc9536SDmitry Monakhov 	 * In worst case we have to writeout two nonadjacent unwritten
459769dc9536SDmitry Monakhov 	 * blocks and update the inode
459869dc9536SDmitry Monakhov 	 */
459969dc9536SDmitry Monakhov 	credits = (2 * ext4_ext_index_trans_blocks(inode, 2)) + 1;
460069dc9536SDmitry Monakhov 	if (ext4_should_journal_data(inode))
460169dc9536SDmitry Monakhov 		credits += 2;
460269dc9536SDmitry Monakhov 	handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
4603b8a86845SLukas Czerner 	if (IS_ERR(handle)) {
4604b8a86845SLukas Czerner 		ret = PTR_ERR(handle);
4605b8a86845SLukas Czerner 		ext4_std_error(inode->i_sb, ret);
46061d39834fSNikolay Borisov 		goto out_mutex;
4607b8a86845SLukas Czerner 	}
4608b8a86845SLukas Czerner 
4609eeca7ea1SDeepa Dinamani 	inode->i_mtime = inode->i_ctime = current_time(inode);
46104337ecd1SEric Whitney 	if (new_size)
46114631dbf6SDmitry Monakhov 		ext4_update_inode_size(inode, new_size);
46124209ae12SHarshad Shirwadkar 	ret = ext4_mark_inode_dirty(handle, inode);
46134209ae12SHarshad Shirwadkar 	if (unlikely(ret))
46144209ae12SHarshad Shirwadkar 		goto out_handle;
4615b8a86845SLukas Czerner 
4616b8a86845SLukas Czerner 	/* Zero out partial block at the edges of the range */
4617b8a86845SLukas Czerner 	ret = ext4_zero_partial_blocks(handle, inode, offset, len);
461867a7d5f5SJan Kara 	if (ret >= 0)
461967a7d5f5SJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 1);
4620b8a86845SLukas Czerner 
4621b8a86845SLukas Czerner 	if (file->f_flags & O_SYNC)
4622b8a86845SLukas Czerner 		ext4_handle_sync(handle);
4623b8a86845SLukas Czerner 
46244209ae12SHarshad Shirwadkar out_handle:
4625b8a86845SLukas Czerner 	ext4_journal_stop(handle);
4626b8a86845SLukas Czerner out_mutex:
46275955102cSAl Viro 	inode_unlock(inode);
4628b8a86845SLukas Czerner 	return ret;
4629b8a86845SLukas Czerner }
4630b8a86845SLukas Czerner 
46310e8b6879SLukas Czerner /*
46320e8b6879SLukas Czerner  * preallocate space for a file. This implements ext4's fallocate file
46330e8b6879SLukas Czerner  * operation, which gets called from sys_fallocate system call.
46340e8b6879SLukas Czerner  * For block-mapped files, posix_fallocate should fall back to the method
46350e8b6879SLukas Czerner  * of writing zeroes to the required new blocks (the same behavior which is
46360e8b6879SLukas Czerner  * expected for file systems which do not support fallocate() system call).
46370e8b6879SLukas Czerner  */
46380e8b6879SLukas Czerner long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
46390e8b6879SLukas Czerner {
46400e8b6879SLukas Czerner 	struct inode *inode = file_inode(file);
46410e8b6879SLukas Czerner 	loff_t new_size = 0;
46420e8b6879SLukas Czerner 	unsigned int max_blocks;
46430e8b6879SLukas Czerner 	int ret = 0;
46440e8b6879SLukas Czerner 	int flags;
46450e8b6879SLukas Czerner 	ext4_lblk_t lblk;
46460e8b6879SLukas Czerner 	unsigned int blkbits = inode->i_blkbits;
46470e8b6879SLukas Czerner 
46482058f83aSMichael Halcrow 	/*
46492058f83aSMichael Halcrow 	 * Encrypted inodes can't handle collapse range or insert
46502058f83aSMichael Halcrow 	 * range since we would need to re-encrypt blocks with a
46512058f83aSMichael Halcrow 	 * different IV or XTS tweak (which are based on the logical
46522058f83aSMichael Halcrow 	 * block number).
46532058f83aSMichael Halcrow 	 */
4654592ddec7SChandan Rajendra 	if (IS_ENCRYPTED(inode) &&
4655457b1e35SEric Biggers 	    (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
46562058f83aSMichael Halcrow 		return -EOPNOTSUPP;
46572058f83aSMichael Halcrow 
46580e8b6879SLukas Czerner 	/* Return error if mode is not supported */
46590e8b6879SLukas Czerner 	if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
4660331573feSNamjae Jeon 		     FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
4661331573feSNamjae Jeon 		     FALLOC_FL_INSERT_RANGE))
46620e8b6879SLukas Czerner 		return -EOPNOTSUPP;
46630e8b6879SLukas Czerner 
46640e8b6879SLukas Czerner 	if (mode & FALLOC_FL_PUNCH_HOLE)
46650e8b6879SLukas Czerner 		return ext4_punch_hole(inode, offset, len);
46660e8b6879SLukas Czerner 
46670e8b6879SLukas Czerner 	ret = ext4_convert_inline_data(inode);
46680e8b6879SLukas Czerner 	if (ret)
46690e8b6879SLukas Czerner 		return ret;
46700e8b6879SLukas Czerner 
467140c406c7STheodore Ts'o 	if (mode & FALLOC_FL_COLLAPSE_RANGE)
467240c406c7STheodore Ts'o 		return ext4_collapse_range(inode, offset, len);
467340c406c7STheodore Ts'o 
4674331573feSNamjae Jeon 	if (mode & FALLOC_FL_INSERT_RANGE)
4675331573feSNamjae Jeon 		return ext4_insert_range(inode, offset, len);
4676331573feSNamjae Jeon 
4677b8a86845SLukas Czerner 	if (mode & FALLOC_FL_ZERO_RANGE)
4678b8a86845SLukas Czerner 		return ext4_zero_range(file, offset, len, mode);
4679b8a86845SLukas Czerner 
46800e8b6879SLukas Czerner 	trace_ext4_fallocate_enter(inode, offset, len, mode);
46810e8b6879SLukas Czerner 	lblk = offset >> blkbits;
46820e8b6879SLukas Czerner 
4683518eaa63SFabian Frederick 	max_blocks = EXT4_MAX_BLOCKS(len, offset, blkbits);
4684556615dcSLukas Czerner 	flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
46850e8b6879SLukas Czerner 
46865955102cSAl Viro 	inode_lock(inode);
46870e8b6879SLukas Czerner 
4688280227a7SDavide Italiano 	/*
4689280227a7SDavide Italiano 	 * We only support preallocation for extent-based files only
4690280227a7SDavide Italiano 	 */
4691280227a7SDavide Italiano 	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4692280227a7SDavide Italiano 		ret = -EOPNOTSUPP;
4693280227a7SDavide Italiano 		goto out;
4694280227a7SDavide Italiano 	}
4695280227a7SDavide Italiano 
46960e8b6879SLukas Czerner 	if (!(mode & FALLOC_FL_KEEP_SIZE) &&
46979b02e498SEric Biggers 	    (offset + len > inode->i_size ||
469851e3ae81STheodore Ts'o 	     offset + len > EXT4_I(inode)->i_disksize)) {
46990e8b6879SLukas Czerner 		new_size = offset + len;
47000e8b6879SLukas Czerner 		ret = inode_newsize_ok(inode, new_size);
47010e8b6879SLukas Czerner 		if (ret)
47020e8b6879SLukas Czerner 			goto out;
47030e8b6879SLukas Czerner 	}
47040e8b6879SLukas Czerner 
470517048e8aSJan Kara 	/* Wait all existing dio workers, newcomers will block on i_mutex */
470617048e8aSJan Kara 	inode_dio_wait(inode);
470717048e8aSJan Kara 
470877a2e84dSTahsin Erdogan 	ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, flags);
47090e8b6879SLukas Czerner 	if (ret)
47100e8b6879SLukas Czerner 		goto out;
47110e8b6879SLukas Czerner 
4712c174e6d6SDmitry Monakhov 	if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) {
4713c174e6d6SDmitry Monakhov 		ret = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal,
4714c174e6d6SDmitry Monakhov 						EXT4_I(inode)->i_sync_tid);
4715f282ac19SLukas Czerner 	}
4716f282ac19SLukas Czerner out:
47175955102cSAl Viro 	inode_unlock(inode);
47180e8b6879SLukas Czerner 	trace_ext4_fallocate_exit(inode, offset, max_blocks, ret);
47190e8b6879SLukas Czerner 	return ret;
4720a2df2a63SAmit Arora }
47216873fa0dSEric Sandeen 
47226873fa0dSEric Sandeen /*
47230031462bSMingming Cao  * This function convert a range of blocks to written extents
47240031462bSMingming Cao  * The caller of this function will pass the start offset and the size.
47250031462bSMingming Cao  * all unwritten extents within this range will be converted to
47260031462bSMingming Cao  * written extents.
47270031462bSMingming Cao  *
47280031462bSMingming Cao  * This function is called from the direct IO end io call back
47290031462bSMingming Cao  * function, to convert the fallocated extents after IO is completed.
4730109f5565SMingming  * Returns 0 on success.
47310031462bSMingming Cao  */
47326b523df4SJan Kara int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
47336b523df4SJan Kara 				   loff_t offset, ssize_t len)
47340031462bSMingming Cao {
47350031462bSMingming Cao 	unsigned int max_blocks;
47364209ae12SHarshad Shirwadkar 	int ret = 0, ret2 = 0, ret3 = 0;
47372ed88685STheodore Ts'o 	struct ext4_map_blocks map;
4738a00713eaSRitesh Harjani 	unsigned int blkbits = inode->i_blkbits;
4739a00713eaSRitesh Harjani 	unsigned int credits = 0;
47400031462bSMingming Cao 
47412ed88685STheodore Ts'o 	map.m_lblk = offset >> blkbits;
4742518eaa63SFabian Frederick 	max_blocks = EXT4_MAX_BLOCKS(len, offset, blkbits);
4743518eaa63SFabian Frederick 
4744a00713eaSRitesh Harjani 	if (!handle) {
47456b523df4SJan Kara 		/*
47460031462bSMingming Cao 		 * credits to insert 1 extent into extent tree
47470031462bSMingming Cao 		 */
47480031462bSMingming Cao 		credits = ext4_chunk_trans_blocks(inode, max_blocks);
47496b523df4SJan Kara 	}
47500031462bSMingming Cao 	while (ret >= 0 && ret < max_blocks) {
47512ed88685STheodore Ts'o 		map.m_lblk += ret;
47522ed88685STheodore Ts'o 		map.m_len = (max_blocks -= ret);
47536b523df4SJan Kara 		if (credits) {
47546b523df4SJan Kara 			handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
47556b523df4SJan Kara 						    credits);
47560031462bSMingming Cao 			if (IS_ERR(handle)) {
47570031462bSMingming Cao 				ret = PTR_ERR(handle);
47580031462bSMingming Cao 				break;
47590031462bSMingming Cao 			}
47606b523df4SJan Kara 		}
47612ed88685STheodore Ts'o 		ret = ext4_map_blocks(handle, inode, &map,
4762c7064ef1SJiaying Zhang 				      EXT4_GET_BLOCKS_IO_CONVERT_EXT);
4763b06acd38SLukas Czerner 		if (ret <= 0)
4764b06acd38SLukas Czerner 			ext4_warning(inode->i_sb,
4765b06acd38SLukas Czerner 				     "inode #%lu: block %u: len %u: "
476692b97816STheodore Ts'o 				     "ext4_ext_map_blocks returned %d",
4767b06acd38SLukas Czerner 				     inode->i_ino, map.m_lblk,
476892b97816STheodore Ts'o 				     map.m_len, ret);
47694209ae12SHarshad Shirwadkar 		ret2 = ext4_mark_inode_dirty(handle, inode);
47704209ae12SHarshad Shirwadkar 		if (credits) {
47714209ae12SHarshad Shirwadkar 			ret3 = ext4_journal_stop(handle);
47724209ae12SHarshad Shirwadkar 			if (unlikely(ret3))
47734209ae12SHarshad Shirwadkar 				ret2 = ret3;
47744209ae12SHarshad Shirwadkar 		}
47754209ae12SHarshad Shirwadkar 
47760031462bSMingming Cao 		if (ret <= 0 || ret2)
47770031462bSMingming Cao 			break;
47780031462bSMingming Cao 	}
47790031462bSMingming Cao 	return ret > 0 ? ret2 : ret;
47800031462bSMingming Cao }
47816d9c85ebSYongqiang Yang 
4782a00713eaSRitesh Harjani int ext4_convert_unwritten_io_end_vec(handle_t *handle, ext4_io_end_t *io_end)
4783a00713eaSRitesh Harjani {
4784a00713eaSRitesh Harjani 	int ret, err = 0;
4785c8cc8816SRitesh Harjani 	struct ext4_io_end_vec *io_end_vec;
4786a00713eaSRitesh Harjani 
4787a00713eaSRitesh Harjani 	/*
4788a00713eaSRitesh Harjani 	 * This is somewhat ugly but the idea is clear: When transaction is
4789a00713eaSRitesh Harjani 	 * reserved, everything goes into it. Otherwise we rather start several
4790a00713eaSRitesh Harjani 	 * smaller transactions for conversion of each extent separately.
4791a00713eaSRitesh Harjani 	 */
4792a00713eaSRitesh Harjani 	if (handle) {
4793a00713eaSRitesh Harjani 		handle = ext4_journal_start_reserved(handle,
4794a00713eaSRitesh Harjani 						     EXT4_HT_EXT_CONVERT);
4795a00713eaSRitesh Harjani 		if (IS_ERR(handle))
4796a00713eaSRitesh Harjani 			return PTR_ERR(handle);
4797a00713eaSRitesh Harjani 	}
4798a00713eaSRitesh Harjani 
4799c8cc8816SRitesh Harjani 	list_for_each_entry(io_end_vec, &io_end->list_vec, list) {
4800a00713eaSRitesh Harjani 		ret = ext4_convert_unwritten_extents(handle, io_end->inode,
4801c8cc8816SRitesh Harjani 						     io_end_vec->offset,
4802c8cc8816SRitesh Harjani 						     io_end_vec->size);
4803c8cc8816SRitesh Harjani 		if (ret)
4804c8cc8816SRitesh Harjani 			break;
4805c8cc8816SRitesh Harjani 	}
4806c8cc8816SRitesh Harjani 
4807a00713eaSRitesh Harjani 	if (handle)
4808a00713eaSRitesh Harjani 		err = ext4_journal_stop(handle);
4809a00713eaSRitesh Harjani 
4810a00713eaSRitesh Harjani 	return ret < 0 ? ret : err;
4811a00713eaSRitesh Harjani }
4812a00713eaSRitesh Harjani 
4813d3b6f23fSRitesh Harjani static int ext4_iomap_xattr_fiemap(struct inode *inode, struct iomap *iomap)
48146873fa0dSEric Sandeen {
48156873fa0dSEric Sandeen 	__u64 physical = 0;
4816d3b6f23fSRitesh Harjani 	__u64 length = 0;
48176873fa0dSEric Sandeen 	int blockbits = inode->i_sb->s_blocksize_bits;
48186873fa0dSEric Sandeen 	int error = 0;
4819d3b6f23fSRitesh Harjani 	u16 iomap_type;
48206873fa0dSEric Sandeen 
48216873fa0dSEric Sandeen 	/* in-inode? */
482219f5fb7aSTheodore Ts'o 	if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
48236873fa0dSEric Sandeen 		struct ext4_iloc iloc;
48246873fa0dSEric Sandeen 		int offset;	/* offset of xattr in inode */
48256873fa0dSEric Sandeen 
48266873fa0dSEric Sandeen 		error = ext4_get_inode_loc(inode, &iloc);
48276873fa0dSEric Sandeen 		if (error)
48286873fa0dSEric Sandeen 			return error;
4829a60697f4SJan Kara 		physical = (__u64)iloc.bh->b_blocknr << blockbits;
48306873fa0dSEric Sandeen 		offset = EXT4_GOOD_OLD_INODE_SIZE +
48316873fa0dSEric Sandeen 				EXT4_I(inode)->i_extra_isize;
48326873fa0dSEric Sandeen 		physical += offset;
48336873fa0dSEric Sandeen 		length = EXT4_SB(inode->i_sb)->s_inode_size - offset;
4834fd2dd9fbSCurt Wohlgemuth 		brelse(iloc.bh);
4835d3b6f23fSRitesh Harjani 		iomap_type = IOMAP_INLINE;
4836d3b6f23fSRitesh Harjani 	} else if (EXT4_I(inode)->i_file_acl) { /* external block */
4837a60697f4SJan Kara 		physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits;
48386873fa0dSEric Sandeen 		length = inode->i_sb->s_blocksize;
4839d3b6f23fSRitesh Harjani 		iomap_type = IOMAP_MAPPED;
4840d3b6f23fSRitesh Harjani 	} else {
4841d3b6f23fSRitesh Harjani 		/* no in-inode or external block for xattr, so return -ENOENT */
4842d3b6f23fSRitesh Harjani 		error = -ENOENT;
4843d3b6f23fSRitesh Harjani 		goto out;
48446873fa0dSEric Sandeen 	}
48456873fa0dSEric Sandeen 
4846d3b6f23fSRitesh Harjani 	iomap->addr = physical;
4847d3b6f23fSRitesh Harjani 	iomap->offset = 0;
4848d3b6f23fSRitesh Harjani 	iomap->length = length;
4849d3b6f23fSRitesh Harjani 	iomap->type = iomap_type;
4850d3b6f23fSRitesh Harjani 	iomap->flags = 0;
4851d3b6f23fSRitesh Harjani out:
4852d3b6f23fSRitesh Harjani 	return error;
48536873fa0dSEric Sandeen }
48546873fa0dSEric Sandeen 
4855d3b6f23fSRitesh Harjani static int ext4_iomap_xattr_begin(struct inode *inode, loff_t offset,
4856d3b6f23fSRitesh Harjani 				  loff_t length, unsigned flags,
4857d3b6f23fSRitesh Harjani 				  struct iomap *iomap, struct iomap *srcmap)
4858d3b6f23fSRitesh Harjani {
4859d3b6f23fSRitesh Harjani 	int error;
4860d3b6f23fSRitesh Harjani 
4861d3b6f23fSRitesh Harjani 	error = ext4_iomap_xattr_fiemap(inode, iomap);
4862d3b6f23fSRitesh Harjani 	if (error == 0 && (offset >= iomap->length))
4863d3b6f23fSRitesh Harjani 		error = -ENOENT;
4864d3b6f23fSRitesh Harjani 	return error;
4865d3b6f23fSRitesh Harjani }
4866d3b6f23fSRitesh Harjani 
4867d3b6f23fSRitesh Harjani static const struct iomap_ops ext4_iomap_xattr_ops = {
4868d3b6f23fSRitesh Harjani 	.iomap_begin		= ext4_iomap_xattr_begin,
4869d3b6f23fSRitesh Harjani };
4870d3b6f23fSRitesh Harjani 
4871d3b6f23fSRitesh Harjani static int _ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
4872d3b6f23fSRitesh Harjani 			__u64 start, __u64 len, bool from_es_cache)
48736873fa0dSEric Sandeen {
48746873fa0dSEric Sandeen 	ext4_lblk_t start_blk;
4875bb5835edSTheodore Ts'o 	u32 ext4_fiemap_flags = FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR;
48766873fa0dSEric Sandeen 	int error = 0;
48776873fa0dSEric Sandeen 
48787869a4a6STheodore Ts'o 	if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {
48797869a4a6STheodore Ts'o 		error = ext4_ext_precache(inode);
48807869a4a6STheodore Ts'o 		if (error)
48817869a4a6STheodore Ts'o 			return error;
4882bb5835edSTheodore Ts'o 		fieinfo->fi_flags &= ~FIEMAP_FLAG_CACHE;
48837869a4a6STheodore Ts'o 	}
48847869a4a6STheodore Ts'o 
4885d3b6f23fSRitesh Harjani 	if (from_es_cache)
4886bb5835edSTheodore Ts'o 		ext4_fiemap_flags &= FIEMAP_FLAG_XATTR;
4887d3b6f23fSRitesh Harjani 
4888bb5835edSTheodore Ts'o 	if (fiemap_check_flags(fieinfo, ext4_fiemap_flags))
48896873fa0dSEric Sandeen 		return -EBADR;
48906873fa0dSEric Sandeen 
48916873fa0dSEric Sandeen 	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
4892d3b6f23fSRitesh Harjani 		fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR;
4893d3b6f23fSRitesh Harjani 		error = iomap_fiemap(inode, fieinfo, start, len,
4894d3b6f23fSRitesh Harjani 				     &ext4_iomap_xattr_ops);
4895d3b6f23fSRitesh Harjani 	} else if (!from_es_cache) {
4896d3b6f23fSRitesh Harjani 		error = iomap_fiemap(inode, fieinfo, start, len,
4897d3b6f23fSRitesh Harjani 				     &ext4_iomap_report_ops);
48986873fa0dSEric Sandeen 	} else {
4899aca92ff6SLeonard Michlmayr 		ext4_lblk_t len_blks;
4900aca92ff6SLeonard Michlmayr 		__u64 last_blk;
4901aca92ff6SLeonard Michlmayr 
49026873fa0dSEric Sandeen 		start_blk = start >> inode->i_sb->s_blocksize_bits;
4903aca92ff6SLeonard Michlmayr 		last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
4904f17722f9SLukas Czerner 		if (last_blk >= EXT_MAX_BLOCKS)
4905f17722f9SLukas Czerner 			last_blk = EXT_MAX_BLOCKS-1;
4906aca92ff6SLeonard Michlmayr 		len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;
49076873fa0dSEric Sandeen 
49086873fa0dSEric Sandeen 		/*
490991dd8c11SLukas Czerner 		 * Walk the extent tree gathering extent information
491091dd8c11SLukas Czerner 		 * and pushing extents back to the user.
49116873fa0dSEric Sandeen 		 */
4912d3b6f23fSRitesh Harjani 		error = ext4_fill_es_cache_info(inode, start_blk, len_blks,
4913d3b6f23fSRitesh Harjani 						fieinfo);
49146873fa0dSEric Sandeen 	}
49156873fa0dSEric Sandeen 	return error;
49166873fa0dSEric Sandeen }
49179eb79482SNamjae Jeon 
4918bb5835edSTheodore Ts'o int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
4919bb5835edSTheodore Ts'o 		__u64 start, __u64 len)
4920bb5835edSTheodore Ts'o {
4921d3b6f23fSRitesh Harjani 	return _ext4_fiemap(inode, fieinfo, start, len, false);
4922bb5835edSTheodore Ts'o }
4923bb5835edSTheodore Ts'o 
4924bb5835edSTheodore Ts'o int ext4_get_es_cache(struct inode *inode, struct fiemap_extent_info *fieinfo,
4925bb5835edSTheodore Ts'o 		      __u64 start, __u64 len)
4926bb5835edSTheodore Ts'o {
4927bb5835edSTheodore Ts'o 	if (ext4_has_inline_data(inode)) {
4928bb5835edSTheodore Ts'o 		int has_inline;
4929bb5835edSTheodore Ts'o 
4930bb5835edSTheodore Ts'o 		down_read(&EXT4_I(inode)->xattr_sem);
4931bb5835edSTheodore Ts'o 		has_inline = ext4_has_inline_data(inode);
4932bb5835edSTheodore Ts'o 		up_read(&EXT4_I(inode)->xattr_sem);
4933bb5835edSTheodore Ts'o 		if (has_inline)
4934bb5835edSTheodore Ts'o 			return 0;
4935bb5835edSTheodore Ts'o 	}
4936bb5835edSTheodore Ts'o 
4937d3b6f23fSRitesh Harjani 	return _ext4_fiemap(inode, fieinfo, start, len, true);
4938bb5835edSTheodore Ts'o }
4939bb5835edSTheodore Ts'o 
4940bb5835edSTheodore Ts'o 
49419eb79482SNamjae Jeon /*
49429eb79482SNamjae Jeon  * ext4_access_path:
49439eb79482SNamjae Jeon  * Function to access the path buffer for marking it dirty.
49449eb79482SNamjae Jeon  * It also checks if there are sufficient credits left in the journal handle
49459eb79482SNamjae Jeon  * to update path.
49469eb79482SNamjae Jeon  */
49479eb79482SNamjae Jeon static int
49489eb79482SNamjae Jeon ext4_access_path(handle_t *handle, struct inode *inode,
49499eb79482SNamjae Jeon 		struct ext4_ext_path *path)
49509eb79482SNamjae Jeon {
49519eb79482SNamjae Jeon 	int credits, err;
49529eb79482SNamjae Jeon 
49539eb79482SNamjae Jeon 	if (!ext4_handle_valid(handle))
49549eb79482SNamjae Jeon 		return 0;
49559eb79482SNamjae Jeon 
49569eb79482SNamjae Jeon 	/*
49579eb79482SNamjae Jeon 	 * Check if need to extend journal credits
49589eb79482SNamjae Jeon 	 * 3 for leaf, sb, and inode plus 2 (bmap and group
49599eb79482SNamjae Jeon 	 * descriptor) for each block group; assume two block
49609eb79482SNamjae Jeon 	 * groups
49619eb79482SNamjae Jeon 	 */
49629eb79482SNamjae Jeon 	credits = ext4_writepage_trans_blocks(inode);
496383448bdfSJan Kara 	err = ext4_datasem_ensure_credits(handle, inode, 7, credits, 0);
4964a4130367SJan Kara 	if (err < 0)
49659eb79482SNamjae Jeon 		return err;
49669eb79482SNamjae Jeon 
49679eb79482SNamjae Jeon 	err = ext4_ext_get_access(handle, inode, path);
49689eb79482SNamjae Jeon 	return err;
49699eb79482SNamjae Jeon }
49709eb79482SNamjae Jeon 
49719eb79482SNamjae Jeon /*
49729eb79482SNamjae Jeon  * ext4_ext_shift_path_extents:
49739eb79482SNamjae Jeon  * Shift the extents of a path structure lying between path[depth].p_ext
4974331573feSNamjae Jeon  * and EXT_LAST_EXTENT(path[depth].p_hdr), by @shift blocks. @SHIFT tells
4975331573feSNamjae Jeon  * if it is right shift or left shift operation.
49769eb79482SNamjae Jeon  */
49779eb79482SNamjae Jeon static int
49789eb79482SNamjae Jeon ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift,
49799eb79482SNamjae Jeon 			    struct inode *inode, handle_t *handle,
4980331573feSNamjae Jeon 			    enum SHIFT_DIRECTION SHIFT)
49819eb79482SNamjae Jeon {
49829eb79482SNamjae Jeon 	int depth, err = 0;
49839eb79482SNamjae Jeon 	struct ext4_extent *ex_start, *ex_last;
49844756ee18Szhengbin 	bool update = false;
49859eb79482SNamjae Jeon 	depth = path->p_depth;
49869eb79482SNamjae Jeon 
49879eb79482SNamjae Jeon 	while (depth >= 0) {
49889eb79482SNamjae Jeon 		if (depth == path->p_depth) {
49899eb79482SNamjae Jeon 			ex_start = path[depth].p_ext;
49909eb79482SNamjae Jeon 			if (!ex_start)
49916a797d27SDarrick J. Wong 				return -EFSCORRUPTED;
49929eb79482SNamjae Jeon 
49939eb79482SNamjae Jeon 			ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);
49949eb79482SNamjae Jeon 
49959eb79482SNamjae Jeon 			err = ext4_access_path(handle, inode, path + depth);
49969eb79482SNamjae Jeon 			if (err)
49979eb79482SNamjae Jeon 				goto out;
49989eb79482SNamjae Jeon 
49999eb79482SNamjae Jeon 			if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr))
50004756ee18Szhengbin 				update = true;
50019eb79482SNamjae Jeon 
50029eb79482SNamjae Jeon 			while (ex_start <= ex_last) {
5003331573feSNamjae Jeon 				if (SHIFT == SHIFT_LEFT) {
5004331573feSNamjae Jeon 					le32_add_cpu(&ex_start->ee_block,
5005331573feSNamjae Jeon 						-shift);
50066dd834efSLukas Czerner 					/* Try to merge to the left. */
50076dd834efSLukas Czerner 					if ((ex_start >
5008331573feSNamjae Jeon 					    EXT_FIRST_EXTENT(path[depth].p_hdr))
5009331573feSNamjae Jeon 					    &&
50106dd834efSLukas Czerner 					    ext4_ext_try_to_merge_right(inode,
50119eb79482SNamjae Jeon 					    path, ex_start - 1))
50129eb79482SNamjae Jeon 						ex_last--;
50136dd834efSLukas Czerner 					else
50149eb79482SNamjae Jeon 						ex_start++;
5015331573feSNamjae Jeon 				} else {
5016331573feSNamjae Jeon 					le32_add_cpu(&ex_last->ee_block, shift);
5017331573feSNamjae Jeon 					ext4_ext_try_to_merge_right(inode, path,
5018331573feSNamjae Jeon 						ex_last);
5019331573feSNamjae Jeon 					ex_last--;
5020331573feSNamjae Jeon 				}
50219eb79482SNamjae Jeon 			}
50229eb79482SNamjae Jeon 			err = ext4_ext_dirty(handle, inode, path + depth);
50239eb79482SNamjae Jeon 			if (err)
50249eb79482SNamjae Jeon 				goto out;
50259eb79482SNamjae Jeon 
50269eb79482SNamjae Jeon 			if (--depth < 0 || !update)
50279eb79482SNamjae Jeon 				break;
50289eb79482SNamjae Jeon 		}
50299eb79482SNamjae Jeon 
50309eb79482SNamjae Jeon 		/* Update index too */
50319eb79482SNamjae Jeon 		err = ext4_access_path(handle, inode, path + depth);
50329eb79482SNamjae Jeon 		if (err)
50339eb79482SNamjae Jeon 			goto out;
50349eb79482SNamjae Jeon 
5035331573feSNamjae Jeon 		if (SHIFT == SHIFT_LEFT)
5036847c6c42SZheng Liu 			le32_add_cpu(&path[depth].p_idx->ei_block, -shift);
5037331573feSNamjae Jeon 		else
5038331573feSNamjae Jeon 			le32_add_cpu(&path[depth].p_idx->ei_block, shift);
50399eb79482SNamjae Jeon 		err = ext4_ext_dirty(handle, inode, path + depth);
50409eb79482SNamjae Jeon 		if (err)
50419eb79482SNamjae Jeon 			goto out;
50429eb79482SNamjae Jeon 
50439eb79482SNamjae Jeon 		/* we are done if current index is not a starting index */
50449eb79482SNamjae Jeon 		if (path[depth].p_idx != EXT_FIRST_INDEX(path[depth].p_hdr))
50459eb79482SNamjae Jeon 			break;
50469eb79482SNamjae Jeon 
50479eb79482SNamjae Jeon 		depth--;
50489eb79482SNamjae Jeon 	}
50499eb79482SNamjae Jeon 
50509eb79482SNamjae Jeon out:
50519eb79482SNamjae Jeon 	return err;
50529eb79482SNamjae Jeon }
50539eb79482SNamjae Jeon 
50549eb79482SNamjae Jeon /*
50559eb79482SNamjae Jeon  * ext4_ext_shift_extents:
5056331573feSNamjae Jeon  * All the extents which lies in the range from @start to the last allocated
5057331573feSNamjae Jeon  * block for the @inode are shifted either towards left or right (depending
5058331573feSNamjae Jeon  * upon @SHIFT) by @shift blocks.
50599eb79482SNamjae Jeon  * On success, 0 is returned, error otherwise.
50609eb79482SNamjae Jeon  */
50619eb79482SNamjae Jeon static int
50629eb79482SNamjae Jeon ext4_ext_shift_extents(struct inode *inode, handle_t *handle,
5063331573feSNamjae Jeon 		       ext4_lblk_t start, ext4_lblk_t shift,
5064331573feSNamjae Jeon 		       enum SHIFT_DIRECTION SHIFT)
50659eb79482SNamjae Jeon {
50669eb79482SNamjae Jeon 	struct ext4_ext_path *path;
50679eb79482SNamjae Jeon 	int ret = 0, depth;
50689eb79482SNamjae Jeon 	struct ext4_extent *extent;
5069331573feSNamjae Jeon 	ext4_lblk_t stop, *iterator, ex_start, ex_end;
50709eb79482SNamjae Jeon 
50719eb79482SNamjae Jeon 	/* Let path point to the last extent */
507203e916faSRoman Pen 	path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
507303e916faSRoman Pen 				EXT4_EX_NOCACHE);
50749eb79482SNamjae Jeon 	if (IS_ERR(path))
50759eb79482SNamjae Jeon 		return PTR_ERR(path);
50769eb79482SNamjae Jeon 
50779eb79482SNamjae Jeon 	depth = path->p_depth;
50789eb79482SNamjae Jeon 	extent = path[depth].p_ext;
5079ee4bd0d9STheodore Ts'o 	if (!extent)
5080ee4bd0d9STheodore Ts'o 		goto out;
50819eb79482SNamjae Jeon 
50822a9b8cbaSRoman Pen 	stop = le32_to_cpu(extent->ee_block);
50839eb79482SNamjae Jeon 
50849eb79482SNamjae Jeon        /*
5085349fa7d6SEric Biggers 	* For left shifts, make sure the hole on the left is big enough to
5086349fa7d6SEric Biggers 	* accommodate the shift.  For right shifts, make sure the last extent
5087349fa7d6SEric Biggers 	* won't be shifted beyond EXT_MAX_BLOCKS.
50889eb79482SNamjae Jeon 	*/
5089331573feSNamjae Jeon 	if (SHIFT == SHIFT_LEFT) {
509003e916faSRoman Pen 		path = ext4_find_extent(inode, start - 1, &path,
509103e916faSRoman Pen 					EXT4_EX_NOCACHE);
50928dc79ec4SDmitry Monakhov 		if (IS_ERR(path))
50938dc79ec4SDmitry Monakhov 			return PTR_ERR(path);
50949eb79482SNamjae Jeon 		depth = path->p_depth;
50959eb79482SNamjae Jeon 		extent =  path[depth].p_ext;
50968dc79ec4SDmitry Monakhov 		if (extent) {
5097847c6c42SZheng Liu 			ex_start = le32_to_cpu(extent->ee_block);
5098847c6c42SZheng Liu 			ex_end = le32_to_cpu(extent->ee_block) +
5099847c6c42SZheng Liu 				ext4_ext_get_actual_len(extent);
51008dc79ec4SDmitry Monakhov 		} else {
51018dc79ec4SDmitry Monakhov 			ex_start = 0;
51028dc79ec4SDmitry Monakhov 			ex_end = 0;
51038dc79ec4SDmitry Monakhov 		}
51049eb79482SNamjae Jeon 
51059eb79482SNamjae Jeon 		if ((start == ex_start && shift > ex_start) ||
5106331573feSNamjae Jeon 		    (shift > start - ex_end)) {
5107349fa7d6SEric Biggers 			ret = -EINVAL;
5108349fa7d6SEric Biggers 			goto out;
5109349fa7d6SEric Biggers 		}
5110349fa7d6SEric Biggers 	} else {
5111349fa7d6SEric Biggers 		if (shift > EXT_MAX_BLOCKS -
5112349fa7d6SEric Biggers 		    (stop + ext4_ext_get_actual_len(extent))) {
5113349fa7d6SEric Biggers 			ret = -EINVAL;
5114349fa7d6SEric Biggers 			goto out;
5115331573feSNamjae Jeon 		}
5116331573feSNamjae Jeon 	}
5117331573feSNamjae Jeon 
5118331573feSNamjae Jeon 	/*
5119331573feSNamjae Jeon 	 * In case of left shift, iterator points to start and it is increased
5120331573feSNamjae Jeon 	 * till we reach stop. In case of right shift, iterator points to stop
5121331573feSNamjae Jeon 	 * and it is decreased till we reach start.
5122331573feSNamjae Jeon 	 */
5123331573feSNamjae Jeon 	if (SHIFT == SHIFT_LEFT)
5124331573feSNamjae Jeon 		iterator = &start;
5125331573feSNamjae Jeon 	else
5126331573feSNamjae Jeon 		iterator = &stop;
51279eb79482SNamjae Jeon 
51282a9b8cbaSRoman Pen 	/*
51292a9b8cbaSRoman Pen 	 * Its safe to start updating extents.  Start and stop are unsigned, so
51302a9b8cbaSRoman Pen 	 * in case of right shift if extent with 0 block is reached, iterator
51312a9b8cbaSRoman Pen 	 * becomes NULL to indicate the end of the loop.
51322a9b8cbaSRoman Pen 	 */
51332a9b8cbaSRoman Pen 	while (iterator && start <= stop) {
513403e916faSRoman Pen 		path = ext4_find_extent(inode, *iterator, &path,
513503e916faSRoman Pen 					EXT4_EX_NOCACHE);
51369eb79482SNamjae Jeon 		if (IS_ERR(path))
51379eb79482SNamjae Jeon 			return PTR_ERR(path);
51389eb79482SNamjae Jeon 		depth = path->p_depth;
51399eb79482SNamjae Jeon 		extent = path[depth].p_ext;
5140a18ed359SDmitry Monakhov 		if (!extent) {
5141a18ed359SDmitry Monakhov 			EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
5142331573feSNamjae Jeon 					 (unsigned long) *iterator);
51436a797d27SDarrick J. Wong 			return -EFSCORRUPTED;
5144a18ed359SDmitry Monakhov 		}
5145331573feSNamjae Jeon 		if (SHIFT == SHIFT_LEFT && *iterator >
5146331573feSNamjae Jeon 		    le32_to_cpu(extent->ee_block)) {
51479eb79482SNamjae Jeon 			/* Hole, move to the next extent */
5148f8fb4f41SDmitry Monakhov 			if (extent < EXT_LAST_EXTENT(path[depth].p_hdr)) {
5149f8fb4f41SDmitry Monakhov 				path[depth].p_ext++;
5150f8fb4f41SDmitry Monakhov 			} else {
5151331573feSNamjae Jeon 				*iterator = ext4_ext_next_allocated_block(path);
5152f8fb4f41SDmitry Monakhov 				continue;
51539eb79482SNamjae Jeon 			}
51549eb79482SNamjae Jeon 		}
5155331573feSNamjae Jeon 
5156331573feSNamjae Jeon 		if (SHIFT == SHIFT_LEFT) {
5157331573feSNamjae Jeon 			extent = EXT_LAST_EXTENT(path[depth].p_hdr);
5158331573feSNamjae Jeon 			*iterator = le32_to_cpu(extent->ee_block) +
5159331573feSNamjae Jeon 					ext4_ext_get_actual_len(extent);
5160331573feSNamjae Jeon 		} else {
5161331573feSNamjae Jeon 			extent = EXT_FIRST_EXTENT(path[depth].p_hdr);
51622a9b8cbaSRoman Pen 			if (le32_to_cpu(extent->ee_block) > 0)
51632a9b8cbaSRoman Pen 				*iterator = le32_to_cpu(extent->ee_block) - 1;
51642a9b8cbaSRoman Pen 			else
51652a9b8cbaSRoman Pen 				/* Beginning is reached, end of the loop */
51662a9b8cbaSRoman Pen 				iterator = NULL;
5167331573feSNamjae Jeon 			/* Update path extent in case we need to stop */
5168331573feSNamjae Jeon 			while (le32_to_cpu(extent->ee_block) < start)
5169331573feSNamjae Jeon 				extent++;
5170331573feSNamjae Jeon 			path[depth].p_ext = extent;
5171331573feSNamjae Jeon 		}
51729eb79482SNamjae Jeon 		ret = ext4_ext_shift_path_extents(path, shift, inode,
5173331573feSNamjae Jeon 				handle, SHIFT);
51749eb79482SNamjae Jeon 		if (ret)
51759eb79482SNamjae Jeon 			break;
51769eb79482SNamjae Jeon 	}
5177ee4bd0d9STheodore Ts'o out:
5178ee4bd0d9STheodore Ts'o 	ext4_ext_drop_refs(path);
5179ee4bd0d9STheodore Ts'o 	kfree(path);
51809eb79482SNamjae Jeon 	return ret;
51819eb79482SNamjae Jeon }
51829eb79482SNamjae Jeon 
51839eb79482SNamjae Jeon /*
51849eb79482SNamjae Jeon  * ext4_collapse_range:
51859eb79482SNamjae Jeon  * This implements the fallocate's collapse range functionality for ext4
51869eb79482SNamjae Jeon  * Returns: 0 and non-zero on error.
51879eb79482SNamjae Jeon  */
518843f81677SEric Biggers static int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
51899eb79482SNamjae Jeon {
51909eb79482SNamjae Jeon 	struct super_block *sb = inode->i_sb;
51919eb79482SNamjae Jeon 	ext4_lblk_t punch_start, punch_stop;
51929eb79482SNamjae Jeon 	handle_t *handle;
51939eb79482SNamjae Jeon 	unsigned int credits;
5194a8680e0dSNamjae Jeon 	loff_t new_size, ioffset;
51959eb79482SNamjae Jeon 	int ret;
51969eb79482SNamjae Jeon 
5197b9576fc3STheodore Ts'o 	/*
5198b9576fc3STheodore Ts'o 	 * We need to test this early because xfstests assumes that a
5199b9576fc3STheodore Ts'o 	 * collapse range of (0, 1) will return EOPNOTSUPP if the file
5200b9576fc3STheodore Ts'o 	 * system does not support collapse range.
5201b9576fc3STheodore Ts'o 	 */
5202b9576fc3STheodore Ts'o 	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5203b9576fc3STheodore Ts'o 		return -EOPNOTSUPP;
5204b9576fc3STheodore Ts'o 
52059b02e498SEric Biggers 	/* Collapse range works only on fs cluster size aligned regions. */
52069b02e498SEric Biggers 	if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))
52079eb79482SNamjae Jeon 		return -EINVAL;
52089eb79482SNamjae Jeon 
52099eb79482SNamjae Jeon 	trace_ext4_collapse_range(inode, offset, len);
52109eb79482SNamjae Jeon 
52119eb79482SNamjae Jeon 	punch_start = offset >> EXT4_BLOCK_SIZE_BITS(sb);
52129eb79482SNamjae Jeon 	punch_stop = (offset + len) >> EXT4_BLOCK_SIZE_BITS(sb);
52139eb79482SNamjae Jeon 
52141ce01c4aSNamjae Jeon 	/* Call ext4_force_commit to flush all data in case of data=journal. */
52151ce01c4aSNamjae Jeon 	if (ext4_should_journal_data(inode)) {
52161ce01c4aSNamjae Jeon 		ret = ext4_force_commit(inode->i_sb);
52171ce01c4aSNamjae Jeon 		if (ret)
52181ce01c4aSNamjae Jeon 			return ret;
52191ce01c4aSNamjae Jeon 	}
52201ce01c4aSNamjae Jeon 
52215955102cSAl Viro 	inode_lock(inode);
522223fffa92SLukas Czerner 	/*
522323fffa92SLukas Czerner 	 * There is no need to overlap collapse range with EOF, in which case
522423fffa92SLukas Czerner 	 * it is effectively a truncate operation
522523fffa92SLukas Czerner 	 */
52269b02e498SEric Biggers 	if (offset + len >= inode->i_size) {
522723fffa92SLukas Czerner 		ret = -EINVAL;
522823fffa92SLukas Czerner 		goto out_mutex;
522923fffa92SLukas Czerner 	}
523023fffa92SLukas Czerner 
52319eb79482SNamjae Jeon 	/* Currently just for extent based files */
52329eb79482SNamjae Jeon 	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
52339eb79482SNamjae Jeon 		ret = -EOPNOTSUPP;
52349eb79482SNamjae Jeon 		goto out_mutex;
52359eb79482SNamjae Jeon 	}
52369eb79482SNamjae Jeon 
52379eb79482SNamjae Jeon 	/* Wait for existing dio to complete */
52389eb79482SNamjae Jeon 	inode_dio_wait(inode);
52399eb79482SNamjae Jeon 
5240ea3d7209SJan Kara 	/*
5241ea3d7209SJan Kara 	 * Prevent page faults from reinstantiating pages we have released from
5242ea3d7209SJan Kara 	 * page cache.
5243ea3d7209SJan Kara 	 */
5244ea3d7209SJan Kara 	down_write(&EXT4_I(inode)->i_mmap_sem);
5245430657b6SRoss Zwisler 
5246430657b6SRoss Zwisler 	ret = ext4_break_layouts(inode);
5247430657b6SRoss Zwisler 	if (ret)
5248430657b6SRoss Zwisler 		goto out_mmap;
5249430657b6SRoss Zwisler 
525032ebffd3SJan Kara 	/*
525132ebffd3SJan Kara 	 * Need to round down offset to be aligned with page size boundary
525232ebffd3SJan Kara 	 * for page size > block size.
525332ebffd3SJan Kara 	 */
525432ebffd3SJan Kara 	ioffset = round_down(offset, PAGE_SIZE);
525532ebffd3SJan Kara 	/*
525632ebffd3SJan Kara 	 * Write tail of the last page before removed range since it will get
525732ebffd3SJan Kara 	 * removed from the page cache below.
525832ebffd3SJan Kara 	 */
525932ebffd3SJan Kara 	ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset);
526032ebffd3SJan Kara 	if (ret)
526132ebffd3SJan Kara 		goto out_mmap;
526232ebffd3SJan Kara 	/*
526332ebffd3SJan Kara 	 * Write data that will be shifted to preserve them when discarding
526432ebffd3SJan Kara 	 * page cache below. We are also protected from pages becoming dirty
526532ebffd3SJan Kara 	 * by i_mmap_sem.
526632ebffd3SJan Kara 	 */
526732ebffd3SJan Kara 	ret = filemap_write_and_wait_range(inode->i_mapping, offset + len,
526832ebffd3SJan Kara 					   LLONG_MAX);
526932ebffd3SJan Kara 	if (ret)
527032ebffd3SJan Kara 		goto out_mmap;
5271ea3d7209SJan Kara 	truncate_pagecache(inode, ioffset);
5272ea3d7209SJan Kara 
52739eb79482SNamjae Jeon 	credits = ext4_writepage_trans_blocks(inode);
52749eb79482SNamjae Jeon 	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
52759eb79482SNamjae Jeon 	if (IS_ERR(handle)) {
52769eb79482SNamjae Jeon 		ret = PTR_ERR(handle);
5277ea3d7209SJan Kara 		goto out_mmap;
52789eb79482SNamjae Jeon 	}
52799eb79482SNamjae Jeon 
52809eb79482SNamjae Jeon 	down_write(&EXT4_I(inode)->i_data_sem);
52819eb79482SNamjae Jeon 	ext4_discard_preallocations(inode);
52829eb79482SNamjae Jeon 
52839eb79482SNamjae Jeon 	ret = ext4_es_remove_extent(inode, punch_start,
52842c1d2328SLukas Czerner 				    EXT_MAX_BLOCKS - punch_start);
52859eb79482SNamjae Jeon 	if (ret) {
52869eb79482SNamjae Jeon 		up_write(&EXT4_I(inode)->i_data_sem);
52879eb79482SNamjae Jeon 		goto out_stop;
52889eb79482SNamjae Jeon 	}
52899eb79482SNamjae Jeon 
52909eb79482SNamjae Jeon 	ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1);
52919eb79482SNamjae Jeon 	if (ret) {
52929eb79482SNamjae Jeon 		up_write(&EXT4_I(inode)->i_data_sem);
52939eb79482SNamjae Jeon 		goto out_stop;
52949eb79482SNamjae Jeon 	}
5295ef24f6c2SLukas Czerner 	ext4_discard_preallocations(inode);
52969eb79482SNamjae Jeon 
52979eb79482SNamjae Jeon 	ret = ext4_ext_shift_extents(inode, handle, punch_stop,
5298331573feSNamjae Jeon 				     punch_stop - punch_start, SHIFT_LEFT);
52999eb79482SNamjae Jeon 	if (ret) {
53009eb79482SNamjae Jeon 		up_write(&EXT4_I(inode)->i_data_sem);
53019eb79482SNamjae Jeon 		goto out_stop;
53029eb79482SNamjae Jeon 	}
53039eb79482SNamjae Jeon 
53049b02e498SEric Biggers 	new_size = inode->i_size - len;
53059337d5d3SLukas Czerner 	i_size_write(inode, new_size);
53069eb79482SNamjae Jeon 	EXT4_I(inode)->i_disksize = new_size;
53079eb79482SNamjae Jeon 
53089eb79482SNamjae Jeon 	up_write(&EXT4_I(inode)->i_data_sem);
53099eb79482SNamjae Jeon 	if (IS_SYNC(inode))
53109eb79482SNamjae Jeon 		ext4_handle_sync(handle);
5311eeca7ea1SDeepa Dinamani 	inode->i_mtime = inode->i_ctime = current_time(inode);
53124209ae12SHarshad Shirwadkar 	ret = ext4_mark_inode_dirty(handle, inode);
531367a7d5f5SJan Kara 	ext4_update_inode_fsync_trans(handle, inode, 1);
53149eb79482SNamjae Jeon 
53159eb79482SNamjae Jeon out_stop:
53169eb79482SNamjae Jeon 	ext4_journal_stop(handle);
5317ea3d7209SJan Kara out_mmap:
5318ea3d7209SJan Kara 	up_write(&EXT4_I(inode)->i_mmap_sem);
53199eb79482SNamjae Jeon out_mutex:
53205955102cSAl Viro 	inode_unlock(inode);
53219eb79482SNamjae Jeon 	return ret;
53229eb79482SNamjae Jeon }
5323fcf6b1b7SDmitry Monakhov 
5324331573feSNamjae Jeon /*
5325331573feSNamjae Jeon  * ext4_insert_range:
5326331573feSNamjae Jeon  * This function implements the FALLOC_FL_INSERT_RANGE flag of fallocate.
5327331573feSNamjae Jeon  * The data blocks starting from @offset to the EOF are shifted by @len
5328331573feSNamjae Jeon  * towards right to create a hole in the @inode. Inode size is increased
5329331573feSNamjae Jeon  * by len bytes.
5330331573feSNamjae Jeon  * Returns 0 on success, error otherwise.
5331331573feSNamjae Jeon  */
533243f81677SEric Biggers static int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
5333331573feSNamjae Jeon {
5334331573feSNamjae Jeon 	struct super_block *sb = inode->i_sb;
5335331573feSNamjae Jeon 	handle_t *handle;
5336331573feSNamjae Jeon 	struct ext4_ext_path *path;
5337331573feSNamjae Jeon 	struct ext4_extent *extent;
5338331573feSNamjae Jeon 	ext4_lblk_t offset_lblk, len_lblk, ee_start_lblk = 0;
5339331573feSNamjae Jeon 	unsigned int credits, ee_len;
5340331573feSNamjae Jeon 	int ret = 0, depth, split_flag = 0;
5341331573feSNamjae Jeon 	loff_t ioffset;
5342331573feSNamjae Jeon 
5343331573feSNamjae Jeon 	/*
5344331573feSNamjae Jeon 	 * We need to test this early because xfstests assumes that an
5345331573feSNamjae Jeon 	 * insert range of (0, 1) will return EOPNOTSUPP if the file
5346331573feSNamjae Jeon 	 * system does not support insert range.
5347331573feSNamjae Jeon 	 */
5348331573feSNamjae Jeon 	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5349331573feSNamjae Jeon 		return -EOPNOTSUPP;
5350331573feSNamjae Jeon 
53519b02e498SEric Biggers 	/* Insert range works only on fs cluster size aligned regions. */
53529b02e498SEric Biggers 	if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))
5353331573feSNamjae Jeon 		return -EINVAL;
5354331573feSNamjae Jeon 
5355331573feSNamjae Jeon 	trace_ext4_insert_range(inode, offset, len);
5356331573feSNamjae Jeon 
5357331573feSNamjae Jeon 	offset_lblk = offset >> EXT4_BLOCK_SIZE_BITS(sb);
5358331573feSNamjae Jeon 	len_lblk = len >> EXT4_BLOCK_SIZE_BITS(sb);
5359331573feSNamjae Jeon 
5360331573feSNamjae Jeon 	/* Call ext4_force_commit to flush all data in case of data=journal */
5361331573feSNamjae Jeon 	if (ext4_should_journal_data(inode)) {
5362331573feSNamjae Jeon 		ret = ext4_force_commit(inode->i_sb);
5363331573feSNamjae Jeon 		if (ret)
5364331573feSNamjae Jeon 			return ret;
5365331573feSNamjae Jeon 	}
5366331573feSNamjae Jeon 
53675955102cSAl Viro 	inode_lock(inode);
5368331573feSNamjae Jeon 	/* Currently just for extent based files */
5369331573feSNamjae Jeon 	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5370331573feSNamjae Jeon 		ret = -EOPNOTSUPP;
5371331573feSNamjae Jeon 		goto out_mutex;
5372331573feSNamjae Jeon 	}
5373331573feSNamjae Jeon 
53749b02e498SEric Biggers 	/* Check whether the maximum file size would be exceeded */
53759b02e498SEric Biggers 	if (len > inode->i_sb->s_maxbytes - inode->i_size) {
5376331573feSNamjae Jeon 		ret = -EFBIG;
5377331573feSNamjae Jeon 		goto out_mutex;
5378331573feSNamjae Jeon 	}
5379331573feSNamjae Jeon 
53809b02e498SEric Biggers 	/* Offset must be less than i_size */
53819b02e498SEric Biggers 	if (offset >= inode->i_size) {
5382331573feSNamjae Jeon 		ret = -EINVAL;
5383331573feSNamjae Jeon 		goto out_mutex;
5384331573feSNamjae Jeon 	}
5385331573feSNamjae Jeon 
5386331573feSNamjae Jeon 	/* Wait for existing dio to complete */
5387331573feSNamjae Jeon 	inode_dio_wait(inode);
5388331573feSNamjae Jeon 
5389ea3d7209SJan Kara 	/*
5390ea3d7209SJan Kara 	 * Prevent page faults from reinstantiating pages we have released from
5391ea3d7209SJan Kara 	 * page cache.
5392ea3d7209SJan Kara 	 */
5393ea3d7209SJan Kara 	down_write(&EXT4_I(inode)->i_mmap_sem);
5394430657b6SRoss Zwisler 
5395430657b6SRoss Zwisler 	ret = ext4_break_layouts(inode);
5396430657b6SRoss Zwisler 	if (ret)
5397430657b6SRoss Zwisler 		goto out_mmap;
5398430657b6SRoss Zwisler 
539932ebffd3SJan Kara 	/*
540032ebffd3SJan Kara 	 * Need to round down to align start offset to page size boundary
540132ebffd3SJan Kara 	 * for page size > block size.
540232ebffd3SJan Kara 	 */
540332ebffd3SJan Kara 	ioffset = round_down(offset, PAGE_SIZE);
540432ebffd3SJan Kara 	/* Write out all dirty pages */
540532ebffd3SJan Kara 	ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
540632ebffd3SJan Kara 			LLONG_MAX);
540732ebffd3SJan Kara 	if (ret)
540832ebffd3SJan Kara 		goto out_mmap;
5409ea3d7209SJan Kara 	truncate_pagecache(inode, ioffset);
5410ea3d7209SJan Kara 
5411331573feSNamjae Jeon 	credits = ext4_writepage_trans_blocks(inode);
5412331573feSNamjae Jeon 	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5413331573feSNamjae Jeon 	if (IS_ERR(handle)) {
5414331573feSNamjae Jeon 		ret = PTR_ERR(handle);
5415ea3d7209SJan Kara 		goto out_mmap;
5416331573feSNamjae Jeon 	}
5417331573feSNamjae Jeon 
5418331573feSNamjae Jeon 	/* Expand file to avoid data loss if there is error while shifting */
5419331573feSNamjae Jeon 	inode->i_size += len;
5420331573feSNamjae Jeon 	EXT4_I(inode)->i_disksize += len;
5421eeca7ea1SDeepa Dinamani 	inode->i_mtime = inode->i_ctime = current_time(inode);
5422331573feSNamjae Jeon 	ret = ext4_mark_inode_dirty(handle, inode);
5423331573feSNamjae Jeon 	if (ret)
5424331573feSNamjae Jeon 		goto out_stop;
5425331573feSNamjae Jeon 
5426331573feSNamjae Jeon 	down_write(&EXT4_I(inode)->i_data_sem);
5427331573feSNamjae Jeon 	ext4_discard_preallocations(inode);
5428331573feSNamjae Jeon 
5429331573feSNamjae Jeon 	path = ext4_find_extent(inode, offset_lblk, NULL, 0);
5430331573feSNamjae Jeon 	if (IS_ERR(path)) {
5431331573feSNamjae Jeon 		up_write(&EXT4_I(inode)->i_data_sem);
5432331573feSNamjae Jeon 		goto out_stop;
5433331573feSNamjae Jeon 	}
5434331573feSNamjae Jeon 
5435331573feSNamjae Jeon 	depth = ext_depth(inode);
5436331573feSNamjae Jeon 	extent = path[depth].p_ext;
5437331573feSNamjae Jeon 	if (extent) {
5438331573feSNamjae Jeon 		ee_start_lblk = le32_to_cpu(extent->ee_block);
5439331573feSNamjae Jeon 		ee_len = ext4_ext_get_actual_len(extent);
5440331573feSNamjae Jeon 
5441331573feSNamjae Jeon 		/*
5442331573feSNamjae Jeon 		 * If offset_lblk is not the starting block of extent, split
5443331573feSNamjae Jeon 		 * the extent @offset_lblk
5444331573feSNamjae Jeon 		 */
5445331573feSNamjae Jeon 		if ((offset_lblk > ee_start_lblk) &&
5446331573feSNamjae Jeon 				(offset_lblk < (ee_start_lblk + ee_len))) {
5447331573feSNamjae Jeon 			if (ext4_ext_is_unwritten(extent))
5448331573feSNamjae Jeon 				split_flag = EXT4_EXT_MARK_UNWRIT1 |
5449331573feSNamjae Jeon 					EXT4_EXT_MARK_UNWRIT2;
5450331573feSNamjae Jeon 			ret = ext4_split_extent_at(handle, inode, &path,
5451331573feSNamjae Jeon 					offset_lblk, split_flag,
5452331573feSNamjae Jeon 					EXT4_EX_NOCACHE |
5453331573feSNamjae Jeon 					EXT4_GET_BLOCKS_PRE_IO |
5454331573feSNamjae Jeon 					EXT4_GET_BLOCKS_METADATA_NOFAIL);
5455331573feSNamjae Jeon 		}
5456331573feSNamjae Jeon 
5457331573feSNamjae Jeon 		ext4_ext_drop_refs(path);
5458331573feSNamjae Jeon 		kfree(path);
5459331573feSNamjae Jeon 		if (ret < 0) {
5460331573feSNamjae Jeon 			up_write(&EXT4_I(inode)->i_data_sem);
5461331573feSNamjae Jeon 			goto out_stop;
5462331573feSNamjae Jeon 		}
5463edf15aa1SFabian Frederick 	} else {
5464edf15aa1SFabian Frederick 		ext4_ext_drop_refs(path);
5465edf15aa1SFabian Frederick 		kfree(path);
5466331573feSNamjae Jeon 	}
5467331573feSNamjae Jeon 
5468331573feSNamjae Jeon 	ret = ext4_es_remove_extent(inode, offset_lblk,
5469331573feSNamjae Jeon 			EXT_MAX_BLOCKS - offset_lblk);
5470331573feSNamjae Jeon 	if (ret) {
5471331573feSNamjae Jeon 		up_write(&EXT4_I(inode)->i_data_sem);
5472331573feSNamjae Jeon 		goto out_stop;
5473331573feSNamjae Jeon 	}
5474331573feSNamjae Jeon 
5475331573feSNamjae Jeon 	/*
5476331573feSNamjae Jeon 	 * if offset_lblk lies in a hole which is at start of file, use
5477331573feSNamjae Jeon 	 * ee_start_lblk to shift extents
5478331573feSNamjae Jeon 	 */
5479331573feSNamjae Jeon 	ret = ext4_ext_shift_extents(inode, handle,
5480331573feSNamjae Jeon 		ee_start_lblk > offset_lblk ? ee_start_lblk : offset_lblk,
5481331573feSNamjae Jeon 		len_lblk, SHIFT_RIGHT);
5482331573feSNamjae Jeon 
5483331573feSNamjae Jeon 	up_write(&EXT4_I(inode)->i_data_sem);
5484331573feSNamjae Jeon 	if (IS_SYNC(inode))
5485331573feSNamjae Jeon 		ext4_handle_sync(handle);
548667a7d5f5SJan Kara 	if (ret >= 0)
548767a7d5f5SJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 1);
5488331573feSNamjae Jeon 
5489331573feSNamjae Jeon out_stop:
5490331573feSNamjae Jeon 	ext4_journal_stop(handle);
5491ea3d7209SJan Kara out_mmap:
5492ea3d7209SJan Kara 	up_write(&EXT4_I(inode)->i_mmap_sem);
5493331573feSNamjae Jeon out_mutex:
54945955102cSAl Viro 	inode_unlock(inode);
5495331573feSNamjae Jeon 	return ret;
5496331573feSNamjae Jeon }
5497331573feSNamjae Jeon 
5498fcf6b1b7SDmitry Monakhov /**
5499c60990b3STheodore Ts'o  * ext4_swap_extents() - Swap extents between two inodes
5500c60990b3STheodore Ts'o  * @handle: handle for this transaction
5501fcf6b1b7SDmitry Monakhov  * @inode1:	First inode
5502fcf6b1b7SDmitry Monakhov  * @inode2:	Second inode
5503fcf6b1b7SDmitry Monakhov  * @lblk1:	Start block for first inode
5504fcf6b1b7SDmitry Monakhov  * @lblk2:	Start block for second inode
5505fcf6b1b7SDmitry Monakhov  * @count:	Number of blocks to swap
5506dcae058aSzhenwei.pi  * @unwritten: Mark second inode's extents as unwritten after swap
5507fcf6b1b7SDmitry Monakhov  * @erp:	Pointer to save error value
5508fcf6b1b7SDmitry Monakhov  *
5509fcf6b1b7SDmitry Monakhov  * This helper routine does exactly what is promise "swap extents". All other
5510fcf6b1b7SDmitry Monakhov  * stuff such as page-cache locking consistency, bh mapping consistency or
5511fcf6b1b7SDmitry Monakhov  * extent's data copying must be performed by caller.
5512fcf6b1b7SDmitry Monakhov  * Locking:
5513fcf6b1b7SDmitry Monakhov  * 		i_mutex is held for both inodes
5514fcf6b1b7SDmitry Monakhov  * 		i_data_sem is locked for write for both inodes
5515fcf6b1b7SDmitry Monakhov  * Assumptions:
5516fcf6b1b7SDmitry Monakhov  *		All pages from requested range are locked for both inodes
5517fcf6b1b7SDmitry Monakhov  */
5518fcf6b1b7SDmitry Monakhov int
5519fcf6b1b7SDmitry Monakhov ext4_swap_extents(handle_t *handle, struct inode *inode1,
5520fcf6b1b7SDmitry Monakhov 		  struct inode *inode2, ext4_lblk_t lblk1, ext4_lblk_t lblk2,
5521fcf6b1b7SDmitry Monakhov 		  ext4_lblk_t count, int unwritten, int *erp)
5522fcf6b1b7SDmitry Monakhov {
5523fcf6b1b7SDmitry Monakhov 	struct ext4_ext_path *path1 = NULL;
5524fcf6b1b7SDmitry Monakhov 	struct ext4_ext_path *path2 = NULL;
5525fcf6b1b7SDmitry Monakhov 	int replaced_count = 0;
5526fcf6b1b7SDmitry Monakhov 
5527fcf6b1b7SDmitry Monakhov 	BUG_ON(!rwsem_is_locked(&EXT4_I(inode1)->i_data_sem));
5528fcf6b1b7SDmitry Monakhov 	BUG_ON(!rwsem_is_locked(&EXT4_I(inode2)->i_data_sem));
55295955102cSAl Viro 	BUG_ON(!inode_is_locked(inode1));
55305955102cSAl Viro 	BUG_ON(!inode_is_locked(inode2));
5531fcf6b1b7SDmitry Monakhov 
5532fcf6b1b7SDmitry Monakhov 	*erp = ext4_es_remove_extent(inode1, lblk1, count);
553319008f6dSTheodore Ts'o 	if (unlikely(*erp))
5534fcf6b1b7SDmitry Monakhov 		return 0;
5535fcf6b1b7SDmitry Monakhov 	*erp = ext4_es_remove_extent(inode2, lblk2, count);
553619008f6dSTheodore Ts'o 	if (unlikely(*erp))
5537fcf6b1b7SDmitry Monakhov 		return 0;
5538fcf6b1b7SDmitry Monakhov 
5539fcf6b1b7SDmitry Monakhov 	while (count) {
5540fcf6b1b7SDmitry Monakhov 		struct ext4_extent *ex1, *ex2, tmp_ex;
5541fcf6b1b7SDmitry Monakhov 		ext4_lblk_t e1_blk, e2_blk;
5542fcf6b1b7SDmitry Monakhov 		int e1_len, e2_len, len;
5543fcf6b1b7SDmitry Monakhov 		int split = 0;
5544fcf6b1b7SDmitry Monakhov 
5545ed8a1a76STheodore Ts'o 		path1 = ext4_find_extent(inode1, lblk1, NULL, EXT4_EX_NOCACHE);
5546a1c83681SViresh Kumar 		if (IS_ERR(path1)) {
5547fcf6b1b7SDmitry Monakhov 			*erp = PTR_ERR(path1);
554819008f6dSTheodore Ts'o 			path1 = NULL;
554919008f6dSTheodore Ts'o 		finish:
555019008f6dSTheodore Ts'o 			count = 0;
555119008f6dSTheodore Ts'o 			goto repeat;
5552fcf6b1b7SDmitry Monakhov 		}
5553ed8a1a76STheodore Ts'o 		path2 = ext4_find_extent(inode2, lblk2, NULL, EXT4_EX_NOCACHE);
5554a1c83681SViresh Kumar 		if (IS_ERR(path2)) {
5555fcf6b1b7SDmitry Monakhov 			*erp = PTR_ERR(path2);
555619008f6dSTheodore Ts'o 			path2 = NULL;
555719008f6dSTheodore Ts'o 			goto finish;
5558fcf6b1b7SDmitry Monakhov 		}
5559fcf6b1b7SDmitry Monakhov 		ex1 = path1[path1->p_depth].p_ext;
5560fcf6b1b7SDmitry Monakhov 		ex2 = path2[path2->p_depth].p_ext;
5561fcf6b1b7SDmitry Monakhov 		/* Do we have somthing to swap ? */
5562fcf6b1b7SDmitry Monakhov 		if (unlikely(!ex2 || !ex1))
556319008f6dSTheodore Ts'o 			goto finish;
5564fcf6b1b7SDmitry Monakhov 
5565fcf6b1b7SDmitry Monakhov 		e1_blk = le32_to_cpu(ex1->ee_block);
5566fcf6b1b7SDmitry Monakhov 		e2_blk = le32_to_cpu(ex2->ee_block);
5567fcf6b1b7SDmitry Monakhov 		e1_len = ext4_ext_get_actual_len(ex1);
5568fcf6b1b7SDmitry Monakhov 		e2_len = ext4_ext_get_actual_len(ex2);
5569fcf6b1b7SDmitry Monakhov 
5570fcf6b1b7SDmitry Monakhov 		/* Hole handling */
5571fcf6b1b7SDmitry Monakhov 		if (!in_range(lblk1, e1_blk, e1_len) ||
5572fcf6b1b7SDmitry Monakhov 		    !in_range(lblk2, e2_blk, e2_len)) {
5573fcf6b1b7SDmitry Monakhov 			ext4_lblk_t next1, next2;
5574fcf6b1b7SDmitry Monakhov 
5575fcf6b1b7SDmitry Monakhov 			/* if hole after extent, then go to next extent */
5576fcf6b1b7SDmitry Monakhov 			next1 = ext4_ext_next_allocated_block(path1);
5577fcf6b1b7SDmitry Monakhov 			next2 = ext4_ext_next_allocated_block(path2);
5578fcf6b1b7SDmitry Monakhov 			/* If hole before extent, then shift to that extent */
5579fcf6b1b7SDmitry Monakhov 			if (e1_blk > lblk1)
5580fcf6b1b7SDmitry Monakhov 				next1 = e1_blk;
5581fcf6b1b7SDmitry Monakhov 			if (e2_blk > lblk2)
55824e562013SManinder Singh 				next2 = e2_blk;
5583fcf6b1b7SDmitry Monakhov 			/* Do we have something to swap */
5584fcf6b1b7SDmitry Monakhov 			if (next1 == EXT_MAX_BLOCKS || next2 == EXT_MAX_BLOCKS)
558519008f6dSTheodore Ts'o 				goto finish;
5586fcf6b1b7SDmitry Monakhov 			/* Move to the rightest boundary */
5587fcf6b1b7SDmitry Monakhov 			len = next1 - lblk1;
5588fcf6b1b7SDmitry Monakhov 			if (len < next2 - lblk2)
5589fcf6b1b7SDmitry Monakhov 				len = next2 - lblk2;
5590fcf6b1b7SDmitry Monakhov 			if (len > count)
5591fcf6b1b7SDmitry Monakhov 				len = count;
5592fcf6b1b7SDmitry Monakhov 			lblk1 += len;
5593fcf6b1b7SDmitry Monakhov 			lblk2 += len;
5594fcf6b1b7SDmitry Monakhov 			count -= len;
5595fcf6b1b7SDmitry Monakhov 			goto repeat;
5596fcf6b1b7SDmitry Monakhov 		}
5597fcf6b1b7SDmitry Monakhov 
5598fcf6b1b7SDmitry Monakhov 		/* Prepare left boundary */
5599fcf6b1b7SDmitry Monakhov 		if (e1_blk < lblk1) {
5600fcf6b1b7SDmitry Monakhov 			split = 1;
5601fcf6b1b7SDmitry Monakhov 			*erp = ext4_force_split_extent_at(handle, inode1,
5602dfe50809STheodore Ts'o 						&path1, lblk1, 0);
560319008f6dSTheodore Ts'o 			if (unlikely(*erp))
560419008f6dSTheodore Ts'o 				goto finish;
5605fcf6b1b7SDmitry Monakhov 		}
5606fcf6b1b7SDmitry Monakhov 		if (e2_blk < lblk2) {
5607fcf6b1b7SDmitry Monakhov 			split = 1;
5608fcf6b1b7SDmitry Monakhov 			*erp = ext4_force_split_extent_at(handle, inode2,
5609dfe50809STheodore Ts'o 						&path2,  lblk2, 0);
561019008f6dSTheodore Ts'o 			if (unlikely(*erp))
561119008f6dSTheodore Ts'o 				goto finish;
5612fcf6b1b7SDmitry Monakhov 		}
5613dfe50809STheodore Ts'o 		/* ext4_split_extent_at() may result in leaf extent split,
5614fcf6b1b7SDmitry Monakhov 		 * path must to be revalidated. */
5615fcf6b1b7SDmitry Monakhov 		if (split)
5616fcf6b1b7SDmitry Monakhov 			goto repeat;
5617fcf6b1b7SDmitry Monakhov 
5618fcf6b1b7SDmitry Monakhov 		/* Prepare right boundary */
5619fcf6b1b7SDmitry Monakhov 		len = count;
5620fcf6b1b7SDmitry Monakhov 		if (len > e1_blk + e1_len - lblk1)
5621fcf6b1b7SDmitry Monakhov 			len = e1_blk + e1_len - lblk1;
5622fcf6b1b7SDmitry Monakhov 		if (len > e2_blk + e2_len - lblk2)
5623fcf6b1b7SDmitry Monakhov 			len = e2_blk + e2_len - lblk2;
5624fcf6b1b7SDmitry Monakhov 
5625fcf6b1b7SDmitry Monakhov 		if (len != e1_len) {
5626fcf6b1b7SDmitry Monakhov 			split = 1;
5627fcf6b1b7SDmitry Monakhov 			*erp = ext4_force_split_extent_at(handle, inode1,
5628dfe50809STheodore Ts'o 						&path1, lblk1 + len, 0);
562919008f6dSTheodore Ts'o 			if (unlikely(*erp))
563019008f6dSTheodore Ts'o 				goto finish;
5631fcf6b1b7SDmitry Monakhov 		}
5632fcf6b1b7SDmitry Monakhov 		if (len != e2_len) {
5633fcf6b1b7SDmitry Monakhov 			split = 1;
5634fcf6b1b7SDmitry Monakhov 			*erp = ext4_force_split_extent_at(handle, inode2,
5635dfe50809STheodore Ts'o 						&path2, lblk2 + len, 0);
5636fcf6b1b7SDmitry Monakhov 			if (*erp)
563719008f6dSTheodore Ts'o 				goto finish;
5638fcf6b1b7SDmitry Monakhov 		}
5639dfe50809STheodore Ts'o 		/* ext4_split_extent_at() may result in leaf extent split,
5640fcf6b1b7SDmitry Monakhov 		 * path must to be revalidated. */
5641fcf6b1b7SDmitry Monakhov 		if (split)
5642fcf6b1b7SDmitry Monakhov 			goto repeat;
5643fcf6b1b7SDmitry Monakhov 
5644fcf6b1b7SDmitry Monakhov 		BUG_ON(e2_len != e1_len);
5645fcf6b1b7SDmitry Monakhov 		*erp = ext4_ext_get_access(handle, inode1, path1 + path1->p_depth);
564619008f6dSTheodore Ts'o 		if (unlikely(*erp))
564719008f6dSTheodore Ts'o 			goto finish;
5648fcf6b1b7SDmitry Monakhov 		*erp = ext4_ext_get_access(handle, inode2, path2 + path2->p_depth);
564919008f6dSTheodore Ts'o 		if (unlikely(*erp))
565019008f6dSTheodore Ts'o 			goto finish;
5651fcf6b1b7SDmitry Monakhov 
5652fcf6b1b7SDmitry Monakhov 		/* Both extents are fully inside boundaries. Swap it now */
5653fcf6b1b7SDmitry Monakhov 		tmp_ex = *ex1;
5654fcf6b1b7SDmitry Monakhov 		ext4_ext_store_pblock(ex1, ext4_ext_pblock(ex2));
5655fcf6b1b7SDmitry Monakhov 		ext4_ext_store_pblock(ex2, ext4_ext_pblock(&tmp_ex));
5656fcf6b1b7SDmitry Monakhov 		ex1->ee_len = cpu_to_le16(e2_len);
5657fcf6b1b7SDmitry Monakhov 		ex2->ee_len = cpu_to_le16(e1_len);
5658fcf6b1b7SDmitry Monakhov 		if (unwritten)
5659fcf6b1b7SDmitry Monakhov 			ext4_ext_mark_unwritten(ex2);
5660fcf6b1b7SDmitry Monakhov 		if (ext4_ext_is_unwritten(&tmp_ex))
5661fcf6b1b7SDmitry Monakhov 			ext4_ext_mark_unwritten(ex1);
5662fcf6b1b7SDmitry Monakhov 
5663fcf6b1b7SDmitry Monakhov 		ext4_ext_try_to_merge(handle, inode2, path2, ex2);
5664fcf6b1b7SDmitry Monakhov 		ext4_ext_try_to_merge(handle, inode1, path1, ex1);
5665fcf6b1b7SDmitry Monakhov 		*erp = ext4_ext_dirty(handle, inode2, path2 +
5666fcf6b1b7SDmitry Monakhov 				      path2->p_depth);
566719008f6dSTheodore Ts'o 		if (unlikely(*erp))
566819008f6dSTheodore Ts'o 			goto finish;
5669fcf6b1b7SDmitry Monakhov 		*erp = ext4_ext_dirty(handle, inode1, path1 +
5670fcf6b1b7SDmitry Monakhov 				      path1->p_depth);
5671fcf6b1b7SDmitry Monakhov 		/*
5672fcf6b1b7SDmitry Monakhov 		 * Looks scarry ah..? second inode already points to new blocks,
5673fcf6b1b7SDmitry Monakhov 		 * and it was successfully dirtied. But luckily error may happen
5674fcf6b1b7SDmitry Monakhov 		 * only due to journal error, so full transaction will be
5675fcf6b1b7SDmitry Monakhov 		 * aborted anyway.
5676fcf6b1b7SDmitry Monakhov 		 */
567719008f6dSTheodore Ts'o 		if (unlikely(*erp))
567819008f6dSTheodore Ts'o 			goto finish;
5679fcf6b1b7SDmitry Monakhov 		lblk1 += len;
5680fcf6b1b7SDmitry Monakhov 		lblk2 += len;
5681fcf6b1b7SDmitry Monakhov 		replaced_count += len;
5682fcf6b1b7SDmitry Monakhov 		count -= len;
5683fcf6b1b7SDmitry Monakhov 
5684fcf6b1b7SDmitry Monakhov 	repeat:
5685fcf6b1b7SDmitry Monakhov 		ext4_ext_drop_refs(path1);
5686fcf6b1b7SDmitry Monakhov 		kfree(path1);
5687fcf6b1b7SDmitry Monakhov 		ext4_ext_drop_refs(path2);
5688fcf6b1b7SDmitry Monakhov 		kfree(path2);
5689b7ea89adSTheodore Ts'o 		path1 = path2 = NULL;
5690fcf6b1b7SDmitry Monakhov 	}
5691fcf6b1b7SDmitry Monakhov 	return replaced_count;
5692fcf6b1b7SDmitry Monakhov }
56930b02f4c0SEric Whitney 
56940b02f4c0SEric Whitney /*
56950b02f4c0SEric Whitney  * ext4_clu_mapped - determine whether any block in a logical cluster has
56960b02f4c0SEric Whitney  *                   been mapped to a physical cluster
56970b02f4c0SEric Whitney  *
56980b02f4c0SEric Whitney  * @inode - file containing the logical cluster
56990b02f4c0SEric Whitney  * @lclu - logical cluster of interest
57000b02f4c0SEric Whitney  *
57010b02f4c0SEric Whitney  * Returns 1 if any block in the logical cluster is mapped, signifying
57020b02f4c0SEric Whitney  * that a physical cluster has been allocated for it.  Otherwise,
57030b02f4c0SEric Whitney  * returns 0.  Can also return negative error codes.  Derived from
57040b02f4c0SEric Whitney  * ext4_ext_map_blocks().
57050b02f4c0SEric Whitney  */
57060b02f4c0SEric Whitney int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu)
57070b02f4c0SEric Whitney {
57080b02f4c0SEric Whitney 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
57090b02f4c0SEric Whitney 	struct ext4_ext_path *path;
57100b02f4c0SEric Whitney 	int depth, mapped = 0, err = 0;
57110b02f4c0SEric Whitney 	struct ext4_extent *extent;
57120b02f4c0SEric Whitney 	ext4_lblk_t first_lblk, first_lclu, last_lclu;
57130b02f4c0SEric Whitney 
57140b02f4c0SEric Whitney 	/* search for the extent closest to the first block in the cluster */
57150b02f4c0SEric Whitney 	path = ext4_find_extent(inode, EXT4_C2B(sbi, lclu), NULL, 0);
57160b02f4c0SEric Whitney 	if (IS_ERR(path)) {
57170b02f4c0SEric Whitney 		err = PTR_ERR(path);
57180b02f4c0SEric Whitney 		path = NULL;
57190b02f4c0SEric Whitney 		goto out;
57200b02f4c0SEric Whitney 	}
57210b02f4c0SEric Whitney 
57220b02f4c0SEric Whitney 	depth = ext_depth(inode);
57230b02f4c0SEric Whitney 
57240b02f4c0SEric Whitney 	/*
57250b02f4c0SEric Whitney 	 * A consistent leaf must not be empty.  This situation is possible,
57260b02f4c0SEric Whitney 	 * though, _during_ tree modification, and it's why an assert can't
57270b02f4c0SEric Whitney 	 * be put in ext4_find_extent().
57280b02f4c0SEric Whitney 	 */
57290b02f4c0SEric Whitney 	if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
57300b02f4c0SEric Whitney 		EXT4_ERROR_INODE(inode,
57310b02f4c0SEric Whitney 		    "bad extent address - lblock: %lu, depth: %d, pblock: %lld",
57320b02f4c0SEric Whitney 				 (unsigned long) EXT4_C2B(sbi, lclu),
57330b02f4c0SEric Whitney 				 depth, path[depth].p_block);
57340b02f4c0SEric Whitney 		err = -EFSCORRUPTED;
57350b02f4c0SEric Whitney 		goto out;
57360b02f4c0SEric Whitney 	}
57370b02f4c0SEric Whitney 
57380b02f4c0SEric Whitney 	extent = path[depth].p_ext;
57390b02f4c0SEric Whitney 
57400b02f4c0SEric Whitney 	/* can't be mapped if the extent tree is empty */
57410b02f4c0SEric Whitney 	if (extent == NULL)
57420b02f4c0SEric Whitney 		goto out;
57430b02f4c0SEric Whitney 
57440b02f4c0SEric Whitney 	first_lblk = le32_to_cpu(extent->ee_block);
57450b02f4c0SEric Whitney 	first_lclu = EXT4_B2C(sbi, first_lblk);
57460b02f4c0SEric Whitney 
57470b02f4c0SEric Whitney 	/*
57480b02f4c0SEric Whitney 	 * Three possible outcomes at this point - found extent spanning
57490b02f4c0SEric Whitney 	 * the target cluster, to the left of the target cluster, or to the
57500b02f4c0SEric Whitney 	 * right of the target cluster.  The first two cases are handled here.
57510b02f4c0SEric Whitney 	 * The last case indicates the target cluster is not mapped.
57520b02f4c0SEric Whitney 	 */
57530b02f4c0SEric Whitney 	if (lclu >= first_lclu) {
57540b02f4c0SEric Whitney 		last_lclu = EXT4_B2C(sbi, first_lblk +
57550b02f4c0SEric Whitney 				     ext4_ext_get_actual_len(extent) - 1);
57560b02f4c0SEric Whitney 		if (lclu <= last_lclu) {
57570b02f4c0SEric Whitney 			mapped = 1;
57580b02f4c0SEric Whitney 		} else {
57590b02f4c0SEric Whitney 			first_lblk = ext4_ext_next_allocated_block(path);
57600b02f4c0SEric Whitney 			first_lclu = EXT4_B2C(sbi, first_lblk);
57610b02f4c0SEric Whitney 			if (lclu == first_lclu)
57620b02f4c0SEric Whitney 				mapped = 1;
57630b02f4c0SEric Whitney 		}
57640b02f4c0SEric Whitney 	}
57650b02f4c0SEric Whitney 
57660b02f4c0SEric Whitney out:
57670b02f4c0SEric Whitney 	ext4_ext_drop_refs(path);
57680b02f4c0SEric Whitney 	kfree(path);
57690b02f4c0SEric Whitney 
57700b02f4c0SEric Whitney 	return err ? err : mapped;
57710b02f4c0SEric Whitney }
5772