xref: /openbmc/linux/fs/ext4/extents.c (revision f85b287a01237857a50c93868231f7e831581a27)
1a86c6181SAlex Tomas /*
2a86c6181SAlex Tomas  * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
3a86c6181SAlex Tomas  * Written by Alex Tomas <alex@clusterfs.com>
4a86c6181SAlex Tomas  *
5a86c6181SAlex Tomas  * Architecture independence:
6a86c6181SAlex Tomas  *   Copyright (c) 2005, Bull S.A.
7a86c6181SAlex Tomas  *   Written by Pierre Peiffer <pierre.peiffer@bull.net>
8a86c6181SAlex Tomas  *
9a86c6181SAlex Tomas  * This program is free software; you can redistribute it and/or modify
10a86c6181SAlex Tomas  * it under the terms of the GNU General Public License version 2 as
11a86c6181SAlex Tomas  * published by the Free Software Foundation.
12a86c6181SAlex Tomas  *
13a86c6181SAlex Tomas  * This program is distributed in the hope that it will be useful,
14a86c6181SAlex Tomas  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15a86c6181SAlex Tomas  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16a86c6181SAlex Tomas  * GNU General Public License for more details.
17a86c6181SAlex Tomas  *
18a86c6181SAlex Tomas  * You should have received a copy of the GNU General Public Licens
19a86c6181SAlex Tomas  * along with this program; if not, write to the Free Software
20a86c6181SAlex Tomas  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
21a86c6181SAlex Tomas  */
22a86c6181SAlex Tomas 
23a86c6181SAlex Tomas /*
24a86c6181SAlex Tomas  * Extents support for EXT4
25a86c6181SAlex Tomas  *
26a86c6181SAlex Tomas  * TODO:
27a86c6181SAlex Tomas  *   - ext4*_error() should be used in some situations
28a86c6181SAlex Tomas  *   - analyze all BUG()/BUG_ON(), use -EIO where appropriate
29a86c6181SAlex Tomas  *   - smart tree reduction
30a86c6181SAlex Tomas  */
31a86c6181SAlex Tomas 
32a86c6181SAlex Tomas #include <linux/module.h>
33a86c6181SAlex Tomas #include <linux/fs.h>
34a86c6181SAlex Tomas #include <linux/time.h>
35cd02ff0bSMingming Cao #include <linux/jbd2.h>
36a86c6181SAlex Tomas #include <linux/highuid.h>
37a86c6181SAlex Tomas #include <linux/pagemap.h>
38a86c6181SAlex Tomas #include <linux/quotaops.h>
39a86c6181SAlex Tomas #include <linux/string.h>
40a86c6181SAlex Tomas #include <linux/slab.h>
41a2df2a63SAmit Arora #include <linux/falloc.h>
42a86c6181SAlex Tomas #include <asm/uaccess.h>
436873fa0dSEric Sandeen #include <linux/fiemap.h>
443dcf5451SChristoph Hellwig #include "ext4_jbd2.h"
45a86c6181SAlex Tomas 
460562e0baSJiaying Zhang #include <trace/events/ext4.h>
470562e0baSJiaying Zhang 
48d583fb87SAllison Henderson static int ext4_split_extent(handle_t *handle,
49d583fb87SAllison Henderson 				struct inode *inode,
50d583fb87SAllison Henderson 				struct ext4_ext_path *path,
51d583fb87SAllison Henderson 				struct ext4_map_blocks *map,
52d583fb87SAllison Henderson 				int split_flag,
53d583fb87SAllison Henderson 				int flags);
54d583fb87SAllison Henderson 
55487caeefSJan Kara static int ext4_ext_truncate_extend_restart(handle_t *handle,
56487caeefSJan Kara 					    struct inode *inode,
57487caeefSJan Kara 					    int needed)
58a86c6181SAlex Tomas {
59a86c6181SAlex Tomas 	int err;
60a86c6181SAlex Tomas 
610390131bSFrank Mayhar 	if (!ext4_handle_valid(handle))
620390131bSFrank Mayhar 		return 0;
63a86c6181SAlex Tomas 	if (handle->h_buffer_credits > needed)
649102e4faSShen Feng 		return 0;
659102e4faSShen Feng 	err = ext4_journal_extend(handle, needed);
660123c939STheodore Ts'o 	if (err <= 0)
679102e4faSShen Feng 		return err;
68487caeefSJan Kara 	err = ext4_truncate_restart_trans(handle, inode, needed);
690617b83fSDmitry Monakhov 	if (err == 0)
700617b83fSDmitry Monakhov 		err = -EAGAIN;
71487caeefSJan Kara 
72487caeefSJan Kara 	return err;
73a86c6181SAlex Tomas }
74a86c6181SAlex Tomas 
75a86c6181SAlex Tomas /*
76a86c6181SAlex Tomas  * could return:
77a86c6181SAlex Tomas  *  - EROFS
78a86c6181SAlex Tomas  *  - ENOMEM
79a86c6181SAlex Tomas  */
80a86c6181SAlex Tomas static int ext4_ext_get_access(handle_t *handle, struct inode *inode,
81a86c6181SAlex Tomas 				struct ext4_ext_path *path)
82a86c6181SAlex Tomas {
83a86c6181SAlex Tomas 	if (path->p_bh) {
84a86c6181SAlex Tomas 		/* path points to block */
85a86c6181SAlex Tomas 		return ext4_journal_get_write_access(handle, path->p_bh);
86a86c6181SAlex Tomas 	}
87a86c6181SAlex Tomas 	/* path points to leaf/index in inode body */
88a86c6181SAlex Tomas 	/* we use in-core data, no need to protect them */
89a86c6181SAlex Tomas 	return 0;
90a86c6181SAlex Tomas }
91a86c6181SAlex Tomas 
92a86c6181SAlex Tomas /*
93a86c6181SAlex Tomas  * could return:
94a86c6181SAlex Tomas  *  - EROFS
95a86c6181SAlex Tomas  *  - ENOMEM
96a86c6181SAlex Tomas  *  - EIO
97a86c6181SAlex Tomas  */
989ea7a0dfSTheodore Ts'o #define ext4_ext_dirty(handle, inode, path) \
999ea7a0dfSTheodore Ts'o 		__ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path))
1009ea7a0dfSTheodore Ts'o static int __ext4_ext_dirty(const char *where, unsigned int line,
1019ea7a0dfSTheodore Ts'o 			    handle_t *handle, struct inode *inode,
102a86c6181SAlex Tomas 			    struct ext4_ext_path *path)
103a86c6181SAlex Tomas {
104a86c6181SAlex Tomas 	int err;
105a86c6181SAlex Tomas 	if (path->p_bh) {
106a86c6181SAlex Tomas 		/* path points to block */
1079ea7a0dfSTheodore Ts'o 		err = __ext4_handle_dirty_metadata(where, line, handle,
1089ea7a0dfSTheodore Ts'o 						   inode, path->p_bh);
109a86c6181SAlex Tomas 	} else {
110a86c6181SAlex Tomas 		/* path points to leaf/index in inode body */
111a86c6181SAlex Tomas 		err = ext4_mark_inode_dirty(handle, inode);
112a86c6181SAlex Tomas 	}
113a86c6181SAlex Tomas 	return err;
114a86c6181SAlex Tomas }
115a86c6181SAlex Tomas 
116f65e6fbaSAlex Tomas static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
117a86c6181SAlex Tomas 			      struct ext4_ext_path *path,
118725d26d3SAneesh Kumar K.V 			      ext4_lblk_t block)
119a86c6181SAlex Tomas {
120a86c6181SAlex Tomas 	int depth;
121a86c6181SAlex Tomas 
122a86c6181SAlex Tomas 	if (path) {
123a86c6181SAlex Tomas 		struct ext4_extent *ex;
124a86c6181SAlex Tomas 		depth = path->p_depth;
125a86c6181SAlex Tomas 
126ad4fb9caSKazuya Mio 		/*
127ad4fb9caSKazuya Mio 		 * Try to predict block placement assuming that we are
128ad4fb9caSKazuya Mio 		 * filling in a file which will eventually be
129ad4fb9caSKazuya Mio 		 * non-sparse --- i.e., in the case of libbfd writing
130ad4fb9caSKazuya Mio 		 * an ELF object sections out-of-order but in a way
131ad4fb9caSKazuya Mio 		 * the eventually results in a contiguous object or
132ad4fb9caSKazuya Mio 		 * executable file, or some database extending a table
133ad4fb9caSKazuya Mio 		 * space file.  However, this is actually somewhat
134ad4fb9caSKazuya Mio 		 * non-ideal if we are writing a sparse file such as
135ad4fb9caSKazuya Mio 		 * qemu or KVM writing a raw image file that is going
136ad4fb9caSKazuya Mio 		 * to stay fairly sparse, since it will end up
137ad4fb9caSKazuya Mio 		 * fragmenting the file system's free space.  Maybe we
138ad4fb9caSKazuya Mio 		 * should have some hueristics or some way to allow
139ad4fb9caSKazuya Mio 		 * userspace to pass a hint to file system,
140b8d6568aSTao Ma 		 * especially if the latter case turns out to be
141ad4fb9caSKazuya Mio 		 * common.
142ad4fb9caSKazuya Mio 		 */
1437e028976SAvantika Mathur 		ex = path[depth].p_ext;
144ad4fb9caSKazuya Mio 		if (ex) {
145ad4fb9caSKazuya Mio 			ext4_fsblk_t ext_pblk = ext4_ext_pblock(ex);
146ad4fb9caSKazuya Mio 			ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block);
147ad4fb9caSKazuya Mio 
148ad4fb9caSKazuya Mio 			if (block > ext_block)
149ad4fb9caSKazuya Mio 				return ext_pblk + (block - ext_block);
150ad4fb9caSKazuya Mio 			else
151ad4fb9caSKazuya Mio 				return ext_pblk - (ext_block - block);
152ad4fb9caSKazuya Mio 		}
153a86c6181SAlex Tomas 
154d0d856e8SRandy Dunlap 		/* it looks like index is empty;
155d0d856e8SRandy Dunlap 		 * try to find starting block from index itself */
156a86c6181SAlex Tomas 		if (path[depth].p_bh)
157a86c6181SAlex Tomas 			return path[depth].p_bh->b_blocknr;
158a86c6181SAlex Tomas 	}
159a86c6181SAlex Tomas 
160a86c6181SAlex Tomas 	/* OK. use inode's group */
161f86186b4SEric Sandeen 	return ext4_inode_to_goal_block(inode);
162a86c6181SAlex Tomas }
163a86c6181SAlex Tomas 
164654b4908SAneesh Kumar K.V /*
165654b4908SAneesh Kumar K.V  * Allocation for a meta data block
166654b4908SAneesh Kumar K.V  */
167f65e6fbaSAlex Tomas static ext4_fsblk_t
168654b4908SAneesh Kumar K.V ext4_ext_new_meta_block(handle_t *handle, struct inode *inode,
169a86c6181SAlex Tomas 			struct ext4_ext_path *path,
17055f020dbSAllison Henderson 			struct ext4_extent *ex, int *err, unsigned int flags)
171a86c6181SAlex Tomas {
172f65e6fbaSAlex Tomas 	ext4_fsblk_t goal, newblock;
173a86c6181SAlex Tomas 
174a86c6181SAlex Tomas 	goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
17555f020dbSAllison Henderson 	newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
17655f020dbSAllison Henderson 					NULL, err);
177a86c6181SAlex Tomas 	return newblock;
178a86c6181SAlex Tomas }
179a86c6181SAlex Tomas 
18055ad63bfSTheodore Ts'o static inline int ext4_ext_space_block(struct inode *inode, int check)
181a86c6181SAlex Tomas {
182a86c6181SAlex Tomas 	int size;
183a86c6181SAlex Tomas 
184a86c6181SAlex Tomas 	size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
185a86c6181SAlex Tomas 			/ sizeof(struct ext4_extent);
18655ad63bfSTheodore Ts'o 	if (!check) {
187bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
188a86c6181SAlex Tomas 		if (size > 6)
189a86c6181SAlex Tomas 			size = 6;
190a86c6181SAlex Tomas #endif
19155ad63bfSTheodore Ts'o 	}
192a86c6181SAlex Tomas 	return size;
193a86c6181SAlex Tomas }
194a86c6181SAlex Tomas 
19555ad63bfSTheodore Ts'o static inline int ext4_ext_space_block_idx(struct inode *inode, int check)
196a86c6181SAlex Tomas {
197a86c6181SAlex Tomas 	int size;
198a86c6181SAlex Tomas 
199a86c6181SAlex Tomas 	size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
200a86c6181SAlex Tomas 			/ sizeof(struct ext4_extent_idx);
20155ad63bfSTheodore Ts'o 	if (!check) {
202bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
203a86c6181SAlex Tomas 		if (size > 5)
204a86c6181SAlex Tomas 			size = 5;
205a86c6181SAlex Tomas #endif
20655ad63bfSTheodore Ts'o 	}
207a86c6181SAlex Tomas 	return size;
208a86c6181SAlex Tomas }
209a86c6181SAlex Tomas 
21055ad63bfSTheodore Ts'o static inline int ext4_ext_space_root(struct inode *inode, int check)
211a86c6181SAlex Tomas {
212a86c6181SAlex Tomas 	int size;
213a86c6181SAlex Tomas 
214a86c6181SAlex Tomas 	size = sizeof(EXT4_I(inode)->i_data);
215a86c6181SAlex Tomas 	size -= sizeof(struct ext4_extent_header);
216a86c6181SAlex Tomas 	size /= sizeof(struct ext4_extent);
21755ad63bfSTheodore Ts'o 	if (!check) {
218bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
219a86c6181SAlex Tomas 		if (size > 3)
220a86c6181SAlex Tomas 			size = 3;
221a86c6181SAlex Tomas #endif
22255ad63bfSTheodore Ts'o 	}
223a86c6181SAlex Tomas 	return size;
224a86c6181SAlex Tomas }
225a86c6181SAlex Tomas 
22655ad63bfSTheodore Ts'o static inline int ext4_ext_space_root_idx(struct inode *inode, int check)
227a86c6181SAlex Tomas {
228a86c6181SAlex Tomas 	int size;
229a86c6181SAlex Tomas 
230a86c6181SAlex Tomas 	size = sizeof(EXT4_I(inode)->i_data);
231a86c6181SAlex Tomas 	size -= sizeof(struct ext4_extent_header);
232a86c6181SAlex Tomas 	size /= sizeof(struct ext4_extent_idx);
23355ad63bfSTheodore Ts'o 	if (!check) {
234bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
235a86c6181SAlex Tomas 		if (size > 4)
236a86c6181SAlex Tomas 			size = 4;
237a86c6181SAlex Tomas #endif
23855ad63bfSTheodore Ts'o 	}
239a86c6181SAlex Tomas 	return size;
240a86c6181SAlex Tomas }
241a86c6181SAlex Tomas 
242d2a17637SMingming Cao /*
243d2a17637SMingming Cao  * Calculate the number of metadata blocks needed
244d2a17637SMingming Cao  * to allocate @blocks
245d2a17637SMingming Cao  * Worse case is one block per extent
246d2a17637SMingming Cao  */
24701f49d0bSTheodore Ts'o int ext4_ext_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock)
248d2a17637SMingming Cao {
2499d0be502STheodore Ts'o 	struct ext4_inode_info *ei = EXT4_I(inode);
2509d0be502STheodore Ts'o 	int idxs, num = 0;
251d2a17637SMingming Cao 
2529d0be502STheodore Ts'o 	idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
2539d0be502STheodore Ts'o 		/ sizeof(struct ext4_extent_idx));
254d2a17637SMingming Cao 
255d2a17637SMingming Cao 	/*
2569d0be502STheodore Ts'o 	 * If the new delayed allocation block is contiguous with the
2579d0be502STheodore Ts'o 	 * previous da block, it can share index blocks with the
2589d0be502STheodore Ts'o 	 * previous block, so we only need to allocate a new index
2599d0be502STheodore Ts'o 	 * block every idxs leaf blocks.  At ldxs**2 blocks, we need
2609d0be502STheodore Ts'o 	 * an additional index block, and at ldxs**3 blocks, yet
2619d0be502STheodore Ts'o 	 * another index blocks.
262d2a17637SMingming Cao 	 */
2639d0be502STheodore Ts'o 	if (ei->i_da_metadata_calc_len &&
2649d0be502STheodore Ts'o 	    ei->i_da_metadata_calc_last_lblock+1 == lblock) {
2659d0be502STheodore Ts'o 		if ((ei->i_da_metadata_calc_len % idxs) == 0)
2669d0be502STheodore Ts'o 			num++;
2679d0be502STheodore Ts'o 		if ((ei->i_da_metadata_calc_len % (idxs*idxs)) == 0)
2689d0be502STheodore Ts'o 			num++;
2699d0be502STheodore Ts'o 		if ((ei->i_da_metadata_calc_len % (idxs*idxs*idxs)) == 0) {
2709d0be502STheodore Ts'o 			num++;
2719d0be502STheodore Ts'o 			ei->i_da_metadata_calc_len = 0;
2729d0be502STheodore Ts'o 		} else
2739d0be502STheodore Ts'o 			ei->i_da_metadata_calc_len++;
2749d0be502STheodore Ts'o 		ei->i_da_metadata_calc_last_lblock++;
275d2a17637SMingming Cao 		return num;
276d2a17637SMingming Cao 	}
277d2a17637SMingming Cao 
2789d0be502STheodore Ts'o 	/*
2799d0be502STheodore Ts'o 	 * In the worst case we need a new set of index blocks at
2809d0be502STheodore Ts'o 	 * every level of the inode's extent tree.
2819d0be502STheodore Ts'o 	 */
2829d0be502STheodore Ts'o 	ei->i_da_metadata_calc_len = 1;
2839d0be502STheodore Ts'o 	ei->i_da_metadata_calc_last_lblock = lblock;
2849d0be502STheodore Ts'o 	return ext_depth(inode) + 1;
2859d0be502STheodore Ts'o }
2869d0be502STheodore Ts'o 
287c29c0ae7SAlex Tomas static int
288c29c0ae7SAlex Tomas ext4_ext_max_entries(struct inode *inode, int depth)
289c29c0ae7SAlex Tomas {
290c29c0ae7SAlex Tomas 	int max;
291c29c0ae7SAlex Tomas 
292c29c0ae7SAlex Tomas 	if (depth == ext_depth(inode)) {
293c29c0ae7SAlex Tomas 		if (depth == 0)
29455ad63bfSTheodore Ts'o 			max = ext4_ext_space_root(inode, 1);
295c29c0ae7SAlex Tomas 		else
29655ad63bfSTheodore Ts'o 			max = ext4_ext_space_root_idx(inode, 1);
297c29c0ae7SAlex Tomas 	} else {
298c29c0ae7SAlex Tomas 		if (depth == 0)
29955ad63bfSTheodore Ts'o 			max = ext4_ext_space_block(inode, 1);
300c29c0ae7SAlex Tomas 		else
30155ad63bfSTheodore Ts'o 			max = ext4_ext_space_block_idx(inode, 1);
302c29c0ae7SAlex Tomas 	}
303c29c0ae7SAlex Tomas 
304c29c0ae7SAlex Tomas 	return max;
305c29c0ae7SAlex Tomas }
306c29c0ae7SAlex Tomas 
30756b19868SAneesh Kumar K.V static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
30856b19868SAneesh Kumar K.V {
309bf89d16fSTheodore Ts'o 	ext4_fsblk_t block = ext4_ext_pblock(ext);
31056b19868SAneesh Kumar K.V 	int len = ext4_ext_get_actual_len(ext);
311e84a26ceSTheodore Ts'o 
3126fd058f7STheodore Ts'o 	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);
31356b19868SAneesh Kumar K.V }
31456b19868SAneesh Kumar K.V 
31556b19868SAneesh Kumar K.V static int ext4_valid_extent_idx(struct inode *inode,
31656b19868SAneesh Kumar K.V 				struct ext4_extent_idx *ext_idx)
31756b19868SAneesh Kumar K.V {
318bf89d16fSTheodore Ts'o 	ext4_fsblk_t block = ext4_idx_pblock(ext_idx);
319e84a26ceSTheodore Ts'o 
3206fd058f7STheodore Ts'o 	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);
32156b19868SAneesh Kumar K.V }
32256b19868SAneesh Kumar K.V 
32356b19868SAneesh Kumar K.V static int ext4_valid_extent_entries(struct inode *inode,
32456b19868SAneesh Kumar K.V 				struct ext4_extent_header *eh,
32556b19868SAneesh Kumar K.V 				int depth)
32656b19868SAneesh Kumar K.V {
32756b19868SAneesh Kumar K.V 	struct ext4_extent *ext;
32856b19868SAneesh Kumar K.V 	struct ext4_extent_idx *ext_idx;
32956b19868SAneesh Kumar K.V 	unsigned short entries;
33056b19868SAneesh Kumar K.V 	if (eh->eh_entries == 0)
33156b19868SAneesh Kumar K.V 		return 1;
33256b19868SAneesh Kumar K.V 
33356b19868SAneesh Kumar K.V 	entries = le16_to_cpu(eh->eh_entries);
33456b19868SAneesh Kumar K.V 
33556b19868SAneesh Kumar K.V 	if (depth == 0) {
33656b19868SAneesh Kumar K.V 		/* leaf entries */
33756b19868SAneesh Kumar K.V 		ext = EXT_FIRST_EXTENT(eh);
33856b19868SAneesh Kumar K.V 		while (entries) {
33956b19868SAneesh Kumar K.V 			if (!ext4_valid_extent(inode, ext))
34056b19868SAneesh Kumar K.V 				return 0;
34156b19868SAneesh Kumar K.V 			ext++;
34256b19868SAneesh Kumar K.V 			entries--;
34356b19868SAneesh Kumar K.V 		}
34456b19868SAneesh Kumar K.V 	} else {
34556b19868SAneesh Kumar K.V 		ext_idx = EXT_FIRST_INDEX(eh);
34656b19868SAneesh Kumar K.V 		while (entries) {
34756b19868SAneesh Kumar K.V 			if (!ext4_valid_extent_idx(inode, ext_idx))
34856b19868SAneesh Kumar K.V 				return 0;
34956b19868SAneesh Kumar K.V 			ext_idx++;
35056b19868SAneesh Kumar K.V 			entries--;
35156b19868SAneesh Kumar K.V 		}
35256b19868SAneesh Kumar K.V 	}
35356b19868SAneesh Kumar K.V 	return 1;
35456b19868SAneesh Kumar K.V }
35556b19868SAneesh Kumar K.V 
356c398eda0STheodore Ts'o static int __ext4_ext_check(const char *function, unsigned int line,
357c398eda0STheodore Ts'o 			    struct inode *inode, struct ext4_extent_header *eh,
358c29c0ae7SAlex Tomas 			    int depth)
359c29c0ae7SAlex Tomas {
360c29c0ae7SAlex Tomas 	const char *error_msg;
361c29c0ae7SAlex Tomas 	int max = 0;
362c29c0ae7SAlex Tomas 
363c29c0ae7SAlex Tomas 	if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) {
364c29c0ae7SAlex Tomas 		error_msg = "invalid magic";
365c29c0ae7SAlex Tomas 		goto corrupted;
366c29c0ae7SAlex Tomas 	}
367c29c0ae7SAlex Tomas 	if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {
368c29c0ae7SAlex Tomas 		error_msg = "unexpected eh_depth";
369c29c0ae7SAlex Tomas 		goto corrupted;
370c29c0ae7SAlex Tomas 	}
371c29c0ae7SAlex Tomas 	if (unlikely(eh->eh_max == 0)) {
372c29c0ae7SAlex Tomas 		error_msg = "invalid eh_max";
373c29c0ae7SAlex Tomas 		goto corrupted;
374c29c0ae7SAlex Tomas 	}
375c29c0ae7SAlex Tomas 	max = ext4_ext_max_entries(inode, depth);
376c29c0ae7SAlex Tomas 	if (unlikely(le16_to_cpu(eh->eh_max) > max)) {
377c29c0ae7SAlex Tomas 		error_msg = "too large eh_max";
378c29c0ae7SAlex Tomas 		goto corrupted;
379c29c0ae7SAlex Tomas 	}
380c29c0ae7SAlex Tomas 	if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) {
381c29c0ae7SAlex Tomas 		error_msg = "invalid eh_entries";
382c29c0ae7SAlex Tomas 		goto corrupted;
383c29c0ae7SAlex Tomas 	}
38456b19868SAneesh Kumar K.V 	if (!ext4_valid_extent_entries(inode, eh, depth)) {
38556b19868SAneesh Kumar K.V 		error_msg = "invalid extent entries";
38656b19868SAneesh Kumar K.V 		goto corrupted;
38756b19868SAneesh Kumar K.V 	}
388c29c0ae7SAlex Tomas 	return 0;
389c29c0ae7SAlex Tomas 
390c29c0ae7SAlex Tomas corrupted:
391c398eda0STheodore Ts'o 	ext4_error_inode(inode, function, line, 0,
39224676da4STheodore Ts'o 			"bad header/extent: %s - magic %x, "
393c29c0ae7SAlex Tomas 			"entries %u, max %u(%u), depth %u(%u)",
39424676da4STheodore Ts'o 			error_msg, le16_to_cpu(eh->eh_magic),
395c29c0ae7SAlex Tomas 			le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max),
396c29c0ae7SAlex Tomas 			max, le16_to_cpu(eh->eh_depth), depth);
397c29c0ae7SAlex Tomas 
398c29c0ae7SAlex Tomas 	return -EIO;
399c29c0ae7SAlex Tomas }
400c29c0ae7SAlex Tomas 
40156b19868SAneesh Kumar K.V #define ext4_ext_check(inode, eh, depth)	\
402c398eda0STheodore Ts'o 	__ext4_ext_check(__func__, __LINE__, inode, eh, depth)
403c29c0ae7SAlex Tomas 
4047a262f7cSAneesh Kumar K.V int ext4_ext_check_inode(struct inode *inode)
4057a262f7cSAneesh Kumar K.V {
4067a262f7cSAneesh Kumar K.V 	return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode));
4077a262f7cSAneesh Kumar K.V }
4087a262f7cSAneesh Kumar K.V 
409a86c6181SAlex Tomas #ifdef EXT_DEBUG
410a86c6181SAlex Tomas static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
411a86c6181SAlex Tomas {
412a86c6181SAlex Tomas 	int k, l = path->p_depth;
413a86c6181SAlex Tomas 
414a86c6181SAlex Tomas 	ext_debug("path:");
415a86c6181SAlex Tomas 	for (k = 0; k <= l; k++, path++) {
416a86c6181SAlex Tomas 		if (path->p_idx) {
4172ae02107SMingming Cao 		  ext_debug("  %d->%llu", le32_to_cpu(path->p_idx->ei_block),
418bf89d16fSTheodore Ts'o 			    ext4_idx_pblock(path->p_idx));
419a86c6181SAlex Tomas 		} else if (path->p_ext) {
420553f9008SMingming 			ext_debug("  %d:[%d]%d:%llu ",
421a86c6181SAlex Tomas 				  le32_to_cpu(path->p_ext->ee_block),
422553f9008SMingming 				  ext4_ext_is_uninitialized(path->p_ext),
423a2df2a63SAmit Arora 				  ext4_ext_get_actual_len(path->p_ext),
424bf89d16fSTheodore Ts'o 				  ext4_ext_pblock(path->p_ext));
425a86c6181SAlex Tomas 		} else
426a86c6181SAlex Tomas 			ext_debug("  []");
427a86c6181SAlex Tomas 	}
428a86c6181SAlex Tomas 	ext_debug("\n");
429a86c6181SAlex Tomas }
430a86c6181SAlex Tomas 
431a86c6181SAlex Tomas static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
432a86c6181SAlex Tomas {
433a86c6181SAlex Tomas 	int depth = ext_depth(inode);
434a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
435a86c6181SAlex Tomas 	struct ext4_extent *ex;
436a86c6181SAlex Tomas 	int i;
437a86c6181SAlex Tomas 
438a86c6181SAlex Tomas 	if (!path)
439a86c6181SAlex Tomas 		return;
440a86c6181SAlex Tomas 
441a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
442a86c6181SAlex Tomas 	ex = EXT_FIRST_EXTENT(eh);
443a86c6181SAlex Tomas 
444553f9008SMingming 	ext_debug("Displaying leaf extents for inode %lu\n", inode->i_ino);
445553f9008SMingming 
446a86c6181SAlex Tomas 	for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) {
447553f9008SMingming 		ext_debug("%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),
448553f9008SMingming 			  ext4_ext_is_uninitialized(ex),
449bf89d16fSTheodore Ts'o 			  ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex));
450a86c6181SAlex Tomas 	}
451a86c6181SAlex Tomas 	ext_debug("\n");
452a86c6181SAlex Tomas }
4531b16da77SYongqiang Yang 
4541b16da77SYongqiang Yang static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path,
4551b16da77SYongqiang Yang 			ext4_fsblk_t newblock, int level)
4561b16da77SYongqiang Yang {
4571b16da77SYongqiang Yang 	int depth = ext_depth(inode);
4581b16da77SYongqiang Yang 	struct ext4_extent *ex;
4591b16da77SYongqiang Yang 
4601b16da77SYongqiang Yang 	if (depth != level) {
4611b16da77SYongqiang Yang 		struct ext4_extent_idx *idx;
4621b16da77SYongqiang Yang 		idx = path[level].p_idx;
4631b16da77SYongqiang Yang 		while (idx <= EXT_MAX_INDEX(path[level].p_hdr)) {
4641b16da77SYongqiang Yang 			ext_debug("%d: move %d:%llu in new index %llu\n", level,
4651b16da77SYongqiang Yang 					le32_to_cpu(idx->ei_block),
4661b16da77SYongqiang Yang 					ext4_idx_pblock(idx),
4671b16da77SYongqiang Yang 					newblock);
4681b16da77SYongqiang Yang 			idx++;
4691b16da77SYongqiang Yang 		}
4701b16da77SYongqiang Yang 
4711b16da77SYongqiang Yang 		return;
4721b16da77SYongqiang Yang 	}
4731b16da77SYongqiang Yang 
4741b16da77SYongqiang Yang 	ex = path[depth].p_ext;
4751b16da77SYongqiang Yang 	while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) {
4761b16da77SYongqiang Yang 		ext_debug("move %d:%llu:[%d]%d in new leaf %llu\n",
4771b16da77SYongqiang Yang 				le32_to_cpu(ex->ee_block),
4781b16da77SYongqiang Yang 				ext4_ext_pblock(ex),
4791b16da77SYongqiang Yang 				ext4_ext_is_uninitialized(ex),
4801b16da77SYongqiang Yang 				ext4_ext_get_actual_len(ex),
4811b16da77SYongqiang Yang 				newblock);
4821b16da77SYongqiang Yang 		ex++;
4831b16da77SYongqiang Yang 	}
4841b16da77SYongqiang Yang }
4851b16da77SYongqiang Yang 
486a86c6181SAlex Tomas #else
487a86c6181SAlex Tomas #define ext4_ext_show_path(inode, path)
488a86c6181SAlex Tomas #define ext4_ext_show_leaf(inode, path)
4891b16da77SYongqiang Yang #define ext4_ext_show_move(inode, path, newblock, level)
490a86c6181SAlex Tomas #endif
491a86c6181SAlex Tomas 
492b35905c1SAneesh Kumar K.V void ext4_ext_drop_refs(struct ext4_ext_path *path)
493a86c6181SAlex Tomas {
494a86c6181SAlex Tomas 	int depth = path->p_depth;
495a86c6181SAlex Tomas 	int i;
496a86c6181SAlex Tomas 
497a86c6181SAlex Tomas 	for (i = 0; i <= depth; i++, path++)
498a86c6181SAlex Tomas 		if (path->p_bh) {
499a86c6181SAlex Tomas 			brelse(path->p_bh);
500a86c6181SAlex Tomas 			path->p_bh = NULL;
501a86c6181SAlex Tomas 		}
502a86c6181SAlex Tomas }
503a86c6181SAlex Tomas 
504a86c6181SAlex Tomas /*
505d0d856e8SRandy Dunlap  * ext4_ext_binsearch_idx:
506d0d856e8SRandy Dunlap  * binary search for the closest index of the given block
507c29c0ae7SAlex Tomas  * the header must be checked before calling this
508a86c6181SAlex Tomas  */
509a86c6181SAlex Tomas static void
510725d26d3SAneesh Kumar K.V ext4_ext_binsearch_idx(struct inode *inode,
511725d26d3SAneesh Kumar K.V 			struct ext4_ext_path *path, ext4_lblk_t block)
512a86c6181SAlex Tomas {
513a86c6181SAlex Tomas 	struct ext4_extent_header *eh = path->p_hdr;
514a86c6181SAlex Tomas 	struct ext4_extent_idx *r, *l, *m;
515a86c6181SAlex Tomas 
516a86c6181SAlex Tomas 
517bba90743SEric Sandeen 	ext_debug("binsearch for %u(idx):  ", block);
518a86c6181SAlex Tomas 
519a86c6181SAlex Tomas 	l = EXT_FIRST_INDEX(eh) + 1;
520e9f410b1SDmitry Monakhov 	r = EXT_LAST_INDEX(eh);
521a86c6181SAlex Tomas 	while (l <= r) {
522a86c6181SAlex Tomas 		m = l + (r - l) / 2;
523a86c6181SAlex Tomas 		if (block < le32_to_cpu(m->ei_block))
524a86c6181SAlex Tomas 			r = m - 1;
525a86c6181SAlex Tomas 		else
526a86c6181SAlex Tomas 			l = m + 1;
52726d535edSDmitry Monakhov 		ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ei_block),
52826d535edSDmitry Monakhov 				m, le32_to_cpu(m->ei_block),
52926d535edSDmitry Monakhov 				r, le32_to_cpu(r->ei_block));
530a86c6181SAlex Tomas 	}
531a86c6181SAlex Tomas 
532a86c6181SAlex Tomas 	path->p_idx = l - 1;
533f65e6fbaSAlex Tomas 	ext_debug("  -> %d->%lld ", le32_to_cpu(path->p_idx->ei_block),
534bf89d16fSTheodore Ts'o 		  ext4_idx_pblock(path->p_idx));
535a86c6181SAlex Tomas 
536a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH
537a86c6181SAlex Tomas 	{
538a86c6181SAlex Tomas 		struct ext4_extent_idx *chix, *ix;
539a86c6181SAlex Tomas 		int k;
540a86c6181SAlex Tomas 
541a86c6181SAlex Tomas 		chix = ix = EXT_FIRST_INDEX(eh);
542a86c6181SAlex Tomas 		for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {
543a86c6181SAlex Tomas 		  if (k != 0 &&
544a86c6181SAlex Tomas 		      le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) {
5454776004fSTheodore Ts'o 				printk(KERN_DEBUG "k=%d, ix=0x%p, "
5464776004fSTheodore Ts'o 				       "first=0x%p\n", k,
547a86c6181SAlex Tomas 				       ix, EXT_FIRST_INDEX(eh));
5484776004fSTheodore Ts'o 				printk(KERN_DEBUG "%u <= %u\n",
549a86c6181SAlex Tomas 				       le32_to_cpu(ix->ei_block),
550a86c6181SAlex Tomas 				       le32_to_cpu(ix[-1].ei_block));
551a86c6181SAlex Tomas 			}
552a86c6181SAlex Tomas 			BUG_ON(k && le32_to_cpu(ix->ei_block)
553a86c6181SAlex Tomas 					   <= le32_to_cpu(ix[-1].ei_block));
554a86c6181SAlex Tomas 			if (block < le32_to_cpu(ix->ei_block))
555a86c6181SAlex Tomas 				break;
556a86c6181SAlex Tomas 			chix = ix;
557a86c6181SAlex Tomas 		}
558a86c6181SAlex Tomas 		BUG_ON(chix != path->p_idx);
559a86c6181SAlex Tomas 	}
560a86c6181SAlex Tomas #endif
561a86c6181SAlex Tomas 
562a86c6181SAlex Tomas }
563a86c6181SAlex Tomas 
564a86c6181SAlex Tomas /*
565d0d856e8SRandy Dunlap  * ext4_ext_binsearch:
566d0d856e8SRandy Dunlap  * binary search for closest extent of the given block
567c29c0ae7SAlex Tomas  * the header must be checked before calling this
568a86c6181SAlex Tomas  */
569a86c6181SAlex Tomas static void
570725d26d3SAneesh Kumar K.V ext4_ext_binsearch(struct inode *inode,
571725d26d3SAneesh Kumar K.V 		struct ext4_ext_path *path, ext4_lblk_t block)
572a86c6181SAlex Tomas {
573a86c6181SAlex Tomas 	struct ext4_extent_header *eh = path->p_hdr;
574a86c6181SAlex Tomas 	struct ext4_extent *r, *l, *m;
575a86c6181SAlex Tomas 
576a86c6181SAlex Tomas 	if (eh->eh_entries == 0) {
577a86c6181SAlex Tomas 		/*
578d0d856e8SRandy Dunlap 		 * this leaf is empty:
579a86c6181SAlex Tomas 		 * we get such a leaf in split/add case
580a86c6181SAlex Tomas 		 */
581a86c6181SAlex Tomas 		return;
582a86c6181SAlex Tomas 	}
583a86c6181SAlex Tomas 
584bba90743SEric Sandeen 	ext_debug("binsearch for %u:  ", block);
585a86c6181SAlex Tomas 
586a86c6181SAlex Tomas 	l = EXT_FIRST_EXTENT(eh) + 1;
587e9f410b1SDmitry Monakhov 	r = EXT_LAST_EXTENT(eh);
588a86c6181SAlex Tomas 
589a86c6181SAlex Tomas 	while (l <= r) {
590a86c6181SAlex Tomas 		m = l + (r - l) / 2;
591a86c6181SAlex Tomas 		if (block < le32_to_cpu(m->ee_block))
592a86c6181SAlex Tomas 			r = m - 1;
593a86c6181SAlex Tomas 		else
594a86c6181SAlex Tomas 			l = m + 1;
59526d535edSDmitry Monakhov 		ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ee_block),
59626d535edSDmitry Monakhov 				m, le32_to_cpu(m->ee_block),
59726d535edSDmitry Monakhov 				r, le32_to_cpu(r->ee_block));
598a86c6181SAlex Tomas 	}
599a86c6181SAlex Tomas 
600a86c6181SAlex Tomas 	path->p_ext = l - 1;
601553f9008SMingming 	ext_debug("  -> %d:%llu:[%d]%d ",
602a86c6181SAlex Tomas 			le32_to_cpu(path->p_ext->ee_block),
603bf89d16fSTheodore Ts'o 			ext4_ext_pblock(path->p_ext),
604553f9008SMingming 			ext4_ext_is_uninitialized(path->p_ext),
605a2df2a63SAmit Arora 			ext4_ext_get_actual_len(path->p_ext));
606a86c6181SAlex Tomas 
607a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH
608a86c6181SAlex Tomas 	{
609a86c6181SAlex Tomas 		struct ext4_extent *chex, *ex;
610a86c6181SAlex Tomas 		int k;
611a86c6181SAlex Tomas 
612a86c6181SAlex Tomas 		chex = ex = EXT_FIRST_EXTENT(eh);
613a86c6181SAlex Tomas 		for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) {
614a86c6181SAlex Tomas 			BUG_ON(k && le32_to_cpu(ex->ee_block)
615a86c6181SAlex Tomas 					  <= le32_to_cpu(ex[-1].ee_block));
616a86c6181SAlex Tomas 			if (block < le32_to_cpu(ex->ee_block))
617a86c6181SAlex Tomas 				break;
618a86c6181SAlex Tomas 			chex = ex;
619a86c6181SAlex Tomas 		}
620a86c6181SAlex Tomas 		BUG_ON(chex != path->p_ext);
621a86c6181SAlex Tomas 	}
622a86c6181SAlex Tomas #endif
623a86c6181SAlex Tomas 
624a86c6181SAlex Tomas }
625a86c6181SAlex Tomas 
626a86c6181SAlex Tomas int ext4_ext_tree_init(handle_t *handle, struct inode *inode)
627a86c6181SAlex Tomas {
628a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
629a86c6181SAlex Tomas 
630a86c6181SAlex Tomas 	eh = ext_inode_hdr(inode);
631a86c6181SAlex Tomas 	eh->eh_depth = 0;
632a86c6181SAlex Tomas 	eh->eh_entries = 0;
633a86c6181SAlex Tomas 	eh->eh_magic = EXT4_EXT_MAGIC;
63455ad63bfSTheodore Ts'o 	eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
635a86c6181SAlex Tomas 	ext4_mark_inode_dirty(handle, inode);
636a86c6181SAlex Tomas 	ext4_ext_invalidate_cache(inode);
637a86c6181SAlex Tomas 	return 0;
638a86c6181SAlex Tomas }
639a86c6181SAlex Tomas 
640a86c6181SAlex Tomas struct ext4_ext_path *
641725d26d3SAneesh Kumar K.V ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
642725d26d3SAneesh Kumar K.V 					struct ext4_ext_path *path)
643a86c6181SAlex Tomas {
644a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
645a86c6181SAlex Tomas 	struct buffer_head *bh;
646a86c6181SAlex Tomas 	short int depth, i, ppos = 0, alloc = 0;
647a86c6181SAlex Tomas 
648a86c6181SAlex Tomas 	eh = ext_inode_hdr(inode);
649c29c0ae7SAlex Tomas 	depth = ext_depth(inode);
650a86c6181SAlex Tomas 
651a86c6181SAlex Tomas 	/* account possible depth increase */
652a86c6181SAlex Tomas 	if (!path) {
6535d4958f9SAvantika Mathur 		path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 2),
654a86c6181SAlex Tomas 				GFP_NOFS);
655a86c6181SAlex Tomas 		if (!path)
656a86c6181SAlex Tomas 			return ERR_PTR(-ENOMEM);
657a86c6181SAlex Tomas 		alloc = 1;
658a86c6181SAlex Tomas 	}
659a86c6181SAlex Tomas 	path[0].p_hdr = eh;
6601973adcbSShen Feng 	path[0].p_bh = NULL;
661a86c6181SAlex Tomas 
662c29c0ae7SAlex Tomas 	i = depth;
663a86c6181SAlex Tomas 	/* walk through the tree */
664a86c6181SAlex Tomas 	while (i) {
6657a262f7cSAneesh Kumar K.V 		int need_to_validate = 0;
6667a262f7cSAneesh Kumar K.V 
667a86c6181SAlex Tomas 		ext_debug("depth %d: num %d, max %d\n",
668a86c6181SAlex Tomas 			  ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
669c29c0ae7SAlex Tomas 
670a86c6181SAlex Tomas 		ext4_ext_binsearch_idx(inode, path + ppos, block);
671bf89d16fSTheodore Ts'o 		path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx);
672a86c6181SAlex Tomas 		path[ppos].p_depth = i;
673a86c6181SAlex Tomas 		path[ppos].p_ext = NULL;
674a86c6181SAlex Tomas 
6757a262f7cSAneesh Kumar K.V 		bh = sb_getblk(inode->i_sb, path[ppos].p_block);
6767a262f7cSAneesh Kumar K.V 		if (unlikely(!bh))
677a86c6181SAlex Tomas 			goto err;
6787a262f7cSAneesh Kumar K.V 		if (!bh_uptodate_or_lock(bh)) {
6790562e0baSJiaying Zhang 			trace_ext4_ext_load_extent(inode, block,
6800562e0baSJiaying Zhang 						path[ppos].p_block);
6817a262f7cSAneesh Kumar K.V 			if (bh_submit_read(bh) < 0) {
6827a262f7cSAneesh Kumar K.V 				put_bh(bh);
6837a262f7cSAneesh Kumar K.V 				goto err;
6847a262f7cSAneesh Kumar K.V 			}
6857a262f7cSAneesh Kumar K.V 			/* validate the extent entries */
6867a262f7cSAneesh Kumar K.V 			need_to_validate = 1;
6877a262f7cSAneesh Kumar K.V 		}
688a86c6181SAlex Tomas 		eh = ext_block_hdr(bh);
689a86c6181SAlex Tomas 		ppos++;
690273df556SFrank Mayhar 		if (unlikely(ppos > depth)) {
691273df556SFrank Mayhar 			put_bh(bh);
692273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
693273df556SFrank Mayhar 					 "ppos %d > depth %d", ppos, depth);
694273df556SFrank Mayhar 			goto err;
695273df556SFrank Mayhar 		}
696a86c6181SAlex Tomas 		path[ppos].p_bh = bh;
697a86c6181SAlex Tomas 		path[ppos].p_hdr = eh;
698a86c6181SAlex Tomas 		i--;
699a86c6181SAlex Tomas 
7007a262f7cSAneesh Kumar K.V 		if (need_to_validate && ext4_ext_check(inode, eh, i))
701a86c6181SAlex Tomas 			goto err;
702a86c6181SAlex Tomas 	}
703a86c6181SAlex Tomas 
704a86c6181SAlex Tomas 	path[ppos].p_depth = i;
705a86c6181SAlex Tomas 	path[ppos].p_ext = NULL;
706a86c6181SAlex Tomas 	path[ppos].p_idx = NULL;
707a86c6181SAlex Tomas 
708a86c6181SAlex Tomas 	/* find extent */
709a86c6181SAlex Tomas 	ext4_ext_binsearch(inode, path + ppos, block);
7101973adcbSShen Feng 	/* if not an empty leaf */
7111973adcbSShen Feng 	if (path[ppos].p_ext)
712bf89d16fSTheodore Ts'o 		path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext);
713a86c6181SAlex Tomas 
714a86c6181SAlex Tomas 	ext4_ext_show_path(inode, path);
715a86c6181SAlex Tomas 
716a86c6181SAlex Tomas 	return path;
717a86c6181SAlex Tomas 
718a86c6181SAlex Tomas err:
719a86c6181SAlex Tomas 	ext4_ext_drop_refs(path);
720a86c6181SAlex Tomas 	if (alloc)
721a86c6181SAlex Tomas 		kfree(path);
722a86c6181SAlex Tomas 	return ERR_PTR(-EIO);
723a86c6181SAlex Tomas }
724a86c6181SAlex Tomas 
725a86c6181SAlex Tomas /*
726d0d856e8SRandy Dunlap  * ext4_ext_insert_index:
727d0d856e8SRandy Dunlap  * insert new index [@logical;@ptr] into the block at @curp;
728d0d856e8SRandy Dunlap  * check where to insert: before @curp or after @curp
729a86c6181SAlex Tomas  */
7301f109d5aSTheodore Ts'o static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
731a86c6181SAlex Tomas 				 struct ext4_ext_path *curp,
732f65e6fbaSAlex Tomas 				 int logical, ext4_fsblk_t ptr)
733a86c6181SAlex Tomas {
734a86c6181SAlex Tomas 	struct ext4_extent_idx *ix;
735a86c6181SAlex Tomas 	int len, err;
736a86c6181SAlex Tomas 
7377e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, curp);
7387e028976SAvantika Mathur 	if (err)
739a86c6181SAlex Tomas 		return err;
740a86c6181SAlex Tomas 
741273df556SFrank Mayhar 	if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) {
742273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
743273df556SFrank Mayhar 				 "logical %d == ei_block %d!",
744273df556SFrank Mayhar 				 logical, le32_to_cpu(curp->p_idx->ei_block));
745273df556SFrank Mayhar 		return -EIO;
746273df556SFrank Mayhar 	}
747d4620315SRobin Dong 
748d4620315SRobin Dong 	if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries)
749d4620315SRobin Dong 			     >= le16_to_cpu(curp->p_hdr->eh_max))) {
750d4620315SRobin Dong 		EXT4_ERROR_INODE(inode,
751d4620315SRobin Dong 				 "eh_entries %d >= eh_max %d!",
752d4620315SRobin Dong 				 le16_to_cpu(curp->p_hdr->eh_entries),
753d4620315SRobin Dong 				 le16_to_cpu(curp->p_hdr->eh_max));
754d4620315SRobin Dong 		return -EIO;
755d4620315SRobin Dong 	}
756d4620315SRobin Dong 
757a86c6181SAlex Tomas 	len = EXT_MAX_INDEX(curp->p_hdr) - curp->p_idx;
758a86c6181SAlex Tomas 	if (logical > le32_to_cpu(curp->p_idx->ei_block)) {
759a86c6181SAlex Tomas 		/* insert after */
760a86c6181SAlex Tomas 		if (curp->p_idx != EXT_LAST_INDEX(curp->p_hdr)) {
761a86c6181SAlex Tomas 			len = (len - 1) * sizeof(struct ext4_extent_idx);
762a86c6181SAlex Tomas 			len = len < 0 ? 0 : len;
76326d535edSDmitry Monakhov 			ext_debug("insert new index %d after: %llu. "
764a86c6181SAlex Tomas 					"move %d from 0x%p to 0x%p\n",
765a86c6181SAlex Tomas 					logical, ptr, len,
766a86c6181SAlex Tomas 					(curp->p_idx + 1), (curp->p_idx + 2));
767a86c6181SAlex Tomas 			memmove(curp->p_idx + 2, curp->p_idx + 1, len);
768a86c6181SAlex Tomas 		}
769a86c6181SAlex Tomas 		ix = curp->p_idx + 1;
770a86c6181SAlex Tomas 	} else {
771a86c6181SAlex Tomas 		/* insert before */
772a86c6181SAlex Tomas 		len = len * sizeof(struct ext4_extent_idx);
773a86c6181SAlex Tomas 		len = len < 0 ? 0 : len;
77426d535edSDmitry Monakhov 		ext_debug("insert new index %d before: %llu. "
775a86c6181SAlex Tomas 				"move %d from 0x%p to 0x%p\n",
776a86c6181SAlex Tomas 				logical, ptr, len,
777a86c6181SAlex Tomas 				curp->p_idx, (curp->p_idx + 1));
778a86c6181SAlex Tomas 		memmove(curp->p_idx + 1, curp->p_idx, len);
779a86c6181SAlex Tomas 		ix = curp->p_idx;
780a86c6181SAlex Tomas 	}
781a86c6181SAlex Tomas 
782f472e026STao Ma 	if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) {
783f472e026STao Ma 		EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!");
784f472e026STao Ma 		return -EIO;
785f472e026STao Ma 	}
786f472e026STao Ma 
787a86c6181SAlex Tomas 	ix->ei_block = cpu_to_le32(logical);
788f65e6fbaSAlex Tomas 	ext4_idx_store_pblock(ix, ptr);
789e8546d06SMarcin Slusarz 	le16_add_cpu(&curp->p_hdr->eh_entries, 1);
790a86c6181SAlex Tomas 
791273df556SFrank Mayhar 	if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) {
792273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
793273df556SFrank Mayhar 		return -EIO;
794273df556SFrank Mayhar 	}
795a86c6181SAlex Tomas 
796a86c6181SAlex Tomas 	err = ext4_ext_dirty(handle, inode, curp);
797a86c6181SAlex Tomas 	ext4_std_error(inode->i_sb, err);
798a86c6181SAlex Tomas 
799a86c6181SAlex Tomas 	return err;
800a86c6181SAlex Tomas }
801a86c6181SAlex Tomas 
802a86c6181SAlex Tomas /*
803d0d856e8SRandy Dunlap  * ext4_ext_split:
804d0d856e8SRandy Dunlap  * inserts new subtree into the path, using free index entry
805d0d856e8SRandy Dunlap  * at depth @at:
806a86c6181SAlex Tomas  * - allocates all needed blocks (new leaf and all intermediate index blocks)
807a86c6181SAlex Tomas  * - makes decision where to split
808d0d856e8SRandy Dunlap  * - moves remaining extents and index entries (right to the split point)
809a86c6181SAlex Tomas  *   into the newly allocated blocks
810d0d856e8SRandy Dunlap  * - initializes subtree
811a86c6181SAlex Tomas  */
812a86c6181SAlex Tomas static int ext4_ext_split(handle_t *handle, struct inode *inode,
81355f020dbSAllison Henderson 			  unsigned int flags,
814a86c6181SAlex Tomas 			  struct ext4_ext_path *path,
815a86c6181SAlex Tomas 			  struct ext4_extent *newext, int at)
816a86c6181SAlex Tomas {
817a86c6181SAlex Tomas 	struct buffer_head *bh = NULL;
818a86c6181SAlex Tomas 	int depth = ext_depth(inode);
819a86c6181SAlex Tomas 	struct ext4_extent_header *neh;
820a86c6181SAlex Tomas 	struct ext4_extent_idx *fidx;
821a86c6181SAlex Tomas 	int i = at, k, m, a;
822f65e6fbaSAlex Tomas 	ext4_fsblk_t newblock, oldblock;
823a86c6181SAlex Tomas 	__le32 border;
824f65e6fbaSAlex Tomas 	ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
825a86c6181SAlex Tomas 	int err = 0;
826a86c6181SAlex Tomas 
827a86c6181SAlex Tomas 	/* make decision: where to split? */
828d0d856e8SRandy Dunlap 	/* FIXME: now decision is simplest: at current extent */
829a86c6181SAlex Tomas 
830d0d856e8SRandy Dunlap 	/* if current leaf will be split, then we should use
831a86c6181SAlex Tomas 	 * border from split point */
832273df556SFrank Mayhar 	if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {
833273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
834273df556SFrank Mayhar 		return -EIO;
835273df556SFrank Mayhar 	}
836a86c6181SAlex Tomas 	if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
837a86c6181SAlex Tomas 		border = path[depth].p_ext[1].ee_block;
838d0d856e8SRandy Dunlap 		ext_debug("leaf will be split."
839a86c6181SAlex Tomas 				" next leaf starts at %d\n",
840a86c6181SAlex Tomas 				  le32_to_cpu(border));
841a86c6181SAlex Tomas 	} else {
842a86c6181SAlex Tomas 		border = newext->ee_block;
843a86c6181SAlex Tomas 		ext_debug("leaf will be added."
844a86c6181SAlex Tomas 				" next leaf starts at %d\n",
845a86c6181SAlex Tomas 				le32_to_cpu(border));
846a86c6181SAlex Tomas 	}
847a86c6181SAlex Tomas 
848a86c6181SAlex Tomas 	/*
849d0d856e8SRandy Dunlap 	 * If error occurs, then we break processing
850d0d856e8SRandy Dunlap 	 * and mark filesystem read-only. index won't
851a86c6181SAlex Tomas 	 * be inserted and tree will be in consistent
852d0d856e8SRandy Dunlap 	 * state. Next mount will repair buffers too.
853a86c6181SAlex Tomas 	 */
854a86c6181SAlex Tomas 
855a86c6181SAlex Tomas 	/*
856d0d856e8SRandy Dunlap 	 * Get array to track all allocated blocks.
857d0d856e8SRandy Dunlap 	 * We need this to handle errors and free blocks
858d0d856e8SRandy Dunlap 	 * upon them.
859a86c6181SAlex Tomas 	 */
8605d4958f9SAvantika Mathur 	ablocks = kzalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS);
861a86c6181SAlex Tomas 	if (!ablocks)
862a86c6181SAlex Tomas 		return -ENOMEM;
863a86c6181SAlex Tomas 
864a86c6181SAlex Tomas 	/* allocate all needed blocks */
865a86c6181SAlex Tomas 	ext_debug("allocate %d blocks for indexes/leaf\n", depth - at);
866a86c6181SAlex Tomas 	for (a = 0; a < depth - at; a++) {
867654b4908SAneesh Kumar K.V 		newblock = ext4_ext_new_meta_block(handle, inode, path,
86855f020dbSAllison Henderson 						   newext, &err, flags);
869a86c6181SAlex Tomas 		if (newblock == 0)
870a86c6181SAlex Tomas 			goto cleanup;
871a86c6181SAlex Tomas 		ablocks[a] = newblock;
872a86c6181SAlex Tomas 	}
873a86c6181SAlex Tomas 
874a86c6181SAlex Tomas 	/* initialize new leaf */
875a86c6181SAlex Tomas 	newblock = ablocks[--a];
876273df556SFrank Mayhar 	if (unlikely(newblock == 0)) {
877273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "newblock == 0!");
878273df556SFrank Mayhar 		err = -EIO;
879273df556SFrank Mayhar 		goto cleanup;
880273df556SFrank Mayhar 	}
881a86c6181SAlex Tomas 	bh = sb_getblk(inode->i_sb, newblock);
882a86c6181SAlex Tomas 	if (!bh) {
883a86c6181SAlex Tomas 		err = -EIO;
884a86c6181SAlex Tomas 		goto cleanup;
885a86c6181SAlex Tomas 	}
886a86c6181SAlex Tomas 	lock_buffer(bh);
887a86c6181SAlex Tomas 
8887e028976SAvantika Mathur 	err = ext4_journal_get_create_access(handle, bh);
8897e028976SAvantika Mathur 	if (err)
890a86c6181SAlex Tomas 		goto cleanup;
891a86c6181SAlex Tomas 
892a86c6181SAlex Tomas 	neh = ext_block_hdr(bh);
893a86c6181SAlex Tomas 	neh->eh_entries = 0;
89455ad63bfSTheodore Ts'o 	neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
895a86c6181SAlex Tomas 	neh->eh_magic = EXT4_EXT_MAGIC;
896a86c6181SAlex Tomas 	neh->eh_depth = 0;
897a86c6181SAlex Tomas 
898d0d856e8SRandy Dunlap 	/* move remainder of path[depth] to the new leaf */
899273df556SFrank Mayhar 	if (unlikely(path[depth].p_hdr->eh_entries !=
900273df556SFrank Mayhar 		     path[depth].p_hdr->eh_max)) {
901273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
902273df556SFrank Mayhar 				 path[depth].p_hdr->eh_entries,
903273df556SFrank Mayhar 				 path[depth].p_hdr->eh_max);
904273df556SFrank Mayhar 		err = -EIO;
905273df556SFrank Mayhar 		goto cleanup;
906273df556SFrank Mayhar 	}
907a86c6181SAlex Tomas 	/* start copy from next extent */
9081b16da77SYongqiang Yang 	m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++;
9091b16da77SYongqiang Yang 	ext4_ext_show_move(inode, path, newblock, depth);
910a86c6181SAlex Tomas 	if (m) {
9111b16da77SYongqiang Yang 		struct ext4_extent *ex;
9121b16da77SYongqiang Yang 		ex = EXT_FIRST_EXTENT(neh);
9131b16da77SYongqiang Yang 		memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m);
914e8546d06SMarcin Slusarz 		le16_add_cpu(&neh->eh_entries, m);
915a86c6181SAlex Tomas 	}
916a86c6181SAlex Tomas 
917a86c6181SAlex Tomas 	set_buffer_uptodate(bh);
918a86c6181SAlex Tomas 	unlock_buffer(bh);
919a86c6181SAlex Tomas 
9200390131bSFrank Mayhar 	err = ext4_handle_dirty_metadata(handle, inode, bh);
9217e028976SAvantika Mathur 	if (err)
922a86c6181SAlex Tomas 		goto cleanup;
923a86c6181SAlex Tomas 	brelse(bh);
924a86c6181SAlex Tomas 	bh = NULL;
925a86c6181SAlex Tomas 
926a86c6181SAlex Tomas 	/* correct old leaf */
927a86c6181SAlex Tomas 	if (m) {
9287e028976SAvantika Mathur 		err = ext4_ext_get_access(handle, inode, path + depth);
9297e028976SAvantika Mathur 		if (err)
930a86c6181SAlex Tomas 			goto cleanup;
931e8546d06SMarcin Slusarz 		le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);
9327e028976SAvantika Mathur 		err = ext4_ext_dirty(handle, inode, path + depth);
9337e028976SAvantika Mathur 		if (err)
934a86c6181SAlex Tomas 			goto cleanup;
935a86c6181SAlex Tomas 
936a86c6181SAlex Tomas 	}
937a86c6181SAlex Tomas 
938a86c6181SAlex Tomas 	/* create intermediate indexes */
939a86c6181SAlex Tomas 	k = depth - at - 1;
940273df556SFrank Mayhar 	if (unlikely(k < 0)) {
941273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "k %d < 0!", k);
942273df556SFrank Mayhar 		err = -EIO;
943273df556SFrank Mayhar 		goto cleanup;
944273df556SFrank Mayhar 	}
945a86c6181SAlex Tomas 	if (k)
946a86c6181SAlex Tomas 		ext_debug("create %d intermediate indices\n", k);
947a86c6181SAlex Tomas 	/* insert new index into current index block */
948a86c6181SAlex Tomas 	/* current depth stored in i var */
949a86c6181SAlex Tomas 	i = depth - 1;
950a86c6181SAlex Tomas 	while (k--) {
951a86c6181SAlex Tomas 		oldblock = newblock;
952a86c6181SAlex Tomas 		newblock = ablocks[--a];
953bba90743SEric Sandeen 		bh = sb_getblk(inode->i_sb, newblock);
954a86c6181SAlex Tomas 		if (!bh) {
955a86c6181SAlex Tomas 			err = -EIO;
956a86c6181SAlex Tomas 			goto cleanup;
957a86c6181SAlex Tomas 		}
958a86c6181SAlex Tomas 		lock_buffer(bh);
959a86c6181SAlex Tomas 
9607e028976SAvantika Mathur 		err = ext4_journal_get_create_access(handle, bh);
9617e028976SAvantika Mathur 		if (err)
962a86c6181SAlex Tomas 			goto cleanup;
963a86c6181SAlex Tomas 
964a86c6181SAlex Tomas 		neh = ext_block_hdr(bh);
965a86c6181SAlex Tomas 		neh->eh_entries = cpu_to_le16(1);
966a86c6181SAlex Tomas 		neh->eh_magic = EXT4_EXT_MAGIC;
96755ad63bfSTheodore Ts'o 		neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
968a86c6181SAlex Tomas 		neh->eh_depth = cpu_to_le16(depth - i);
969a86c6181SAlex Tomas 		fidx = EXT_FIRST_INDEX(neh);
970a86c6181SAlex Tomas 		fidx->ei_block = border;
971f65e6fbaSAlex Tomas 		ext4_idx_store_pblock(fidx, oldblock);
972a86c6181SAlex Tomas 
973bba90743SEric Sandeen 		ext_debug("int.index at %d (block %llu): %u -> %llu\n",
974bba90743SEric Sandeen 				i, newblock, le32_to_cpu(border), oldblock);
975a86c6181SAlex Tomas 
9761b16da77SYongqiang Yang 		/* move remainder of path[i] to the new index block */
977273df556SFrank Mayhar 		if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) !=
978273df556SFrank Mayhar 					EXT_LAST_INDEX(path[i].p_hdr))) {
979273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
980273df556SFrank Mayhar 					 "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!",
981273df556SFrank Mayhar 					 le32_to_cpu(path[i].p_ext->ee_block));
982273df556SFrank Mayhar 			err = -EIO;
983273df556SFrank Mayhar 			goto cleanup;
984273df556SFrank Mayhar 		}
9851b16da77SYongqiang Yang 		/* start copy indexes */
9861b16da77SYongqiang Yang 		m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++;
9871b16da77SYongqiang Yang 		ext_debug("cur 0x%p, last 0x%p\n", path[i].p_idx,
9881b16da77SYongqiang Yang 				EXT_MAX_INDEX(path[i].p_hdr));
9891b16da77SYongqiang Yang 		ext4_ext_show_move(inode, path, newblock, i);
990a86c6181SAlex Tomas 		if (m) {
9911b16da77SYongqiang Yang 			memmove(++fidx, path[i].p_idx,
992a86c6181SAlex Tomas 				sizeof(struct ext4_extent_idx) * m);
993e8546d06SMarcin Slusarz 			le16_add_cpu(&neh->eh_entries, m);
994a86c6181SAlex Tomas 		}
995a86c6181SAlex Tomas 		set_buffer_uptodate(bh);
996a86c6181SAlex Tomas 		unlock_buffer(bh);
997a86c6181SAlex Tomas 
9980390131bSFrank Mayhar 		err = ext4_handle_dirty_metadata(handle, inode, bh);
9997e028976SAvantika Mathur 		if (err)
1000a86c6181SAlex Tomas 			goto cleanup;
1001a86c6181SAlex Tomas 		brelse(bh);
1002a86c6181SAlex Tomas 		bh = NULL;
1003a86c6181SAlex Tomas 
1004a86c6181SAlex Tomas 		/* correct old index */
1005a86c6181SAlex Tomas 		if (m) {
1006a86c6181SAlex Tomas 			err = ext4_ext_get_access(handle, inode, path + i);
1007a86c6181SAlex Tomas 			if (err)
1008a86c6181SAlex Tomas 				goto cleanup;
1009e8546d06SMarcin Slusarz 			le16_add_cpu(&path[i].p_hdr->eh_entries, -m);
1010a86c6181SAlex Tomas 			err = ext4_ext_dirty(handle, inode, path + i);
1011a86c6181SAlex Tomas 			if (err)
1012a86c6181SAlex Tomas 				goto cleanup;
1013a86c6181SAlex Tomas 		}
1014a86c6181SAlex Tomas 
1015a86c6181SAlex Tomas 		i--;
1016a86c6181SAlex Tomas 	}
1017a86c6181SAlex Tomas 
1018a86c6181SAlex Tomas 	/* insert new index */
1019a86c6181SAlex Tomas 	err = ext4_ext_insert_index(handle, inode, path + at,
1020a86c6181SAlex Tomas 				    le32_to_cpu(border), newblock);
1021a86c6181SAlex Tomas 
1022a86c6181SAlex Tomas cleanup:
1023a86c6181SAlex Tomas 	if (bh) {
1024a86c6181SAlex Tomas 		if (buffer_locked(bh))
1025a86c6181SAlex Tomas 			unlock_buffer(bh);
1026a86c6181SAlex Tomas 		brelse(bh);
1027a86c6181SAlex Tomas 	}
1028a86c6181SAlex Tomas 
1029a86c6181SAlex Tomas 	if (err) {
1030a86c6181SAlex Tomas 		/* free all allocated blocks in error case */
1031a86c6181SAlex Tomas 		for (i = 0; i < depth; i++) {
1032a86c6181SAlex Tomas 			if (!ablocks[i])
1033a86c6181SAlex Tomas 				continue;
10347dc57615SPeter Huewe 			ext4_free_blocks(handle, inode, NULL, ablocks[i], 1,
1035e6362609STheodore Ts'o 					 EXT4_FREE_BLOCKS_METADATA);
1036a86c6181SAlex Tomas 		}
1037a86c6181SAlex Tomas 	}
1038a86c6181SAlex Tomas 	kfree(ablocks);
1039a86c6181SAlex Tomas 
1040a86c6181SAlex Tomas 	return err;
1041a86c6181SAlex Tomas }
1042a86c6181SAlex Tomas 
1043a86c6181SAlex Tomas /*
1044d0d856e8SRandy Dunlap  * ext4_ext_grow_indepth:
1045d0d856e8SRandy Dunlap  * implements tree growing procedure:
1046a86c6181SAlex Tomas  * - allocates new block
1047a86c6181SAlex Tomas  * - moves top-level data (index block or leaf) into the new block
1048d0d856e8SRandy Dunlap  * - initializes new top-level, creating index that points to the
1049a86c6181SAlex Tomas  *   just created block
1050a86c6181SAlex Tomas  */
1051a86c6181SAlex Tomas static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
105255f020dbSAllison Henderson 				 unsigned int flags,
1053a86c6181SAlex Tomas 				 struct ext4_extent *newext)
1054a86c6181SAlex Tomas {
1055a86c6181SAlex Tomas 	struct ext4_extent_header *neh;
1056a86c6181SAlex Tomas 	struct buffer_head *bh;
1057f65e6fbaSAlex Tomas 	ext4_fsblk_t newblock;
1058a86c6181SAlex Tomas 	int err = 0;
1059a86c6181SAlex Tomas 
10601939dd84SDmitry Monakhov 	newblock = ext4_ext_new_meta_block(handle, inode, NULL,
106155f020dbSAllison Henderson 		newext, &err, flags);
1062a86c6181SAlex Tomas 	if (newblock == 0)
1063a86c6181SAlex Tomas 		return err;
1064a86c6181SAlex Tomas 
1065a86c6181SAlex Tomas 	bh = sb_getblk(inode->i_sb, newblock);
1066a86c6181SAlex Tomas 	if (!bh) {
1067a86c6181SAlex Tomas 		err = -EIO;
1068a86c6181SAlex Tomas 		ext4_std_error(inode->i_sb, err);
1069a86c6181SAlex Tomas 		return err;
1070a86c6181SAlex Tomas 	}
1071a86c6181SAlex Tomas 	lock_buffer(bh);
1072a86c6181SAlex Tomas 
10737e028976SAvantika Mathur 	err = ext4_journal_get_create_access(handle, bh);
10747e028976SAvantika Mathur 	if (err) {
1075a86c6181SAlex Tomas 		unlock_buffer(bh);
1076a86c6181SAlex Tomas 		goto out;
1077a86c6181SAlex Tomas 	}
1078a86c6181SAlex Tomas 
1079a86c6181SAlex Tomas 	/* move top-level index/leaf into new block */
10801939dd84SDmitry Monakhov 	memmove(bh->b_data, EXT4_I(inode)->i_data,
10811939dd84SDmitry Monakhov 		sizeof(EXT4_I(inode)->i_data));
1082a86c6181SAlex Tomas 
1083a86c6181SAlex Tomas 	/* set size of new block */
1084a86c6181SAlex Tomas 	neh = ext_block_hdr(bh);
1085a86c6181SAlex Tomas 	/* old root could have indexes or leaves
1086a86c6181SAlex Tomas 	 * so calculate e_max right way */
1087a86c6181SAlex Tomas 	if (ext_depth(inode))
108855ad63bfSTheodore Ts'o 		neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1089a86c6181SAlex Tomas 	else
109055ad63bfSTheodore Ts'o 		neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1091a86c6181SAlex Tomas 	neh->eh_magic = EXT4_EXT_MAGIC;
1092a86c6181SAlex Tomas 	set_buffer_uptodate(bh);
1093a86c6181SAlex Tomas 	unlock_buffer(bh);
1094a86c6181SAlex Tomas 
10950390131bSFrank Mayhar 	err = ext4_handle_dirty_metadata(handle, inode, bh);
10967e028976SAvantika Mathur 	if (err)
1097a86c6181SAlex Tomas 		goto out;
1098a86c6181SAlex Tomas 
10991939dd84SDmitry Monakhov 	/* Update top-level index: num,max,pointer */
1100a86c6181SAlex Tomas 	neh = ext_inode_hdr(inode);
11011939dd84SDmitry Monakhov 	neh->eh_entries = cpu_to_le16(1);
11021939dd84SDmitry Monakhov 	ext4_idx_store_pblock(EXT_FIRST_INDEX(neh), newblock);
11031939dd84SDmitry Monakhov 	if (neh->eh_depth == 0) {
11041939dd84SDmitry Monakhov 		/* Root extent block becomes index block */
11051939dd84SDmitry Monakhov 		neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
11061939dd84SDmitry Monakhov 		EXT_FIRST_INDEX(neh)->ei_block =
11071939dd84SDmitry Monakhov 			EXT_FIRST_EXTENT(neh)->ee_block;
11081939dd84SDmitry Monakhov 	}
11092ae02107SMingming Cao 	ext_debug("new root: num %d(%d), lblock %d, ptr %llu\n",
1110a86c6181SAlex Tomas 		  le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),
11115a0790c2SAndi Kleen 		  le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block),
1112bf89d16fSTheodore Ts'o 		  ext4_idx_pblock(EXT_FIRST_INDEX(neh)));
1113a86c6181SAlex Tomas 
11141939dd84SDmitry Monakhov 	neh->eh_depth = cpu_to_le16(neh->eh_depth + 1);
11151939dd84SDmitry Monakhov 	ext4_mark_inode_dirty(handle, inode);
1116a86c6181SAlex Tomas out:
1117a86c6181SAlex Tomas 	brelse(bh);
1118a86c6181SAlex Tomas 
1119a86c6181SAlex Tomas 	return err;
1120a86c6181SAlex Tomas }
1121a86c6181SAlex Tomas 
1122a86c6181SAlex Tomas /*
1123d0d856e8SRandy Dunlap  * ext4_ext_create_new_leaf:
1124d0d856e8SRandy Dunlap  * finds empty index and adds new leaf.
1125d0d856e8SRandy Dunlap  * if no free index is found, then it requests in-depth growing.
1126a86c6181SAlex Tomas  */
1127a86c6181SAlex Tomas static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode,
112855f020dbSAllison Henderson 				    unsigned int flags,
1129a86c6181SAlex Tomas 				    struct ext4_ext_path *path,
1130a86c6181SAlex Tomas 				    struct ext4_extent *newext)
1131a86c6181SAlex Tomas {
1132a86c6181SAlex Tomas 	struct ext4_ext_path *curp;
1133a86c6181SAlex Tomas 	int depth, i, err = 0;
1134a86c6181SAlex Tomas 
1135a86c6181SAlex Tomas repeat:
1136a86c6181SAlex Tomas 	i = depth = ext_depth(inode);
1137a86c6181SAlex Tomas 
1138a86c6181SAlex Tomas 	/* walk up to the tree and look for free index entry */
1139a86c6181SAlex Tomas 	curp = path + depth;
1140a86c6181SAlex Tomas 	while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) {
1141a86c6181SAlex Tomas 		i--;
1142a86c6181SAlex Tomas 		curp--;
1143a86c6181SAlex Tomas 	}
1144a86c6181SAlex Tomas 
1145d0d856e8SRandy Dunlap 	/* we use already allocated block for index block,
1146d0d856e8SRandy Dunlap 	 * so subsequent data blocks should be contiguous */
1147a86c6181SAlex Tomas 	if (EXT_HAS_FREE_INDEX(curp)) {
1148a86c6181SAlex Tomas 		/* if we found index with free entry, then use that
1149a86c6181SAlex Tomas 		 * entry: create all needed subtree and add new leaf */
115055f020dbSAllison Henderson 		err = ext4_ext_split(handle, inode, flags, path, newext, i);
1151787e0981SShen Feng 		if (err)
1152787e0981SShen Feng 			goto out;
1153a86c6181SAlex Tomas 
1154a86c6181SAlex Tomas 		/* refill path */
1155a86c6181SAlex Tomas 		ext4_ext_drop_refs(path);
1156a86c6181SAlex Tomas 		path = ext4_ext_find_extent(inode,
1157725d26d3SAneesh Kumar K.V 				    (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1158a86c6181SAlex Tomas 				    path);
1159a86c6181SAlex Tomas 		if (IS_ERR(path))
1160a86c6181SAlex Tomas 			err = PTR_ERR(path);
1161a86c6181SAlex Tomas 	} else {
1162a86c6181SAlex Tomas 		/* tree is full, time to grow in depth */
11631939dd84SDmitry Monakhov 		err = ext4_ext_grow_indepth(handle, inode, flags, newext);
1164a86c6181SAlex Tomas 		if (err)
1165a86c6181SAlex Tomas 			goto out;
1166a86c6181SAlex Tomas 
1167a86c6181SAlex Tomas 		/* refill path */
1168a86c6181SAlex Tomas 		ext4_ext_drop_refs(path);
1169a86c6181SAlex Tomas 		path = ext4_ext_find_extent(inode,
1170725d26d3SAneesh Kumar K.V 				   (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1171a86c6181SAlex Tomas 				    path);
1172a86c6181SAlex Tomas 		if (IS_ERR(path)) {
1173a86c6181SAlex Tomas 			err = PTR_ERR(path);
1174a86c6181SAlex Tomas 			goto out;
1175a86c6181SAlex Tomas 		}
1176a86c6181SAlex Tomas 
1177a86c6181SAlex Tomas 		/*
1178d0d856e8SRandy Dunlap 		 * only first (depth 0 -> 1) produces free space;
1179d0d856e8SRandy Dunlap 		 * in all other cases we have to split the grown tree
1180a86c6181SAlex Tomas 		 */
1181a86c6181SAlex Tomas 		depth = ext_depth(inode);
1182a86c6181SAlex Tomas 		if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
1183d0d856e8SRandy Dunlap 			/* now we need to split */
1184a86c6181SAlex Tomas 			goto repeat;
1185a86c6181SAlex Tomas 		}
1186a86c6181SAlex Tomas 	}
1187a86c6181SAlex Tomas 
1188a86c6181SAlex Tomas out:
1189a86c6181SAlex Tomas 	return err;
1190a86c6181SAlex Tomas }
1191a86c6181SAlex Tomas 
1192a86c6181SAlex Tomas /*
11931988b51eSAlex Tomas  * search the closest allocated block to the left for *logical
11941988b51eSAlex Tomas  * and returns it at @logical + it's physical address at @phys
11951988b51eSAlex Tomas  * if *logical is the smallest allocated block, the function
11961988b51eSAlex Tomas  * returns 0 at @phys
11971988b51eSAlex Tomas  * return value contains 0 (success) or error code
11981988b51eSAlex Tomas  */
11991f109d5aSTheodore Ts'o static int ext4_ext_search_left(struct inode *inode,
12001f109d5aSTheodore Ts'o 				struct ext4_ext_path *path,
12011988b51eSAlex Tomas 				ext4_lblk_t *logical, ext4_fsblk_t *phys)
12021988b51eSAlex Tomas {
12031988b51eSAlex Tomas 	struct ext4_extent_idx *ix;
12041988b51eSAlex Tomas 	struct ext4_extent *ex;
1205b939e376SAneesh Kumar K.V 	int depth, ee_len;
12061988b51eSAlex Tomas 
1207273df556SFrank Mayhar 	if (unlikely(path == NULL)) {
1208273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1209273df556SFrank Mayhar 		return -EIO;
1210273df556SFrank Mayhar 	}
12111988b51eSAlex Tomas 	depth = path->p_depth;
12121988b51eSAlex Tomas 	*phys = 0;
12131988b51eSAlex Tomas 
12141988b51eSAlex Tomas 	if (depth == 0 && path->p_ext == NULL)
12151988b51eSAlex Tomas 		return 0;
12161988b51eSAlex Tomas 
12171988b51eSAlex Tomas 	/* usually extent in the path covers blocks smaller
12181988b51eSAlex Tomas 	 * then *logical, but it can be that extent is the
12191988b51eSAlex Tomas 	 * first one in the file */
12201988b51eSAlex Tomas 
12211988b51eSAlex Tomas 	ex = path[depth].p_ext;
1222b939e376SAneesh Kumar K.V 	ee_len = ext4_ext_get_actual_len(ex);
12231988b51eSAlex Tomas 	if (*logical < le32_to_cpu(ex->ee_block)) {
1224273df556SFrank Mayhar 		if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1225273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
1226273df556SFrank Mayhar 					 "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!",
1227273df556SFrank Mayhar 					 *logical, le32_to_cpu(ex->ee_block));
1228273df556SFrank Mayhar 			return -EIO;
1229273df556SFrank Mayhar 		}
12301988b51eSAlex Tomas 		while (--depth >= 0) {
12311988b51eSAlex Tomas 			ix = path[depth].p_idx;
1232273df556SFrank Mayhar 			if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1233273df556SFrank Mayhar 				EXT4_ERROR_INODE(inode,
1234273df556SFrank Mayhar 				  "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!",
12356ee3b212STao Ma 				  ix != NULL ? le32_to_cpu(ix->ei_block) : 0,
1236273df556SFrank Mayhar 				  EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?
12376ee3b212STao Ma 		le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0,
1238273df556SFrank Mayhar 				  depth);
1239273df556SFrank Mayhar 				return -EIO;
1240273df556SFrank Mayhar 			}
12411988b51eSAlex Tomas 		}
12421988b51eSAlex Tomas 		return 0;
12431988b51eSAlex Tomas 	}
12441988b51eSAlex Tomas 
1245273df556SFrank Mayhar 	if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1246273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
1247273df556SFrank Mayhar 				 "logical %d < ee_block %d + ee_len %d!",
1248273df556SFrank Mayhar 				 *logical, le32_to_cpu(ex->ee_block), ee_len);
1249273df556SFrank Mayhar 		return -EIO;
1250273df556SFrank Mayhar 	}
12511988b51eSAlex Tomas 
1252b939e376SAneesh Kumar K.V 	*logical = le32_to_cpu(ex->ee_block) + ee_len - 1;
1253bf89d16fSTheodore Ts'o 	*phys = ext4_ext_pblock(ex) + ee_len - 1;
12541988b51eSAlex Tomas 	return 0;
12551988b51eSAlex Tomas }
12561988b51eSAlex Tomas 
12571988b51eSAlex Tomas /*
12581988b51eSAlex Tomas  * search the closest allocated block to the right for *logical
12591988b51eSAlex Tomas  * and returns it at @logical + it's physical address at @phys
1260df3ab170STao Ma  * if *logical is the largest allocated block, the function
12611988b51eSAlex Tomas  * returns 0 at @phys
12621988b51eSAlex Tomas  * return value contains 0 (success) or error code
12631988b51eSAlex Tomas  */
12641f109d5aSTheodore Ts'o static int ext4_ext_search_right(struct inode *inode,
12651f109d5aSTheodore Ts'o 				 struct ext4_ext_path *path,
12664d33b1efSTheodore Ts'o 				 ext4_lblk_t *logical, ext4_fsblk_t *phys,
12674d33b1efSTheodore Ts'o 				 struct ext4_extent **ret_ex)
12681988b51eSAlex Tomas {
12691988b51eSAlex Tomas 	struct buffer_head *bh = NULL;
12701988b51eSAlex Tomas 	struct ext4_extent_header *eh;
12711988b51eSAlex Tomas 	struct ext4_extent_idx *ix;
12721988b51eSAlex Tomas 	struct ext4_extent *ex;
12731988b51eSAlex Tomas 	ext4_fsblk_t block;
1274395a87bfSEric Sandeen 	int depth;	/* Note, NOT eh_depth; depth from top of tree */
1275395a87bfSEric Sandeen 	int ee_len;
12761988b51eSAlex Tomas 
1277273df556SFrank Mayhar 	if (unlikely(path == NULL)) {
1278273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1279273df556SFrank Mayhar 		return -EIO;
1280273df556SFrank Mayhar 	}
12811988b51eSAlex Tomas 	depth = path->p_depth;
12821988b51eSAlex Tomas 	*phys = 0;
12831988b51eSAlex Tomas 
12841988b51eSAlex Tomas 	if (depth == 0 && path->p_ext == NULL)
12851988b51eSAlex Tomas 		return 0;
12861988b51eSAlex Tomas 
12871988b51eSAlex Tomas 	/* usually extent in the path covers blocks smaller
12881988b51eSAlex Tomas 	 * then *logical, but it can be that extent is the
12891988b51eSAlex Tomas 	 * first one in the file */
12901988b51eSAlex Tomas 
12911988b51eSAlex Tomas 	ex = path[depth].p_ext;
1292b939e376SAneesh Kumar K.V 	ee_len = ext4_ext_get_actual_len(ex);
12931988b51eSAlex Tomas 	if (*logical < le32_to_cpu(ex->ee_block)) {
1294273df556SFrank Mayhar 		if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1295273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode,
1296273df556SFrank Mayhar 					 "first_extent(path[%d].p_hdr) != ex",
1297273df556SFrank Mayhar 					 depth);
1298273df556SFrank Mayhar 			return -EIO;
1299273df556SFrank Mayhar 		}
13001988b51eSAlex Tomas 		while (--depth >= 0) {
13011988b51eSAlex Tomas 			ix = path[depth].p_idx;
1302273df556SFrank Mayhar 			if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1303273df556SFrank Mayhar 				EXT4_ERROR_INODE(inode,
1304273df556SFrank Mayhar 						 "ix != EXT_FIRST_INDEX *logical %d!",
1305273df556SFrank Mayhar 						 *logical);
1306273df556SFrank Mayhar 				return -EIO;
1307273df556SFrank Mayhar 			}
13081988b51eSAlex Tomas 		}
13094d33b1efSTheodore Ts'o 		goto found_extent;
13101988b51eSAlex Tomas 	}
13111988b51eSAlex Tomas 
1312273df556SFrank Mayhar 	if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1313273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
1314273df556SFrank Mayhar 				 "logical %d < ee_block %d + ee_len %d!",
1315273df556SFrank Mayhar 				 *logical, le32_to_cpu(ex->ee_block), ee_len);
1316273df556SFrank Mayhar 		return -EIO;
1317273df556SFrank Mayhar 	}
13181988b51eSAlex Tomas 
13191988b51eSAlex Tomas 	if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
13201988b51eSAlex Tomas 		/* next allocated block in this leaf */
13211988b51eSAlex Tomas 		ex++;
13224d33b1efSTheodore Ts'o 		goto found_extent;
13231988b51eSAlex Tomas 	}
13241988b51eSAlex Tomas 
13251988b51eSAlex Tomas 	/* go up and search for index to the right */
13261988b51eSAlex Tomas 	while (--depth >= 0) {
13271988b51eSAlex Tomas 		ix = path[depth].p_idx;
13281988b51eSAlex Tomas 		if (ix != EXT_LAST_INDEX(path[depth].p_hdr))
132925f1ee3aSWu Fengguang 			goto got_index;
13301988b51eSAlex Tomas 	}
13311988b51eSAlex Tomas 
133225f1ee3aSWu Fengguang 	/* we've gone up to the root and found no index to the right */
13331988b51eSAlex Tomas 	return 0;
13341988b51eSAlex Tomas 
133525f1ee3aSWu Fengguang got_index:
13361988b51eSAlex Tomas 	/* we've found index to the right, let's
13371988b51eSAlex Tomas 	 * follow it and find the closest allocated
13381988b51eSAlex Tomas 	 * block to the right */
13391988b51eSAlex Tomas 	ix++;
1340bf89d16fSTheodore Ts'o 	block = ext4_idx_pblock(ix);
13411988b51eSAlex Tomas 	while (++depth < path->p_depth) {
13421988b51eSAlex Tomas 		bh = sb_bread(inode->i_sb, block);
13431988b51eSAlex Tomas 		if (bh == NULL)
13441988b51eSAlex Tomas 			return -EIO;
13451988b51eSAlex Tomas 		eh = ext_block_hdr(bh);
1346395a87bfSEric Sandeen 		/* subtract from p_depth to get proper eh_depth */
134756b19868SAneesh Kumar K.V 		if (ext4_ext_check(inode, eh, path->p_depth - depth)) {
13481988b51eSAlex Tomas 			put_bh(bh);
13491988b51eSAlex Tomas 			return -EIO;
13501988b51eSAlex Tomas 		}
13511988b51eSAlex Tomas 		ix = EXT_FIRST_INDEX(eh);
1352bf89d16fSTheodore Ts'o 		block = ext4_idx_pblock(ix);
13531988b51eSAlex Tomas 		put_bh(bh);
13541988b51eSAlex Tomas 	}
13551988b51eSAlex Tomas 
13561988b51eSAlex Tomas 	bh = sb_bread(inode->i_sb, block);
13571988b51eSAlex Tomas 	if (bh == NULL)
13581988b51eSAlex Tomas 		return -EIO;
13591988b51eSAlex Tomas 	eh = ext_block_hdr(bh);
136056b19868SAneesh Kumar K.V 	if (ext4_ext_check(inode, eh, path->p_depth - depth)) {
13611988b51eSAlex Tomas 		put_bh(bh);
13621988b51eSAlex Tomas 		return -EIO;
13631988b51eSAlex Tomas 	}
13641988b51eSAlex Tomas 	ex = EXT_FIRST_EXTENT(eh);
13654d33b1efSTheodore Ts'o found_extent:
13661988b51eSAlex Tomas 	*logical = le32_to_cpu(ex->ee_block);
1367bf89d16fSTheodore Ts'o 	*phys = ext4_ext_pblock(ex);
13684d33b1efSTheodore Ts'o 	*ret_ex = ex;
13694d33b1efSTheodore Ts'o 	if (bh)
13701988b51eSAlex Tomas 		put_bh(bh);
13711988b51eSAlex Tomas 	return 0;
13721988b51eSAlex Tomas }
13731988b51eSAlex Tomas 
13741988b51eSAlex Tomas /*
1375d0d856e8SRandy Dunlap  * ext4_ext_next_allocated_block:
1376f17722f9SLukas Czerner  * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
1377d0d856e8SRandy Dunlap  * NOTE: it considers block number from index entry as
1378d0d856e8SRandy Dunlap  * allocated block. Thus, index entries have to be consistent
1379d0d856e8SRandy Dunlap  * with leaves.
1380a86c6181SAlex Tomas  */
1381725d26d3SAneesh Kumar K.V static ext4_lblk_t
1382a86c6181SAlex Tomas ext4_ext_next_allocated_block(struct ext4_ext_path *path)
1383a86c6181SAlex Tomas {
1384a86c6181SAlex Tomas 	int depth;
1385a86c6181SAlex Tomas 
1386a86c6181SAlex Tomas 	BUG_ON(path == NULL);
1387a86c6181SAlex Tomas 	depth = path->p_depth;
1388a86c6181SAlex Tomas 
1389a86c6181SAlex Tomas 	if (depth == 0 && path->p_ext == NULL)
1390f17722f9SLukas Czerner 		return EXT_MAX_BLOCKS;
1391a86c6181SAlex Tomas 
1392a86c6181SAlex Tomas 	while (depth >= 0) {
1393a86c6181SAlex Tomas 		if (depth == path->p_depth) {
1394a86c6181SAlex Tomas 			/* leaf */
1395a86c6181SAlex Tomas 			if (path[depth].p_ext !=
1396a86c6181SAlex Tomas 					EXT_LAST_EXTENT(path[depth].p_hdr))
1397a86c6181SAlex Tomas 			  return le32_to_cpu(path[depth].p_ext[1].ee_block);
1398a86c6181SAlex Tomas 		} else {
1399a86c6181SAlex Tomas 			/* index */
1400a86c6181SAlex Tomas 			if (path[depth].p_idx !=
1401a86c6181SAlex Tomas 					EXT_LAST_INDEX(path[depth].p_hdr))
1402a86c6181SAlex Tomas 			  return le32_to_cpu(path[depth].p_idx[1].ei_block);
1403a86c6181SAlex Tomas 		}
1404a86c6181SAlex Tomas 		depth--;
1405a86c6181SAlex Tomas 	}
1406a86c6181SAlex Tomas 
1407f17722f9SLukas Czerner 	return EXT_MAX_BLOCKS;
1408a86c6181SAlex Tomas }
1409a86c6181SAlex Tomas 
1410a86c6181SAlex Tomas /*
1411d0d856e8SRandy Dunlap  * ext4_ext_next_leaf_block:
1412f17722f9SLukas Czerner  * returns first allocated block from next leaf or EXT_MAX_BLOCKS
1413a86c6181SAlex Tomas  */
14145718789dSRobin Dong static ext4_lblk_t ext4_ext_next_leaf_block(struct ext4_ext_path *path)
1415a86c6181SAlex Tomas {
1416a86c6181SAlex Tomas 	int depth;
1417a86c6181SAlex Tomas 
1418a86c6181SAlex Tomas 	BUG_ON(path == NULL);
1419a86c6181SAlex Tomas 	depth = path->p_depth;
1420a86c6181SAlex Tomas 
1421a86c6181SAlex Tomas 	/* zero-tree has no leaf blocks at all */
1422a86c6181SAlex Tomas 	if (depth == 0)
1423f17722f9SLukas Czerner 		return EXT_MAX_BLOCKS;
1424a86c6181SAlex Tomas 
1425a86c6181SAlex Tomas 	/* go to index block */
1426a86c6181SAlex Tomas 	depth--;
1427a86c6181SAlex Tomas 
1428a86c6181SAlex Tomas 	while (depth >= 0) {
1429a86c6181SAlex Tomas 		if (path[depth].p_idx !=
1430a86c6181SAlex Tomas 				EXT_LAST_INDEX(path[depth].p_hdr))
1431725d26d3SAneesh Kumar K.V 			return (ext4_lblk_t)
1432725d26d3SAneesh Kumar K.V 				le32_to_cpu(path[depth].p_idx[1].ei_block);
1433a86c6181SAlex Tomas 		depth--;
1434a86c6181SAlex Tomas 	}
1435a86c6181SAlex Tomas 
1436f17722f9SLukas Czerner 	return EXT_MAX_BLOCKS;
1437a86c6181SAlex Tomas }
1438a86c6181SAlex Tomas 
1439a86c6181SAlex Tomas /*
1440d0d856e8SRandy Dunlap  * ext4_ext_correct_indexes:
1441d0d856e8SRandy Dunlap  * if leaf gets modified and modified extent is first in the leaf,
1442d0d856e8SRandy Dunlap  * then we have to correct all indexes above.
1443a86c6181SAlex Tomas  * TODO: do we need to correct tree in all cases?
1444a86c6181SAlex Tomas  */
14451d03ec98SAneesh Kumar K.V static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
1446a86c6181SAlex Tomas 				struct ext4_ext_path *path)
1447a86c6181SAlex Tomas {
1448a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
1449a86c6181SAlex Tomas 	int depth = ext_depth(inode);
1450a86c6181SAlex Tomas 	struct ext4_extent *ex;
1451a86c6181SAlex Tomas 	__le32 border;
1452a86c6181SAlex Tomas 	int k, err = 0;
1453a86c6181SAlex Tomas 
1454a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
1455a86c6181SAlex Tomas 	ex = path[depth].p_ext;
1456273df556SFrank Mayhar 
1457273df556SFrank Mayhar 	if (unlikely(ex == NULL || eh == NULL)) {
1458273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode,
1459273df556SFrank Mayhar 				 "ex %p == NULL or eh %p == NULL", ex, eh);
1460273df556SFrank Mayhar 		return -EIO;
1461273df556SFrank Mayhar 	}
1462a86c6181SAlex Tomas 
1463a86c6181SAlex Tomas 	if (depth == 0) {
1464a86c6181SAlex Tomas 		/* there is no tree at all */
1465a86c6181SAlex Tomas 		return 0;
1466a86c6181SAlex Tomas 	}
1467a86c6181SAlex Tomas 
1468a86c6181SAlex Tomas 	if (ex != EXT_FIRST_EXTENT(eh)) {
1469a86c6181SAlex Tomas 		/* we correct tree if first leaf got modified only */
1470a86c6181SAlex Tomas 		return 0;
1471a86c6181SAlex Tomas 	}
1472a86c6181SAlex Tomas 
1473a86c6181SAlex Tomas 	/*
1474d0d856e8SRandy Dunlap 	 * TODO: we need correction if border is smaller than current one
1475a86c6181SAlex Tomas 	 */
1476a86c6181SAlex Tomas 	k = depth - 1;
1477a86c6181SAlex Tomas 	border = path[depth].p_ext->ee_block;
14787e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, path + k);
14797e028976SAvantika Mathur 	if (err)
1480a86c6181SAlex Tomas 		return err;
1481a86c6181SAlex Tomas 	path[k].p_idx->ei_block = border;
14827e028976SAvantika Mathur 	err = ext4_ext_dirty(handle, inode, path + k);
14837e028976SAvantika Mathur 	if (err)
1484a86c6181SAlex Tomas 		return err;
1485a86c6181SAlex Tomas 
1486a86c6181SAlex Tomas 	while (k--) {
1487a86c6181SAlex Tomas 		/* change all left-side indexes */
1488a86c6181SAlex Tomas 		if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr))
1489a86c6181SAlex Tomas 			break;
14907e028976SAvantika Mathur 		err = ext4_ext_get_access(handle, inode, path + k);
14917e028976SAvantika Mathur 		if (err)
1492a86c6181SAlex Tomas 			break;
1493a86c6181SAlex Tomas 		path[k].p_idx->ei_block = border;
14947e028976SAvantika Mathur 		err = ext4_ext_dirty(handle, inode, path + k);
14957e028976SAvantika Mathur 		if (err)
1496a86c6181SAlex Tomas 			break;
1497a86c6181SAlex Tomas 	}
1498a86c6181SAlex Tomas 
1499a86c6181SAlex Tomas 	return err;
1500a86c6181SAlex Tomas }
1501a86c6181SAlex Tomas 
1502748de673SAkira Fujita int
1503a86c6181SAlex Tomas ext4_can_extents_be_merged(struct inode *inode, struct ext4_extent *ex1,
1504a86c6181SAlex Tomas 				struct ext4_extent *ex2)
1505a86c6181SAlex Tomas {
1506749269faSAmit Arora 	unsigned short ext1_ee_len, ext2_ee_len, max_len;
1507a2df2a63SAmit Arora 
1508a2df2a63SAmit Arora 	/*
1509a2df2a63SAmit Arora 	 * Make sure that either both extents are uninitialized, or
1510a2df2a63SAmit Arora 	 * both are _not_.
1511a2df2a63SAmit Arora 	 */
1512a2df2a63SAmit Arora 	if (ext4_ext_is_uninitialized(ex1) ^ ext4_ext_is_uninitialized(ex2))
1513a2df2a63SAmit Arora 		return 0;
1514a2df2a63SAmit Arora 
1515749269faSAmit Arora 	if (ext4_ext_is_uninitialized(ex1))
1516749269faSAmit Arora 		max_len = EXT_UNINIT_MAX_LEN;
1517749269faSAmit Arora 	else
1518749269faSAmit Arora 		max_len = EXT_INIT_MAX_LEN;
1519749269faSAmit Arora 
1520a2df2a63SAmit Arora 	ext1_ee_len = ext4_ext_get_actual_len(ex1);
1521a2df2a63SAmit Arora 	ext2_ee_len = ext4_ext_get_actual_len(ex2);
1522a2df2a63SAmit Arora 
1523a2df2a63SAmit Arora 	if (le32_to_cpu(ex1->ee_block) + ext1_ee_len !=
152463f57933SAndrew Morton 			le32_to_cpu(ex2->ee_block))
1525a86c6181SAlex Tomas 		return 0;
1526a86c6181SAlex Tomas 
1527471d4011SSuparna Bhattacharya 	/*
1528471d4011SSuparna Bhattacharya 	 * To allow future support for preallocated extents to be added
1529471d4011SSuparna Bhattacharya 	 * as an RO_COMPAT feature, refuse to merge to extents if
1530d0d856e8SRandy Dunlap 	 * this can result in the top bit of ee_len being set.
1531471d4011SSuparna Bhattacharya 	 */
1532749269faSAmit Arora 	if (ext1_ee_len + ext2_ee_len > max_len)
1533471d4011SSuparna Bhattacharya 		return 0;
1534bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
1535b939e376SAneesh Kumar K.V 	if (ext1_ee_len >= 4)
1536a86c6181SAlex Tomas 		return 0;
1537a86c6181SAlex Tomas #endif
1538a86c6181SAlex Tomas 
1539bf89d16fSTheodore Ts'o 	if (ext4_ext_pblock(ex1) + ext1_ee_len == ext4_ext_pblock(ex2))
1540a86c6181SAlex Tomas 		return 1;
1541a86c6181SAlex Tomas 	return 0;
1542a86c6181SAlex Tomas }
1543a86c6181SAlex Tomas 
1544a86c6181SAlex Tomas /*
154556055d3aSAmit Arora  * This function tries to merge the "ex" extent to the next extent in the tree.
154656055d3aSAmit Arora  * It always tries to merge towards right. If you want to merge towards
154756055d3aSAmit Arora  * left, pass "ex - 1" as argument instead of "ex".
154856055d3aSAmit Arora  * Returns 0 if the extents (ex and ex+1) were _not_ merged and returns
154956055d3aSAmit Arora  * 1 if they got merged.
155056055d3aSAmit Arora  */
1551197217a5SYongqiang Yang static int ext4_ext_try_to_merge_right(struct inode *inode,
155256055d3aSAmit Arora 				 struct ext4_ext_path *path,
155356055d3aSAmit Arora 				 struct ext4_extent *ex)
155456055d3aSAmit Arora {
155556055d3aSAmit Arora 	struct ext4_extent_header *eh;
155656055d3aSAmit Arora 	unsigned int depth, len;
155756055d3aSAmit Arora 	int merge_done = 0;
155856055d3aSAmit Arora 	int uninitialized = 0;
155956055d3aSAmit Arora 
156056055d3aSAmit Arora 	depth = ext_depth(inode);
156156055d3aSAmit Arora 	BUG_ON(path[depth].p_hdr == NULL);
156256055d3aSAmit Arora 	eh = path[depth].p_hdr;
156356055d3aSAmit Arora 
156456055d3aSAmit Arora 	while (ex < EXT_LAST_EXTENT(eh)) {
156556055d3aSAmit Arora 		if (!ext4_can_extents_be_merged(inode, ex, ex + 1))
156656055d3aSAmit Arora 			break;
156756055d3aSAmit Arora 		/* merge with next extent! */
156856055d3aSAmit Arora 		if (ext4_ext_is_uninitialized(ex))
156956055d3aSAmit Arora 			uninitialized = 1;
157056055d3aSAmit Arora 		ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
157156055d3aSAmit Arora 				+ ext4_ext_get_actual_len(ex + 1));
157256055d3aSAmit Arora 		if (uninitialized)
157356055d3aSAmit Arora 			ext4_ext_mark_uninitialized(ex);
157456055d3aSAmit Arora 
157556055d3aSAmit Arora 		if (ex + 1 < EXT_LAST_EXTENT(eh)) {
157656055d3aSAmit Arora 			len = (EXT_LAST_EXTENT(eh) - ex - 1)
157756055d3aSAmit Arora 				* sizeof(struct ext4_extent);
157856055d3aSAmit Arora 			memmove(ex + 1, ex + 2, len);
157956055d3aSAmit Arora 		}
1580e8546d06SMarcin Slusarz 		le16_add_cpu(&eh->eh_entries, -1);
158156055d3aSAmit Arora 		merge_done = 1;
158256055d3aSAmit Arora 		WARN_ON(eh->eh_entries == 0);
158356055d3aSAmit Arora 		if (!eh->eh_entries)
158424676da4STheodore Ts'o 			EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!");
158556055d3aSAmit Arora 	}
158656055d3aSAmit Arora 
158756055d3aSAmit Arora 	return merge_done;
158856055d3aSAmit Arora }
158956055d3aSAmit Arora 
159056055d3aSAmit Arora /*
1591197217a5SYongqiang Yang  * This function tries to merge the @ex extent to neighbours in the tree.
1592197217a5SYongqiang Yang  * return 1 if merge left else 0.
1593197217a5SYongqiang Yang  */
1594197217a5SYongqiang Yang static int ext4_ext_try_to_merge(struct inode *inode,
1595197217a5SYongqiang Yang 				  struct ext4_ext_path *path,
1596197217a5SYongqiang Yang 				  struct ext4_extent *ex) {
1597197217a5SYongqiang Yang 	struct ext4_extent_header *eh;
1598197217a5SYongqiang Yang 	unsigned int depth;
1599197217a5SYongqiang Yang 	int merge_done = 0;
1600197217a5SYongqiang Yang 	int ret = 0;
1601197217a5SYongqiang Yang 
1602197217a5SYongqiang Yang 	depth = ext_depth(inode);
1603197217a5SYongqiang Yang 	BUG_ON(path[depth].p_hdr == NULL);
1604197217a5SYongqiang Yang 	eh = path[depth].p_hdr;
1605197217a5SYongqiang Yang 
1606197217a5SYongqiang Yang 	if (ex > EXT_FIRST_EXTENT(eh))
1607197217a5SYongqiang Yang 		merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1);
1608197217a5SYongqiang Yang 
1609197217a5SYongqiang Yang 	if (!merge_done)
1610197217a5SYongqiang Yang 		ret = ext4_ext_try_to_merge_right(inode, path, ex);
1611197217a5SYongqiang Yang 
1612197217a5SYongqiang Yang 	return ret;
1613197217a5SYongqiang Yang }
1614197217a5SYongqiang Yang 
1615197217a5SYongqiang Yang /*
161625d14f98SAmit Arora  * check if a portion of the "newext" extent overlaps with an
161725d14f98SAmit Arora  * existing extent.
161825d14f98SAmit Arora  *
161925d14f98SAmit Arora  * If there is an overlap discovered, it updates the length of the newext
162025d14f98SAmit Arora  * such that there will be no overlap, and then returns 1.
162125d14f98SAmit Arora  * If there is no overlap found, it returns 0.
162225d14f98SAmit Arora  */
16234d33b1efSTheodore Ts'o static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi,
16244d33b1efSTheodore Ts'o 					   struct inode *inode,
162525d14f98SAmit Arora 					   struct ext4_extent *newext,
162625d14f98SAmit Arora 					   struct ext4_ext_path *path)
162725d14f98SAmit Arora {
1628725d26d3SAneesh Kumar K.V 	ext4_lblk_t b1, b2;
162925d14f98SAmit Arora 	unsigned int depth, len1;
163025d14f98SAmit Arora 	unsigned int ret = 0;
163125d14f98SAmit Arora 
163225d14f98SAmit Arora 	b1 = le32_to_cpu(newext->ee_block);
1633a2df2a63SAmit Arora 	len1 = ext4_ext_get_actual_len(newext);
163425d14f98SAmit Arora 	depth = ext_depth(inode);
163525d14f98SAmit Arora 	if (!path[depth].p_ext)
163625d14f98SAmit Arora 		goto out;
163725d14f98SAmit Arora 	b2 = le32_to_cpu(path[depth].p_ext->ee_block);
16384d33b1efSTheodore Ts'o 	b2 &= ~(sbi->s_cluster_ratio - 1);
163925d14f98SAmit Arora 
164025d14f98SAmit Arora 	/*
164125d14f98SAmit Arora 	 * get the next allocated block if the extent in the path
164225d14f98SAmit Arora 	 * is before the requested block(s)
164325d14f98SAmit Arora 	 */
164425d14f98SAmit Arora 	if (b2 < b1) {
164525d14f98SAmit Arora 		b2 = ext4_ext_next_allocated_block(path);
1646f17722f9SLukas Czerner 		if (b2 == EXT_MAX_BLOCKS)
164725d14f98SAmit Arora 			goto out;
16484d33b1efSTheodore Ts'o 		b2 &= ~(sbi->s_cluster_ratio - 1);
164925d14f98SAmit Arora 	}
165025d14f98SAmit Arora 
1651725d26d3SAneesh Kumar K.V 	/* check for wrap through zero on extent logical start block*/
165225d14f98SAmit Arora 	if (b1 + len1 < b1) {
1653f17722f9SLukas Czerner 		len1 = EXT_MAX_BLOCKS - b1;
165425d14f98SAmit Arora 		newext->ee_len = cpu_to_le16(len1);
165525d14f98SAmit Arora 		ret = 1;
165625d14f98SAmit Arora 	}
165725d14f98SAmit Arora 
165825d14f98SAmit Arora 	/* check for overlap */
165925d14f98SAmit Arora 	if (b1 + len1 > b2) {
166025d14f98SAmit Arora 		newext->ee_len = cpu_to_le16(b2 - b1);
166125d14f98SAmit Arora 		ret = 1;
166225d14f98SAmit Arora 	}
166325d14f98SAmit Arora out:
166425d14f98SAmit Arora 	return ret;
166525d14f98SAmit Arora }
166625d14f98SAmit Arora 
166725d14f98SAmit Arora /*
1668d0d856e8SRandy Dunlap  * ext4_ext_insert_extent:
1669d0d856e8SRandy Dunlap  * tries to merge requsted extent into the existing extent or
1670d0d856e8SRandy Dunlap  * inserts requested extent as new one into the tree,
1671d0d856e8SRandy Dunlap  * creating new leaf in the no-space case.
1672a86c6181SAlex Tomas  */
1673a86c6181SAlex Tomas int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1674a86c6181SAlex Tomas 				struct ext4_ext_path *path,
16750031462bSMingming Cao 				struct ext4_extent *newext, int flag)
1676a86c6181SAlex Tomas {
1677a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
1678a86c6181SAlex Tomas 	struct ext4_extent *ex, *fex;
1679a86c6181SAlex Tomas 	struct ext4_extent *nearex; /* nearest extent */
1680a86c6181SAlex Tomas 	struct ext4_ext_path *npath = NULL;
1681725d26d3SAneesh Kumar K.V 	int depth, len, err;
1682725d26d3SAneesh Kumar K.V 	ext4_lblk_t next;
1683a2df2a63SAmit Arora 	unsigned uninitialized = 0;
168455f020dbSAllison Henderson 	int flags = 0;
1685a86c6181SAlex Tomas 
1686273df556SFrank Mayhar 	if (unlikely(ext4_ext_get_actual_len(newext) == 0)) {
1687273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
1688273df556SFrank Mayhar 		return -EIO;
1689273df556SFrank Mayhar 	}
1690a86c6181SAlex Tomas 	depth = ext_depth(inode);
1691a86c6181SAlex Tomas 	ex = path[depth].p_ext;
1692273df556SFrank Mayhar 	if (unlikely(path[depth].p_hdr == NULL)) {
1693273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
1694273df556SFrank Mayhar 		return -EIO;
1695273df556SFrank Mayhar 	}
1696a86c6181SAlex Tomas 
1697a86c6181SAlex Tomas 	/* try to insert block into found extent and return */
1698744692dcSJiaying Zhang 	if (ex && !(flag & EXT4_GET_BLOCKS_PRE_IO)
16990031462bSMingming Cao 		&& ext4_can_extents_be_merged(inode, ex, newext)) {
1700553f9008SMingming 		ext_debug("append [%d]%d block to %d:[%d]%d (from %llu)\n",
1701553f9008SMingming 			  ext4_ext_is_uninitialized(newext),
1702a2df2a63SAmit Arora 			  ext4_ext_get_actual_len(newext),
1703a86c6181SAlex Tomas 			  le32_to_cpu(ex->ee_block),
1704553f9008SMingming 			  ext4_ext_is_uninitialized(ex),
1705bf89d16fSTheodore Ts'o 			  ext4_ext_get_actual_len(ex),
1706bf89d16fSTheodore Ts'o 			  ext4_ext_pblock(ex));
17077e028976SAvantika Mathur 		err = ext4_ext_get_access(handle, inode, path + depth);
17087e028976SAvantika Mathur 		if (err)
1709a86c6181SAlex Tomas 			return err;
1710a2df2a63SAmit Arora 
1711a2df2a63SAmit Arora 		/*
1712a2df2a63SAmit Arora 		 * ext4_can_extents_be_merged should have checked that either
1713a2df2a63SAmit Arora 		 * both extents are uninitialized, or both aren't. Thus we
1714a2df2a63SAmit Arora 		 * need to check only one of them here.
1715a2df2a63SAmit Arora 		 */
1716a2df2a63SAmit Arora 		if (ext4_ext_is_uninitialized(ex))
1717a2df2a63SAmit Arora 			uninitialized = 1;
1718a2df2a63SAmit Arora 		ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
1719a2df2a63SAmit Arora 					+ ext4_ext_get_actual_len(newext));
1720a2df2a63SAmit Arora 		if (uninitialized)
1721a2df2a63SAmit Arora 			ext4_ext_mark_uninitialized(ex);
1722a86c6181SAlex Tomas 		eh = path[depth].p_hdr;
1723a86c6181SAlex Tomas 		nearex = ex;
1724a86c6181SAlex Tomas 		goto merge;
1725a86c6181SAlex Tomas 	}
1726a86c6181SAlex Tomas 
1727a86c6181SAlex Tomas 	depth = ext_depth(inode);
1728a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
1729a86c6181SAlex Tomas 	if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max))
1730a86c6181SAlex Tomas 		goto has_space;
1731a86c6181SAlex Tomas 
1732a86c6181SAlex Tomas 	/* probably next leaf has space for us? */
1733a86c6181SAlex Tomas 	fex = EXT_LAST_EXTENT(eh);
1734598dbdf2SRobin Dong 	next = EXT_MAX_BLOCKS;
1735598dbdf2SRobin Dong 	if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block))
17365718789dSRobin Dong 		next = ext4_ext_next_leaf_block(path);
1737598dbdf2SRobin Dong 	if (next != EXT_MAX_BLOCKS) {
1738a86c6181SAlex Tomas 		ext_debug("next leaf block - %d\n", next);
1739a86c6181SAlex Tomas 		BUG_ON(npath != NULL);
1740a86c6181SAlex Tomas 		npath = ext4_ext_find_extent(inode, next, NULL);
1741a86c6181SAlex Tomas 		if (IS_ERR(npath))
1742a86c6181SAlex Tomas 			return PTR_ERR(npath);
1743a86c6181SAlex Tomas 		BUG_ON(npath->p_depth != path->p_depth);
1744a86c6181SAlex Tomas 		eh = npath[depth].p_hdr;
1745a86c6181SAlex Tomas 		if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) {
174625985edcSLucas De Marchi 			ext_debug("next leaf isn't full(%d)\n",
1747a86c6181SAlex Tomas 				  le16_to_cpu(eh->eh_entries));
1748a86c6181SAlex Tomas 			path = npath;
1749ffb505ffSRobin Dong 			goto has_space;
1750a86c6181SAlex Tomas 		}
1751a86c6181SAlex Tomas 		ext_debug("next leaf has no free space(%d,%d)\n",
1752a86c6181SAlex Tomas 			  le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
1753a86c6181SAlex Tomas 	}
1754a86c6181SAlex Tomas 
1755a86c6181SAlex Tomas 	/*
1756d0d856e8SRandy Dunlap 	 * There is no free space in the found leaf.
1757d0d856e8SRandy Dunlap 	 * We're gonna add a new leaf in the tree.
1758a86c6181SAlex Tomas 	 */
175955f020dbSAllison Henderson 	if (flag & EXT4_GET_BLOCKS_PUNCH_OUT_EXT)
176055f020dbSAllison Henderson 		flags = EXT4_MB_USE_ROOT_BLOCKS;
176155f020dbSAllison Henderson 	err = ext4_ext_create_new_leaf(handle, inode, flags, path, newext);
1762a86c6181SAlex Tomas 	if (err)
1763a86c6181SAlex Tomas 		goto cleanup;
1764a86c6181SAlex Tomas 	depth = ext_depth(inode);
1765a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
1766a86c6181SAlex Tomas 
1767a86c6181SAlex Tomas has_space:
1768a86c6181SAlex Tomas 	nearex = path[depth].p_ext;
1769a86c6181SAlex Tomas 
17707e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, path + depth);
17717e028976SAvantika Mathur 	if (err)
1772a86c6181SAlex Tomas 		goto cleanup;
1773a86c6181SAlex Tomas 
1774a86c6181SAlex Tomas 	if (!nearex) {
1775a86c6181SAlex Tomas 		/* there is no extent in this leaf, create first one */
1776553f9008SMingming 		ext_debug("first extent in the leaf: %d:%llu:[%d]%d\n",
1777a86c6181SAlex Tomas 				le32_to_cpu(newext->ee_block),
1778bf89d16fSTheodore Ts'o 				ext4_ext_pblock(newext),
1779553f9008SMingming 				ext4_ext_is_uninitialized(newext),
1780a2df2a63SAmit Arora 				ext4_ext_get_actual_len(newext));
1781a86c6181SAlex Tomas 		path[depth].p_ext = EXT_FIRST_EXTENT(eh);
1782a86c6181SAlex Tomas 	} else if (le32_to_cpu(newext->ee_block)
1783a86c6181SAlex Tomas 			   > le32_to_cpu(nearex->ee_block)) {
1784a86c6181SAlex Tomas /*		BUG_ON(newext->ee_block == nearex->ee_block); */
1785a86c6181SAlex Tomas 		if (nearex != EXT_LAST_EXTENT(eh)) {
1786a86c6181SAlex Tomas 			len = EXT_MAX_EXTENT(eh) - nearex;
1787a86c6181SAlex Tomas 			len = (len - 1) * sizeof(struct ext4_extent);
1788a86c6181SAlex Tomas 			len = len < 0 ? 0 : len;
1789553f9008SMingming 			ext_debug("insert %d:%llu:[%d]%d after: nearest 0x%p, "
1790a86c6181SAlex Tomas 					"move %d from 0x%p to 0x%p\n",
1791a86c6181SAlex Tomas 					le32_to_cpu(newext->ee_block),
1792bf89d16fSTheodore Ts'o 					ext4_ext_pblock(newext),
1793553f9008SMingming 					ext4_ext_is_uninitialized(newext),
1794a2df2a63SAmit Arora 					ext4_ext_get_actual_len(newext),
1795a86c6181SAlex Tomas 					nearex, len, nearex + 1, nearex + 2);
1796a86c6181SAlex Tomas 			memmove(nearex + 2, nearex + 1, len);
1797a86c6181SAlex Tomas 		}
1798a86c6181SAlex Tomas 		path[depth].p_ext = nearex + 1;
1799a86c6181SAlex Tomas 	} else {
1800a86c6181SAlex Tomas 		BUG_ON(newext->ee_block == nearex->ee_block);
1801a86c6181SAlex Tomas 		len = (EXT_MAX_EXTENT(eh) - nearex) * sizeof(struct ext4_extent);
1802a86c6181SAlex Tomas 		len = len < 0 ? 0 : len;
1803553f9008SMingming 		ext_debug("insert %d:%llu:[%d]%d before: nearest 0x%p, "
1804a86c6181SAlex Tomas 				"move %d from 0x%p to 0x%p\n",
1805a86c6181SAlex Tomas 				le32_to_cpu(newext->ee_block),
1806bf89d16fSTheodore Ts'o 				ext4_ext_pblock(newext),
1807553f9008SMingming 				ext4_ext_is_uninitialized(newext),
1808a2df2a63SAmit Arora 				ext4_ext_get_actual_len(newext),
18090737964bSRobin Dong 				nearex, len, nearex, nearex + 1);
1810a86c6181SAlex Tomas 		memmove(nearex + 1, nearex, len);
1811a86c6181SAlex Tomas 		path[depth].p_ext = nearex;
1812a86c6181SAlex Tomas 	}
1813a86c6181SAlex Tomas 
1814e8546d06SMarcin Slusarz 	le16_add_cpu(&eh->eh_entries, 1);
1815a86c6181SAlex Tomas 	nearex = path[depth].p_ext;
1816a86c6181SAlex Tomas 	nearex->ee_block = newext->ee_block;
1817bf89d16fSTheodore Ts'o 	ext4_ext_store_pblock(nearex, ext4_ext_pblock(newext));
1818a86c6181SAlex Tomas 	nearex->ee_len = newext->ee_len;
1819a86c6181SAlex Tomas 
1820a86c6181SAlex Tomas merge:
1821a86c6181SAlex Tomas 	/* try to merge extents to the right */
1822744692dcSJiaying Zhang 	if (!(flag & EXT4_GET_BLOCKS_PRE_IO))
182356055d3aSAmit Arora 		ext4_ext_try_to_merge(inode, path, nearex);
1824a86c6181SAlex Tomas 
1825a86c6181SAlex Tomas 	/* try to merge extents to the left */
1826a86c6181SAlex Tomas 
1827a86c6181SAlex Tomas 	/* time to correct all indexes above */
1828a86c6181SAlex Tomas 	err = ext4_ext_correct_indexes(handle, inode, path);
1829a86c6181SAlex Tomas 	if (err)
1830a86c6181SAlex Tomas 		goto cleanup;
1831a86c6181SAlex Tomas 
1832a86c6181SAlex Tomas 	err = ext4_ext_dirty(handle, inode, path + depth);
1833a86c6181SAlex Tomas 
1834a86c6181SAlex Tomas cleanup:
1835a86c6181SAlex Tomas 	if (npath) {
1836a86c6181SAlex Tomas 		ext4_ext_drop_refs(npath);
1837a86c6181SAlex Tomas 		kfree(npath);
1838a86c6181SAlex Tomas 	}
1839a86c6181SAlex Tomas 	ext4_ext_invalidate_cache(inode);
1840a86c6181SAlex Tomas 	return err;
1841a86c6181SAlex Tomas }
1842a86c6181SAlex Tomas 
18431f109d5aSTheodore Ts'o static int ext4_ext_walk_space(struct inode *inode, ext4_lblk_t block,
18446873fa0dSEric Sandeen 			       ext4_lblk_t num, ext_prepare_callback func,
18456873fa0dSEric Sandeen 			       void *cbdata)
18466873fa0dSEric Sandeen {
18476873fa0dSEric Sandeen 	struct ext4_ext_path *path = NULL;
18486873fa0dSEric Sandeen 	struct ext4_ext_cache cbex;
18496873fa0dSEric Sandeen 	struct ext4_extent *ex;
18506873fa0dSEric Sandeen 	ext4_lblk_t next, start = 0, end = 0;
18516873fa0dSEric Sandeen 	ext4_lblk_t last = block + num;
18526873fa0dSEric Sandeen 	int depth, exists, err = 0;
18536873fa0dSEric Sandeen 
18546873fa0dSEric Sandeen 	BUG_ON(func == NULL);
18556873fa0dSEric Sandeen 	BUG_ON(inode == NULL);
18566873fa0dSEric Sandeen 
1857f17722f9SLukas Czerner 	while (block < last && block != EXT_MAX_BLOCKS) {
18586873fa0dSEric Sandeen 		num = last - block;
18596873fa0dSEric Sandeen 		/* find extent for this block */
1860fab3a549STheodore Ts'o 		down_read(&EXT4_I(inode)->i_data_sem);
18616873fa0dSEric Sandeen 		path = ext4_ext_find_extent(inode, block, path);
1862fab3a549STheodore Ts'o 		up_read(&EXT4_I(inode)->i_data_sem);
18636873fa0dSEric Sandeen 		if (IS_ERR(path)) {
18646873fa0dSEric Sandeen 			err = PTR_ERR(path);
18656873fa0dSEric Sandeen 			path = NULL;
18666873fa0dSEric Sandeen 			break;
18676873fa0dSEric Sandeen 		}
18686873fa0dSEric Sandeen 
18696873fa0dSEric Sandeen 		depth = ext_depth(inode);
1870273df556SFrank Mayhar 		if (unlikely(path[depth].p_hdr == NULL)) {
1871273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
1872273df556SFrank Mayhar 			err = -EIO;
1873273df556SFrank Mayhar 			break;
1874273df556SFrank Mayhar 		}
18756873fa0dSEric Sandeen 		ex = path[depth].p_ext;
18766873fa0dSEric Sandeen 		next = ext4_ext_next_allocated_block(path);
18776873fa0dSEric Sandeen 
18786873fa0dSEric Sandeen 		exists = 0;
18796873fa0dSEric Sandeen 		if (!ex) {
18806873fa0dSEric Sandeen 			/* there is no extent yet, so try to allocate
18816873fa0dSEric Sandeen 			 * all requested space */
18826873fa0dSEric Sandeen 			start = block;
18836873fa0dSEric Sandeen 			end = block + num;
18846873fa0dSEric Sandeen 		} else if (le32_to_cpu(ex->ee_block) > block) {
18856873fa0dSEric Sandeen 			/* need to allocate space before found extent */
18866873fa0dSEric Sandeen 			start = block;
18876873fa0dSEric Sandeen 			end = le32_to_cpu(ex->ee_block);
18886873fa0dSEric Sandeen 			if (block + num < end)
18896873fa0dSEric Sandeen 				end = block + num;
18906873fa0dSEric Sandeen 		} else if (block >= le32_to_cpu(ex->ee_block)
18916873fa0dSEric Sandeen 					+ ext4_ext_get_actual_len(ex)) {
18926873fa0dSEric Sandeen 			/* need to allocate space after found extent */
18936873fa0dSEric Sandeen 			start = block;
18946873fa0dSEric Sandeen 			end = block + num;
18956873fa0dSEric Sandeen 			if (end >= next)
18966873fa0dSEric Sandeen 				end = next;
18976873fa0dSEric Sandeen 		} else if (block >= le32_to_cpu(ex->ee_block)) {
18986873fa0dSEric Sandeen 			/*
18996873fa0dSEric Sandeen 			 * some part of requested space is covered
19006873fa0dSEric Sandeen 			 * by found extent
19016873fa0dSEric Sandeen 			 */
19026873fa0dSEric Sandeen 			start = block;
19036873fa0dSEric Sandeen 			end = le32_to_cpu(ex->ee_block)
19046873fa0dSEric Sandeen 				+ ext4_ext_get_actual_len(ex);
19056873fa0dSEric Sandeen 			if (block + num < end)
19066873fa0dSEric Sandeen 				end = block + num;
19076873fa0dSEric Sandeen 			exists = 1;
19086873fa0dSEric Sandeen 		} else {
19096873fa0dSEric Sandeen 			BUG();
19106873fa0dSEric Sandeen 		}
19116873fa0dSEric Sandeen 		BUG_ON(end <= start);
19126873fa0dSEric Sandeen 
19136873fa0dSEric Sandeen 		if (!exists) {
19146873fa0dSEric Sandeen 			cbex.ec_block = start;
19156873fa0dSEric Sandeen 			cbex.ec_len = end - start;
19166873fa0dSEric Sandeen 			cbex.ec_start = 0;
19176873fa0dSEric Sandeen 		} else {
19186873fa0dSEric Sandeen 			cbex.ec_block = le32_to_cpu(ex->ee_block);
19196873fa0dSEric Sandeen 			cbex.ec_len = ext4_ext_get_actual_len(ex);
1920bf89d16fSTheodore Ts'o 			cbex.ec_start = ext4_ext_pblock(ex);
19216873fa0dSEric Sandeen 		}
19226873fa0dSEric Sandeen 
1923273df556SFrank Mayhar 		if (unlikely(cbex.ec_len == 0)) {
1924273df556SFrank Mayhar 			EXT4_ERROR_INODE(inode, "cbex.ec_len == 0");
1925273df556SFrank Mayhar 			err = -EIO;
1926273df556SFrank Mayhar 			break;
1927273df556SFrank Mayhar 		}
1928c03f8aa9SLukas Czerner 		err = func(inode, next, &cbex, ex, cbdata);
19296873fa0dSEric Sandeen 		ext4_ext_drop_refs(path);
19306873fa0dSEric Sandeen 
19316873fa0dSEric Sandeen 		if (err < 0)
19326873fa0dSEric Sandeen 			break;
19336873fa0dSEric Sandeen 
19346873fa0dSEric Sandeen 		if (err == EXT_REPEAT)
19356873fa0dSEric Sandeen 			continue;
19366873fa0dSEric Sandeen 		else if (err == EXT_BREAK) {
19376873fa0dSEric Sandeen 			err = 0;
19386873fa0dSEric Sandeen 			break;
19396873fa0dSEric Sandeen 		}
19406873fa0dSEric Sandeen 
19416873fa0dSEric Sandeen 		if (ext_depth(inode) != depth) {
19426873fa0dSEric Sandeen 			/* depth was changed. we have to realloc path */
19436873fa0dSEric Sandeen 			kfree(path);
19446873fa0dSEric Sandeen 			path = NULL;
19456873fa0dSEric Sandeen 		}
19466873fa0dSEric Sandeen 
19476873fa0dSEric Sandeen 		block = cbex.ec_block + cbex.ec_len;
19486873fa0dSEric Sandeen 	}
19496873fa0dSEric Sandeen 
19506873fa0dSEric Sandeen 	if (path) {
19516873fa0dSEric Sandeen 		ext4_ext_drop_refs(path);
19526873fa0dSEric Sandeen 		kfree(path);
19536873fa0dSEric Sandeen 	}
19546873fa0dSEric Sandeen 
19556873fa0dSEric Sandeen 	return err;
19566873fa0dSEric Sandeen }
19576873fa0dSEric Sandeen 
195809b88252SAvantika Mathur static void
1959725d26d3SAneesh Kumar K.V ext4_ext_put_in_cache(struct inode *inode, ext4_lblk_t block,
1960b05e6ae5STheodore Ts'o 			__u32 len, ext4_fsblk_t start)
1961a86c6181SAlex Tomas {
1962a86c6181SAlex Tomas 	struct ext4_ext_cache *cex;
1963a86c6181SAlex Tomas 	BUG_ON(len == 0);
19642ec0ae3aSTheodore Ts'o 	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1965d8990240SAditya Kali 	trace_ext4_ext_put_in_cache(inode, block, len, start);
1966a86c6181SAlex Tomas 	cex = &EXT4_I(inode)->i_cached_extent;
1967a86c6181SAlex Tomas 	cex->ec_block = block;
1968a86c6181SAlex Tomas 	cex->ec_len = len;
1969a86c6181SAlex Tomas 	cex->ec_start = start;
19702ec0ae3aSTheodore Ts'o 	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1971a86c6181SAlex Tomas }
1972a86c6181SAlex Tomas 
1973a86c6181SAlex Tomas /*
1974d0d856e8SRandy Dunlap  * ext4_ext_put_gap_in_cache:
1975d0d856e8SRandy Dunlap  * calculate boundaries of the gap that the requested block fits into
1976a86c6181SAlex Tomas  * and cache this gap
1977a86c6181SAlex Tomas  */
197809b88252SAvantika Mathur static void
1979a86c6181SAlex Tomas ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
1980725d26d3SAneesh Kumar K.V 				ext4_lblk_t block)
1981a86c6181SAlex Tomas {
1982a86c6181SAlex Tomas 	int depth = ext_depth(inode);
1983725d26d3SAneesh Kumar K.V 	unsigned long len;
1984725d26d3SAneesh Kumar K.V 	ext4_lblk_t lblock;
1985a86c6181SAlex Tomas 	struct ext4_extent *ex;
1986a86c6181SAlex Tomas 
1987a86c6181SAlex Tomas 	ex = path[depth].p_ext;
1988a86c6181SAlex Tomas 	if (ex == NULL) {
1989a86c6181SAlex Tomas 		/* there is no extent yet, so gap is [0;-] */
1990a86c6181SAlex Tomas 		lblock = 0;
1991f17722f9SLukas Czerner 		len = EXT_MAX_BLOCKS;
1992a86c6181SAlex Tomas 		ext_debug("cache gap(whole file):");
1993a86c6181SAlex Tomas 	} else if (block < le32_to_cpu(ex->ee_block)) {
1994a86c6181SAlex Tomas 		lblock = block;
1995a86c6181SAlex Tomas 		len = le32_to_cpu(ex->ee_block) - block;
1996bba90743SEric Sandeen 		ext_debug("cache gap(before): %u [%u:%u]",
1997bba90743SEric Sandeen 				block,
1998bba90743SEric Sandeen 				le32_to_cpu(ex->ee_block),
1999bba90743SEric Sandeen 				 ext4_ext_get_actual_len(ex));
2000a86c6181SAlex Tomas 	} else if (block >= le32_to_cpu(ex->ee_block)
2001a2df2a63SAmit Arora 			+ ext4_ext_get_actual_len(ex)) {
2002725d26d3SAneesh Kumar K.V 		ext4_lblk_t next;
2003a86c6181SAlex Tomas 		lblock = le32_to_cpu(ex->ee_block)
2004a2df2a63SAmit Arora 			+ ext4_ext_get_actual_len(ex);
2005725d26d3SAneesh Kumar K.V 
2006725d26d3SAneesh Kumar K.V 		next = ext4_ext_next_allocated_block(path);
2007bba90743SEric Sandeen 		ext_debug("cache gap(after): [%u:%u] %u",
2008bba90743SEric Sandeen 				le32_to_cpu(ex->ee_block),
2009bba90743SEric Sandeen 				ext4_ext_get_actual_len(ex),
2010bba90743SEric Sandeen 				block);
2011725d26d3SAneesh Kumar K.V 		BUG_ON(next == lblock);
2012725d26d3SAneesh Kumar K.V 		len = next - lblock;
2013a86c6181SAlex Tomas 	} else {
2014a86c6181SAlex Tomas 		lblock = len = 0;
2015a86c6181SAlex Tomas 		BUG();
2016a86c6181SAlex Tomas 	}
2017a86c6181SAlex Tomas 
2018bba90743SEric Sandeen 	ext_debug(" -> %u:%lu\n", lblock, len);
2019b05e6ae5STheodore Ts'o 	ext4_ext_put_in_cache(inode, lblock, len, 0);
2020a86c6181SAlex Tomas }
2021a86c6181SAlex Tomas 
2022b05e6ae5STheodore Ts'o /*
2023b7ca1e8eSRobin Dong  * ext4_ext_check_cache()
2024a4bb6b64SAllison Henderson  * Checks to see if the given block is in the cache.
2025a4bb6b64SAllison Henderson  * If it is, the cached extent is stored in the given
2026a4bb6b64SAllison Henderson  * cache extent pointer.  If the cached extent is a hole,
2027a4bb6b64SAllison Henderson  * this routine should be used instead of
2028a4bb6b64SAllison Henderson  * ext4_ext_in_cache if the calling function needs to
2029a4bb6b64SAllison Henderson  * know the size of the hole.
2030a4bb6b64SAllison Henderson  *
2031a4bb6b64SAllison Henderson  * @inode: The files inode
2032a4bb6b64SAllison Henderson  * @block: The block to look for in the cache
2033a4bb6b64SAllison Henderson  * @ex:    Pointer where the cached extent will be stored
2034a4bb6b64SAllison Henderson  *         if it contains block
2035a4bb6b64SAllison Henderson  *
2036b05e6ae5STheodore Ts'o  * Return 0 if cache is invalid; 1 if the cache is valid
2037b05e6ae5STheodore Ts'o  */
2038a4bb6b64SAllison Henderson static int ext4_ext_check_cache(struct inode *inode, ext4_lblk_t block,
2039a4bb6b64SAllison Henderson 	struct ext4_ext_cache *ex){
2040a86c6181SAlex Tomas 	struct ext4_ext_cache *cex;
204177f4135fSVivek Haldar 	struct ext4_sb_info *sbi;
2042b05e6ae5STheodore Ts'o 	int ret = 0;
2043a86c6181SAlex Tomas 
20442ec0ae3aSTheodore Ts'o 	/*
20452ec0ae3aSTheodore Ts'o 	 * We borrow i_block_reservation_lock to protect i_cached_extent
20462ec0ae3aSTheodore Ts'o 	 */
20472ec0ae3aSTheodore Ts'o 	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
2048a86c6181SAlex Tomas 	cex = &EXT4_I(inode)->i_cached_extent;
204977f4135fSVivek Haldar 	sbi = EXT4_SB(inode->i_sb);
2050a86c6181SAlex Tomas 
2051a86c6181SAlex Tomas 	/* has cache valid data? */
2052b05e6ae5STheodore Ts'o 	if (cex->ec_len == 0)
20532ec0ae3aSTheodore Ts'o 		goto errout;
2054a86c6181SAlex Tomas 
2055731eb1a0SAkinobu Mita 	if (in_range(block, cex->ec_block, cex->ec_len)) {
2056a4bb6b64SAllison Henderson 		memcpy(ex, cex, sizeof(struct ext4_ext_cache));
2057bba90743SEric Sandeen 		ext_debug("%u cached by %u:%u:%llu\n",
2058bba90743SEric Sandeen 				block,
2059bba90743SEric Sandeen 				cex->ec_block, cex->ec_len, cex->ec_start);
2060b05e6ae5STheodore Ts'o 		ret = 1;
2061a86c6181SAlex Tomas 	}
20622ec0ae3aSTheodore Ts'o errout:
206377f4135fSVivek Haldar 	if (!ret)
206477f4135fSVivek Haldar 		sbi->extent_cache_misses++;
206577f4135fSVivek Haldar 	else
206677f4135fSVivek Haldar 		sbi->extent_cache_hits++;
2067d8990240SAditya Kali 	trace_ext4_ext_in_cache(inode, block, ret);
20682ec0ae3aSTheodore Ts'o 	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
20692ec0ae3aSTheodore Ts'o 	return ret;
2070a86c6181SAlex Tomas }
2071a86c6181SAlex Tomas 
2072a86c6181SAlex Tomas /*
2073a4bb6b64SAllison Henderson  * ext4_ext_in_cache()
2074a4bb6b64SAllison Henderson  * Checks to see if the given block is in the cache.
2075a4bb6b64SAllison Henderson  * If it is, the cached extent is stored in the given
2076a4bb6b64SAllison Henderson  * extent pointer.
2077a4bb6b64SAllison Henderson  *
2078a4bb6b64SAllison Henderson  * @inode: The files inode
2079a4bb6b64SAllison Henderson  * @block: The block to look for in the cache
2080a4bb6b64SAllison Henderson  * @ex:    Pointer where the cached extent will be stored
2081a4bb6b64SAllison Henderson  *         if it contains block
2082a4bb6b64SAllison Henderson  *
2083a4bb6b64SAllison Henderson  * Return 0 if cache is invalid; 1 if the cache is valid
2084a4bb6b64SAllison Henderson  */
2085a4bb6b64SAllison Henderson static int
2086a4bb6b64SAllison Henderson ext4_ext_in_cache(struct inode *inode, ext4_lblk_t block,
2087a4bb6b64SAllison Henderson 			struct ext4_extent *ex)
2088a4bb6b64SAllison Henderson {
2089a4bb6b64SAllison Henderson 	struct ext4_ext_cache cex;
2090a4bb6b64SAllison Henderson 	int ret = 0;
2091a4bb6b64SAllison Henderson 
2092a4bb6b64SAllison Henderson 	if (ext4_ext_check_cache(inode, block, &cex)) {
2093a4bb6b64SAllison Henderson 		ex->ee_block = cpu_to_le32(cex.ec_block);
2094a4bb6b64SAllison Henderson 		ext4_ext_store_pblock(ex, cex.ec_start);
2095a4bb6b64SAllison Henderson 		ex->ee_len = cpu_to_le16(cex.ec_len);
2096a4bb6b64SAllison Henderson 		ret = 1;
2097a4bb6b64SAllison Henderson 	}
2098a4bb6b64SAllison Henderson 
2099a4bb6b64SAllison Henderson 	return ret;
2100a4bb6b64SAllison Henderson }
2101a4bb6b64SAllison Henderson 
2102a4bb6b64SAllison Henderson 
2103a4bb6b64SAllison Henderson /*
2104d0d856e8SRandy Dunlap  * ext4_ext_rm_idx:
2105d0d856e8SRandy Dunlap  * removes index from the index block.
2106a86c6181SAlex Tomas  */
21071d03ec98SAneesh Kumar K.V static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
2108a86c6181SAlex Tomas 			struct ext4_ext_path *path)
2109a86c6181SAlex Tomas {
2110a86c6181SAlex Tomas 	int err;
2111f65e6fbaSAlex Tomas 	ext4_fsblk_t leaf;
2112a86c6181SAlex Tomas 
2113a86c6181SAlex Tomas 	/* free index block */
2114a86c6181SAlex Tomas 	path--;
2115bf89d16fSTheodore Ts'o 	leaf = ext4_idx_pblock(path->p_idx);
2116273df556SFrank Mayhar 	if (unlikely(path->p_hdr->eh_entries == 0)) {
2117273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
2118273df556SFrank Mayhar 		return -EIO;
2119273df556SFrank Mayhar 	}
21207e028976SAvantika Mathur 	err = ext4_ext_get_access(handle, inode, path);
21217e028976SAvantika Mathur 	if (err)
2122a86c6181SAlex Tomas 		return err;
21230e1147b0SRobin Dong 
21240e1147b0SRobin Dong 	if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) {
21250e1147b0SRobin Dong 		int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx;
21260e1147b0SRobin Dong 		len *= sizeof(struct ext4_extent_idx);
21270e1147b0SRobin Dong 		memmove(path->p_idx, path->p_idx + 1, len);
21280e1147b0SRobin Dong 	}
21290e1147b0SRobin Dong 
2130e8546d06SMarcin Slusarz 	le16_add_cpu(&path->p_hdr->eh_entries, -1);
21317e028976SAvantika Mathur 	err = ext4_ext_dirty(handle, inode, path);
21327e028976SAvantika Mathur 	if (err)
2133a86c6181SAlex Tomas 		return err;
21342ae02107SMingming Cao 	ext_debug("index is empty, remove it, free block %llu\n", leaf);
2135d8990240SAditya Kali 	trace_ext4_ext_rm_idx(inode, leaf);
2136d8990240SAditya Kali 
21377dc57615SPeter Huewe 	ext4_free_blocks(handle, inode, NULL, leaf, 1,
2138e6362609STheodore Ts'o 			 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
2139a86c6181SAlex Tomas 	return err;
2140a86c6181SAlex Tomas }
2141a86c6181SAlex Tomas 
2142a86c6181SAlex Tomas /*
2143ee12b630SMingming Cao  * ext4_ext_calc_credits_for_single_extent:
2144ee12b630SMingming Cao  * This routine returns max. credits that needed to insert an extent
2145ee12b630SMingming Cao  * to the extent tree.
2146ee12b630SMingming Cao  * When pass the actual path, the caller should calculate credits
2147ee12b630SMingming Cao  * under i_data_sem.
2148a86c6181SAlex Tomas  */
2149525f4ed8SMingming Cao int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks,
2150a86c6181SAlex Tomas 						struct ext4_ext_path *path)
2151a86c6181SAlex Tomas {
2152a86c6181SAlex Tomas 	if (path) {
2153ee12b630SMingming Cao 		int depth = ext_depth(inode);
2154f3bd1f3fSMingming Cao 		int ret = 0;
2155ee12b630SMingming Cao 
2156a86c6181SAlex Tomas 		/* probably there is space in leaf? */
2157a86c6181SAlex Tomas 		if (le16_to_cpu(path[depth].p_hdr->eh_entries)
2158ee12b630SMingming Cao 				< le16_to_cpu(path[depth].p_hdr->eh_max)) {
2159ee12b630SMingming Cao 
2160ee12b630SMingming Cao 			/*
2161ee12b630SMingming Cao 			 *  There are some space in the leaf tree, no
2162ee12b630SMingming Cao 			 *  need to account for leaf block credit
2163ee12b630SMingming Cao 			 *
2164ee12b630SMingming Cao 			 *  bitmaps and block group descriptor blocks
2165df3ab170STao Ma 			 *  and other metadata blocks still need to be
2166ee12b630SMingming Cao 			 *  accounted.
2167ee12b630SMingming Cao 			 */
2168525f4ed8SMingming Cao 			/* 1 bitmap, 1 block group descriptor */
2169ee12b630SMingming Cao 			ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);
21705887e98bSAneesh Kumar K.V 			return ret;
2171ee12b630SMingming Cao 		}
2172ee12b630SMingming Cao 	}
2173ee12b630SMingming Cao 
2174525f4ed8SMingming Cao 	return ext4_chunk_trans_blocks(inode, nrblocks);
2175a86c6181SAlex Tomas }
2176a86c6181SAlex Tomas 
2177a86c6181SAlex Tomas /*
2178ee12b630SMingming Cao  * How many index/leaf blocks need to change/allocate to modify nrblocks?
2179ee12b630SMingming Cao  *
2180ee12b630SMingming Cao  * if nrblocks are fit in a single extent (chunk flag is 1), then
2181ee12b630SMingming Cao  * in the worse case, each tree level index/leaf need to be changed
2182ee12b630SMingming Cao  * if the tree split due to insert a new extent, then the old tree
2183ee12b630SMingming Cao  * index/leaf need to be updated too
2184ee12b630SMingming Cao  *
2185ee12b630SMingming Cao  * If the nrblocks are discontiguous, they could cause
2186ee12b630SMingming Cao  * the whole tree split more than once, but this is really rare.
2187a86c6181SAlex Tomas  */
2188525f4ed8SMingming Cao int ext4_ext_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
2189ee12b630SMingming Cao {
2190ee12b630SMingming Cao 	int index;
2191ee12b630SMingming Cao 	int depth = ext_depth(inode);
2192a86c6181SAlex Tomas 
2193ee12b630SMingming Cao 	if (chunk)
2194ee12b630SMingming Cao 		index = depth * 2;
2195ee12b630SMingming Cao 	else
2196ee12b630SMingming Cao 		index = depth * 3;
2197a86c6181SAlex Tomas 
2198ee12b630SMingming Cao 	return index;
2199a86c6181SAlex Tomas }
2200a86c6181SAlex Tomas 
2201a86c6181SAlex Tomas static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
2202a86c6181SAlex Tomas 			      struct ext4_extent *ex,
22030aa06000STheodore Ts'o 			      ext4_fsblk_t *partial_cluster,
2204725d26d3SAneesh Kumar K.V 			      ext4_lblk_t from, ext4_lblk_t to)
2205a86c6181SAlex Tomas {
22060aa06000STheodore Ts'o 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2207a2df2a63SAmit Arora 	unsigned short ee_len =  ext4_ext_get_actual_len(ex);
22080aa06000STheodore Ts'o 	ext4_fsblk_t pblk;
2209e6362609STheodore Ts'o 	int flags = EXT4_FREE_BLOCKS_FORGET;
2210a86c6181SAlex Tomas 
2211c9de560dSAlex Tomas 	if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
2212e6362609STheodore Ts'o 		flags |= EXT4_FREE_BLOCKS_METADATA;
22130aa06000STheodore Ts'o 	/*
22140aa06000STheodore Ts'o 	 * For bigalloc file systems, we never free a partial cluster
22150aa06000STheodore Ts'o 	 * at the beginning of the extent.  Instead, we make a note
22160aa06000STheodore Ts'o 	 * that we tried freeing the cluster, and check to see if we
22170aa06000STheodore Ts'o 	 * need to free it on a subsequent call to ext4_remove_blocks,
22180aa06000STheodore Ts'o 	 * or at the end of the ext4_truncate() operation.
22190aa06000STheodore Ts'o 	 */
22200aa06000STheodore Ts'o 	flags |= EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER;
22210aa06000STheodore Ts'o 
2222d8990240SAditya Kali 	trace_ext4_remove_blocks(inode, ex, from, to, *partial_cluster);
22230aa06000STheodore Ts'o 	/*
22240aa06000STheodore Ts'o 	 * If we have a partial cluster, and it's different from the
22250aa06000STheodore Ts'o 	 * cluster of the last block, we need to explicitly free the
22260aa06000STheodore Ts'o 	 * partial cluster here.
22270aa06000STheodore Ts'o 	 */
22280aa06000STheodore Ts'o 	pblk = ext4_ext_pblock(ex) + ee_len - 1;
22290aa06000STheodore Ts'o 	if (*partial_cluster && (EXT4_B2C(sbi, pblk) != *partial_cluster)) {
22300aa06000STheodore Ts'o 		ext4_free_blocks(handle, inode, NULL,
22310aa06000STheodore Ts'o 				 EXT4_C2B(sbi, *partial_cluster),
22320aa06000STheodore Ts'o 				 sbi->s_cluster_ratio, flags);
22330aa06000STheodore Ts'o 		*partial_cluster = 0;
22340aa06000STheodore Ts'o 	}
22350aa06000STheodore Ts'o 
2236a86c6181SAlex Tomas #ifdef EXTENTS_STATS
2237a86c6181SAlex Tomas 	{
2238a86c6181SAlex Tomas 		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2239a86c6181SAlex Tomas 		spin_lock(&sbi->s_ext_stats_lock);
2240a86c6181SAlex Tomas 		sbi->s_ext_blocks += ee_len;
2241a86c6181SAlex Tomas 		sbi->s_ext_extents++;
2242a86c6181SAlex Tomas 		if (ee_len < sbi->s_ext_min)
2243a86c6181SAlex Tomas 			sbi->s_ext_min = ee_len;
2244a86c6181SAlex Tomas 		if (ee_len > sbi->s_ext_max)
2245a86c6181SAlex Tomas 			sbi->s_ext_max = ee_len;
2246a86c6181SAlex Tomas 		if (ext_depth(inode) > sbi->s_depth_max)
2247a86c6181SAlex Tomas 			sbi->s_depth_max = ext_depth(inode);
2248a86c6181SAlex Tomas 		spin_unlock(&sbi->s_ext_stats_lock);
2249a86c6181SAlex Tomas 	}
2250a86c6181SAlex Tomas #endif
2251a86c6181SAlex Tomas 	if (from >= le32_to_cpu(ex->ee_block)
2252a2df2a63SAmit Arora 	    && to == le32_to_cpu(ex->ee_block) + ee_len - 1) {
2253a86c6181SAlex Tomas 		/* tail removal */
2254725d26d3SAneesh Kumar K.V 		ext4_lblk_t num;
2255725d26d3SAneesh Kumar K.V 
2256a2df2a63SAmit Arora 		num = le32_to_cpu(ex->ee_block) + ee_len - from;
22570aa06000STheodore Ts'o 		pblk = ext4_ext_pblock(ex) + ee_len - num;
22580aa06000STheodore Ts'o 		ext_debug("free last %u blocks starting %llu\n", num, pblk);
22590aa06000STheodore Ts'o 		ext4_free_blocks(handle, inode, NULL, pblk, num, flags);
22600aa06000STheodore Ts'o 		/*
22610aa06000STheodore Ts'o 		 * If the block range to be freed didn't start at the
22620aa06000STheodore Ts'o 		 * beginning of a cluster, and we removed the entire
22630aa06000STheodore Ts'o 		 * extent, save the partial cluster here, since we
22640aa06000STheodore Ts'o 		 * might need to delete if we determine that the
22650aa06000STheodore Ts'o 		 * truncate operation has removed all of the blocks in
22660aa06000STheodore Ts'o 		 * the cluster.
22670aa06000STheodore Ts'o 		 */
22680aa06000STheodore Ts'o 		if (pblk & (sbi->s_cluster_ratio - 1) &&
22690aa06000STheodore Ts'o 		    (ee_len == num))
22700aa06000STheodore Ts'o 			*partial_cluster = EXT4_B2C(sbi, pblk);
22710aa06000STheodore Ts'o 		else
22720aa06000STheodore Ts'o 			*partial_cluster = 0;
2273a86c6181SAlex Tomas 	} else if (from == le32_to_cpu(ex->ee_block)
2274a2df2a63SAmit Arora 		   && to <= le32_to_cpu(ex->ee_block) + ee_len - 1) {
2275d583fb87SAllison Henderson 		/* head removal */
2276d583fb87SAllison Henderson 		ext4_lblk_t num;
2277d583fb87SAllison Henderson 		ext4_fsblk_t start;
2278d583fb87SAllison Henderson 
2279d583fb87SAllison Henderson 		num = to - from;
2280d583fb87SAllison Henderson 		start = ext4_ext_pblock(ex);
2281d583fb87SAllison Henderson 
2282d583fb87SAllison Henderson 		ext_debug("free first %u blocks starting %llu\n", num, start);
2283ee90d57eSH Hartley Sweeten 		ext4_free_blocks(handle, inode, NULL, start, num, flags);
2284d583fb87SAllison Henderson 
2285a86c6181SAlex Tomas 	} else {
2286725d26d3SAneesh Kumar K.V 		printk(KERN_INFO "strange request: removal(2) "
2287725d26d3SAneesh Kumar K.V 				"%u-%u from %u:%u\n",
2288a2df2a63SAmit Arora 				from, to, le32_to_cpu(ex->ee_block), ee_len);
2289a86c6181SAlex Tomas 	}
2290a86c6181SAlex Tomas 	return 0;
2291a86c6181SAlex Tomas }
2292a86c6181SAlex Tomas 
2293d583fb87SAllison Henderson 
2294d583fb87SAllison Henderson /*
2295d583fb87SAllison Henderson  * ext4_ext_rm_leaf() Removes the extents associated with the
2296d583fb87SAllison Henderson  * blocks appearing between "start" and "end", and splits the extents
2297d583fb87SAllison Henderson  * if "start" and "end" appear in the same extent
2298d583fb87SAllison Henderson  *
2299d583fb87SAllison Henderson  * @handle: The journal handle
2300d583fb87SAllison Henderson  * @inode:  The files inode
2301d583fb87SAllison Henderson  * @path:   The path to the leaf
2302d583fb87SAllison Henderson  * @start:  The first block to remove
2303d583fb87SAllison Henderson  * @end:   The last block to remove
2304d583fb87SAllison Henderson  */
2305a86c6181SAlex Tomas static int
2306a86c6181SAlex Tomas ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
23070aa06000STheodore Ts'o 		 struct ext4_ext_path *path, ext4_fsblk_t *partial_cluster,
23080aa06000STheodore Ts'o 		 ext4_lblk_t start, ext4_lblk_t end)
2309a86c6181SAlex Tomas {
23100aa06000STheodore Ts'o 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2311a86c6181SAlex Tomas 	int err = 0, correct_index = 0;
2312a86c6181SAlex Tomas 	int depth = ext_depth(inode), credits;
2313a86c6181SAlex Tomas 	struct ext4_extent_header *eh;
2314750c9c47SDmitry Monakhov 	ext4_lblk_t a, b;
2315725d26d3SAneesh Kumar K.V 	unsigned num;
2316725d26d3SAneesh Kumar K.V 	ext4_lblk_t ex_ee_block;
2317a86c6181SAlex Tomas 	unsigned short ex_ee_len;
2318a2df2a63SAmit Arora 	unsigned uninitialized = 0;
2319a86c6181SAlex Tomas 	struct ext4_extent *ex;
2320a86c6181SAlex Tomas 
2321c29c0ae7SAlex Tomas 	/* the header must be checked already in ext4_ext_remove_space() */
2322725d26d3SAneesh Kumar K.V 	ext_debug("truncate since %u in leaf\n", start);
2323a86c6181SAlex Tomas 	if (!path[depth].p_hdr)
2324a86c6181SAlex Tomas 		path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);
2325a86c6181SAlex Tomas 	eh = path[depth].p_hdr;
2326273df556SFrank Mayhar 	if (unlikely(path[depth].p_hdr == NULL)) {
2327273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2328273df556SFrank Mayhar 		return -EIO;
2329273df556SFrank Mayhar 	}
2330a86c6181SAlex Tomas 	/* find where to start removing */
2331a86c6181SAlex Tomas 	ex = EXT_LAST_EXTENT(eh);
2332a86c6181SAlex Tomas 
2333a86c6181SAlex Tomas 	ex_ee_block = le32_to_cpu(ex->ee_block);
2334a2df2a63SAmit Arora 	ex_ee_len = ext4_ext_get_actual_len(ex);
2335a86c6181SAlex Tomas 
2336d8990240SAditya Kali 	trace_ext4_ext_rm_leaf(inode, start, ex, *partial_cluster);
2337d8990240SAditya Kali 
2338a86c6181SAlex Tomas 	while (ex >= EXT_FIRST_EXTENT(eh) &&
2339a86c6181SAlex Tomas 			ex_ee_block + ex_ee_len > start) {
2340a41f2071SAneesh Kumar K.V 
2341a41f2071SAneesh Kumar K.V 		if (ext4_ext_is_uninitialized(ex))
2342a41f2071SAneesh Kumar K.V 			uninitialized = 1;
2343a41f2071SAneesh Kumar K.V 		else
2344a41f2071SAneesh Kumar K.V 			uninitialized = 0;
2345a41f2071SAneesh Kumar K.V 
2346553f9008SMingming 		ext_debug("remove ext %u:[%d]%d\n", ex_ee_block,
2347553f9008SMingming 			 uninitialized, ex_ee_len);
2348a86c6181SAlex Tomas 		path[depth].p_ext = ex;
2349a86c6181SAlex Tomas 
2350a86c6181SAlex Tomas 		a = ex_ee_block > start ? ex_ee_block : start;
2351d583fb87SAllison Henderson 		b = ex_ee_block+ex_ee_len - 1 < end ?
2352d583fb87SAllison Henderson 			ex_ee_block+ex_ee_len - 1 : end;
2353a86c6181SAlex Tomas 
2354a86c6181SAlex Tomas 		ext_debug("  border %u:%u\n", a, b);
2355a86c6181SAlex Tomas 
2356d583fb87SAllison Henderson 		/* If this extent is beyond the end of the hole, skip it */
2357d583fb87SAllison Henderson 		if (end <= ex_ee_block) {
2358d583fb87SAllison Henderson 			ex--;
2359d583fb87SAllison Henderson 			ex_ee_block = le32_to_cpu(ex->ee_block);
2360d583fb87SAllison Henderson 			ex_ee_len = ext4_ext_get_actual_len(ex);
2361d583fb87SAllison Henderson 			continue;
2362750c9c47SDmitry Monakhov 		} else if (b != ex_ee_block + ex_ee_len - 1) {
2363750c9c47SDmitry Monakhov 			EXT4_ERROR_INODE(inode,"  bad truncate %u:%u\n",
2364d583fb87SAllison Henderson 					 start, end);
2365d583fb87SAllison Henderson 			err = -EIO;
2366d583fb87SAllison Henderson 			goto out;
2367a86c6181SAlex Tomas 		} else if (a != ex_ee_block) {
2368a86c6181SAlex Tomas 			/* remove tail of the extent */
2369750c9c47SDmitry Monakhov 			num = a - ex_ee_block;
2370a86c6181SAlex Tomas 		} else {
2371a86c6181SAlex Tomas 			/* remove whole extent: excellent! */
2372a86c6181SAlex Tomas 			num = 0;
2373d583fb87SAllison Henderson 		}
237434071da7STheodore Ts'o 		/*
237534071da7STheodore Ts'o 		 * 3 for leaf, sb, and inode plus 2 (bmap and group
237634071da7STheodore Ts'o 		 * descriptor) for each block group; assume two block
237734071da7STheodore Ts'o 		 * groups plus ex_ee_len/blocks_per_block_group for
237834071da7STheodore Ts'o 		 * the worst case
237934071da7STheodore Ts'o 		 */
238034071da7STheodore Ts'o 		credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
2381a86c6181SAlex Tomas 		if (ex == EXT_FIRST_EXTENT(eh)) {
2382a86c6181SAlex Tomas 			correct_index = 1;
2383a86c6181SAlex Tomas 			credits += (ext_depth(inode)) + 1;
2384a86c6181SAlex Tomas 		}
23855aca07ebSDmitry Monakhov 		credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
2386a86c6181SAlex Tomas 
2387487caeefSJan Kara 		err = ext4_ext_truncate_extend_restart(handle, inode, credits);
23889102e4faSShen Feng 		if (err)
2389a86c6181SAlex Tomas 			goto out;
2390a86c6181SAlex Tomas 
2391a86c6181SAlex Tomas 		err = ext4_ext_get_access(handle, inode, path + depth);
2392a86c6181SAlex Tomas 		if (err)
2393a86c6181SAlex Tomas 			goto out;
2394a86c6181SAlex Tomas 
23950aa06000STheodore Ts'o 		err = ext4_remove_blocks(handle, inode, ex, partial_cluster,
23960aa06000STheodore Ts'o 					 a, b);
2397a86c6181SAlex Tomas 		if (err)
2398a86c6181SAlex Tomas 			goto out;
2399a86c6181SAlex Tomas 
2400750c9c47SDmitry Monakhov 		if (num == 0)
2401d0d856e8SRandy Dunlap 			/* this extent is removed; mark slot entirely unused */
2402f65e6fbaSAlex Tomas 			ext4_ext_store_pblock(ex, 0);
2403a86c6181SAlex Tomas 
2404a86c6181SAlex Tomas 		ex->ee_len = cpu_to_le16(num);
2405749269faSAmit Arora 		/*
2406749269faSAmit Arora 		 * Do not mark uninitialized if all the blocks in the
2407749269faSAmit Arora 		 * extent have been removed.
2408749269faSAmit Arora 		 */
2409749269faSAmit Arora 		if (uninitialized && num)
2410a2df2a63SAmit Arora 			ext4_ext_mark_uninitialized(ex);
2411d583fb87SAllison Henderson 		/*
2412d583fb87SAllison Henderson 		 * If the extent was completely released,
2413d583fb87SAllison Henderson 		 * we need to remove it from the leaf
2414d583fb87SAllison Henderson 		 */
2415d583fb87SAllison Henderson 		if (num == 0) {
2416f17722f9SLukas Czerner 			if (end != EXT_MAX_BLOCKS - 1) {
2417d583fb87SAllison Henderson 				/*
2418d583fb87SAllison Henderson 				 * For hole punching, we need to scoot all the
2419d583fb87SAllison Henderson 				 * extents up when an extent is removed so that
2420d583fb87SAllison Henderson 				 * we dont have blank extents in the middle
2421d583fb87SAllison Henderson 				 */
2422d583fb87SAllison Henderson 				memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) *
2423d583fb87SAllison Henderson 					sizeof(struct ext4_extent));
2424d583fb87SAllison Henderson 
2425d583fb87SAllison Henderson 				/* Now get rid of the one at the end */
2426d583fb87SAllison Henderson 				memset(EXT_LAST_EXTENT(eh), 0,
2427d583fb87SAllison Henderson 					sizeof(struct ext4_extent));
2428d583fb87SAllison Henderson 			}
2429d583fb87SAllison Henderson 			le16_add_cpu(&eh->eh_entries, -1);
24300aa06000STheodore Ts'o 		} else
24310aa06000STheodore Ts'o 			*partial_cluster = 0;
2432d583fb87SAllison Henderson 
2433750c9c47SDmitry Monakhov 		err = ext4_ext_dirty(handle, inode, path + depth);
2434750c9c47SDmitry Monakhov 		if (err)
2435750c9c47SDmitry Monakhov 			goto out;
2436750c9c47SDmitry Monakhov 
24372ae02107SMingming Cao 		ext_debug("new extent: %u:%u:%llu\n", block, num,
2438bf89d16fSTheodore Ts'o 				ext4_ext_pblock(ex));
2439a86c6181SAlex Tomas 		ex--;
2440a86c6181SAlex Tomas 		ex_ee_block = le32_to_cpu(ex->ee_block);
2441a2df2a63SAmit Arora 		ex_ee_len = ext4_ext_get_actual_len(ex);
2442a86c6181SAlex Tomas 	}
2443a86c6181SAlex Tomas 
2444a86c6181SAlex Tomas 	if (correct_index && eh->eh_entries)
2445a86c6181SAlex Tomas 		err = ext4_ext_correct_indexes(handle, inode, path);
2446a86c6181SAlex Tomas 
24470aa06000STheodore Ts'o 	/*
24480aa06000STheodore Ts'o 	 * If there is still a entry in the leaf node, check to see if
24490aa06000STheodore Ts'o 	 * it references the partial cluster.  This is the only place
24500aa06000STheodore Ts'o 	 * where it could; if it doesn't, we can free the cluster.
24510aa06000STheodore Ts'o 	 */
24520aa06000STheodore Ts'o 	if (*partial_cluster && ex >= EXT_FIRST_EXTENT(eh) &&
24530aa06000STheodore Ts'o 	    (EXT4_B2C(sbi, ext4_ext_pblock(ex) + ex_ee_len - 1) !=
24540aa06000STheodore Ts'o 	     *partial_cluster)) {
24550aa06000STheodore Ts'o 		int flags = EXT4_FREE_BLOCKS_FORGET;
24560aa06000STheodore Ts'o 
24570aa06000STheodore Ts'o 		if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
24580aa06000STheodore Ts'o 			flags |= EXT4_FREE_BLOCKS_METADATA;
24590aa06000STheodore Ts'o 
24600aa06000STheodore Ts'o 		ext4_free_blocks(handle, inode, NULL,
24610aa06000STheodore Ts'o 				 EXT4_C2B(sbi, *partial_cluster),
24620aa06000STheodore Ts'o 				 sbi->s_cluster_ratio, flags);
24630aa06000STheodore Ts'o 		*partial_cluster = 0;
24640aa06000STheodore Ts'o 	}
24650aa06000STheodore Ts'o 
2466a86c6181SAlex Tomas 	/* if this leaf is free, then we should
2467a86c6181SAlex Tomas 	 * remove it from index block above */
2468a86c6181SAlex Tomas 	if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
2469a86c6181SAlex Tomas 		err = ext4_ext_rm_idx(handle, inode, path + depth);
2470a86c6181SAlex Tomas 
2471a86c6181SAlex Tomas out:
2472a86c6181SAlex Tomas 	return err;
2473a86c6181SAlex Tomas }
2474a86c6181SAlex Tomas 
2475a86c6181SAlex Tomas /*
2476d0d856e8SRandy Dunlap  * ext4_ext_more_to_rm:
2477d0d856e8SRandy Dunlap  * returns 1 if current index has to be freed (even partial)
2478a86c6181SAlex Tomas  */
247909b88252SAvantika Mathur static int
2480a86c6181SAlex Tomas ext4_ext_more_to_rm(struct ext4_ext_path *path)
2481a86c6181SAlex Tomas {
2482a86c6181SAlex Tomas 	BUG_ON(path->p_idx == NULL);
2483a86c6181SAlex Tomas 
2484a86c6181SAlex Tomas 	if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr))
2485a86c6181SAlex Tomas 		return 0;
2486a86c6181SAlex Tomas 
2487a86c6181SAlex Tomas 	/*
2488d0d856e8SRandy Dunlap 	 * if truncate on deeper level happened, it wasn't partial,
2489a86c6181SAlex Tomas 	 * so we have to consider current index for truncation
2490a86c6181SAlex Tomas 	 */
2491a86c6181SAlex Tomas 	if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)
2492a86c6181SAlex Tomas 		return 0;
2493a86c6181SAlex Tomas 	return 1;
2494a86c6181SAlex Tomas }
2495a86c6181SAlex Tomas 
2496c6a0371cSAllison Henderson static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start)
2497a86c6181SAlex Tomas {
2498a86c6181SAlex Tomas 	struct super_block *sb = inode->i_sb;
2499a86c6181SAlex Tomas 	int depth = ext_depth(inode);
2500a86c6181SAlex Tomas 	struct ext4_ext_path *path;
25010aa06000STheodore Ts'o 	ext4_fsblk_t partial_cluster = 0;
2502a86c6181SAlex Tomas 	handle_t *handle;
25030617b83fSDmitry Monakhov 	int i, err;
2504a86c6181SAlex Tomas 
2505725d26d3SAneesh Kumar K.V 	ext_debug("truncate since %u\n", start);
2506a86c6181SAlex Tomas 
2507a86c6181SAlex Tomas 	/* probably first extent we're gonna free will be last in block */
2508a86c6181SAlex Tomas 	handle = ext4_journal_start(inode, depth + 1);
2509a86c6181SAlex Tomas 	if (IS_ERR(handle))
2510a86c6181SAlex Tomas 		return PTR_ERR(handle);
2511a86c6181SAlex Tomas 
25120617b83fSDmitry Monakhov again:
2513a86c6181SAlex Tomas 	ext4_ext_invalidate_cache(inode);
2514a86c6181SAlex Tomas 
2515d8990240SAditya Kali 	trace_ext4_ext_remove_space(inode, start, depth);
2516d8990240SAditya Kali 
2517a86c6181SAlex Tomas 	/*
2518d0d856e8SRandy Dunlap 	 * We start scanning from right side, freeing all the blocks
2519d0d856e8SRandy Dunlap 	 * after i_size and walking into the tree depth-wise.
2520a86c6181SAlex Tomas 	 */
25210617b83fSDmitry Monakhov 	depth = ext_depth(inode);
2522216553c4SJosef Bacik 	path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS);
2523a86c6181SAlex Tomas 	if (path == NULL) {
2524a86c6181SAlex Tomas 		ext4_journal_stop(handle);
2525a86c6181SAlex Tomas 		return -ENOMEM;
2526a86c6181SAlex Tomas 	}
25270617b83fSDmitry Monakhov 	path[0].p_depth = depth;
2528a86c6181SAlex Tomas 	path[0].p_hdr = ext_inode_hdr(inode);
252956b19868SAneesh Kumar K.V 	if (ext4_ext_check(inode, path[0].p_hdr, depth)) {
2530a86c6181SAlex Tomas 		err = -EIO;
2531a86c6181SAlex Tomas 		goto out;
2532a86c6181SAlex Tomas 	}
25330617b83fSDmitry Monakhov 	i = err = 0;
2534a86c6181SAlex Tomas 
2535a86c6181SAlex Tomas 	while (i >= 0 && err == 0) {
2536a86c6181SAlex Tomas 		if (i == depth) {
2537a86c6181SAlex Tomas 			/* this is leaf block */
2538d583fb87SAllison Henderson 			err = ext4_ext_rm_leaf(handle, inode, path,
25390aa06000STheodore Ts'o 					       &partial_cluster, start,
25400aa06000STheodore Ts'o 					       EXT_MAX_BLOCKS - 1);
2541d0d856e8SRandy Dunlap 			/* root level has p_bh == NULL, brelse() eats this */
2542a86c6181SAlex Tomas 			brelse(path[i].p_bh);
2543a86c6181SAlex Tomas 			path[i].p_bh = NULL;
2544a86c6181SAlex Tomas 			i--;
2545a86c6181SAlex Tomas 			continue;
2546a86c6181SAlex Tomas 		}
2547a86c6181SAlex Tomas 
2548a86c6181SAlex Tomas 		/* this is index block */
2549a86c6181SAlex Tomas 		if (!path[i].p_hdr) {
2550a86c6181SAlex Tomas 			ext_debug("initialize header\n");
2551a86c6181SAlex Tomas 			path[i].p_hdr = ext_block_hdr(path[i].p_bh);
2552a86c6181SAlex Tomas 		}
2553a86c6181SAlex Tomas 
2554a86c6181SAlex Tomas 		if (!path[i].p_idx) {
2555d0d856e8SRandy Dunlap 			/* this level hasn't been touched yet */
2556a86c6181SAlex Tomas 			path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
2557a86c6181SAlex Tomas 			path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
2558a86c6181SAlex Tomas 			ext_debug("init index ptr: hdr 0x%p, num %d\n",
2559a86c6181SAlex Tomas 				  path[i].p_hdr,
2560a86c6181SAlex Tomas 				  le16_to_cpu(path[i].p_hdr->eh_entries));
2561a86c6181SAlex Tomas 		} else {
2562d0d856e8SRandy Dunlap 			/* we were already here, see at next index */
2563a86c6181SAlex Tomas 			path[i].p_idx--;
2564a86c6181SAlex Tomas 		}
2565a86c6181SAlex Tomas 
2566a86c6181SAlex Tomas 		ext_debug("level %d - index, first 0x%p, cur 0x%p\n",
2567a86c6181SAlex Tomas 				i, EXT_FIRST_INDEX(path[i].p_hdr),
2568a86c6181SAlex Tomas 				path[i].p_idx);
2569a86c6181SAlex Tomas 		if (ext4_ext_more_to_rm(path + i)) {
2570c29c0ae7SAlex Tomas 			struct buffer_head *bh;
2571a86c6181SAlex Tomas 			/* go to the next level */
25722ae02107SMingming Cao 			ext_debug("move to level %d (block %llu)\n",
2573bf89d16fSTheodore Ts'o 				  i + 1, ext4_idx_pblock(path[i].p_idx));
2574a86c6181SAlex Tomas 			memset(path + i + 1, 0, sizeof(*path));
2575bf89d16fSTheodore Ts'o 			bh = sb_bread(sb, ext4_idx_pblock(path[i].p_idx));
2576c29c0ae7SAlex Tomas 			if (!bh) {
2577a86c6181SAlex Tomas 				/* should we reset i_size? */
2578a86c6181SAlex Tomas 				err = -EIO;
2579a86c6181SAlex Tomas 				break;
2580a86c6181SAlex Tomas 			}
2581c29c0ae7SAlex Tomas 			if (WARN_ON(i + 1 > depth)) {
2582c29c0ae7SAlex Tomas 				err = -EIO;
2583c29c0ae7SAlex Tomas 				break;
2584c29c0ae7SAlex Tomas 			}
258556b19868SAneesh Kumar K.V 			if (ext4_ext_check(inode, ext_block_hdr(bh),
2586c29c0ae7SAlex Tomas 							depth - i - 1)) {
2587c29c0ae7SAlex Tomas 				err = -EIO;
2588c29c0ae7SAlex Tomas 				break;
2589c29c0ae7SAlex Tomas 			}
2590c29c0ae7SAlex Tomas 			path[i + 1].p_bh = bh;
2591a86c6181SAlex Tomas 
2592d0d856e8SRandy Dunlap 			/* save actual number of indexes since this
2593d0d856e8SRandy Dunlap 			 * number is changed at the next iteration */
2594a86c6181SAlex Tomas 			path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
2595a86c6181SAlex Tomas 			i++;
2596a86c6181SAlex Tomas 		} else {
2597d0d856e8SRandy Dunlap 			/* we finished processing this index, go up */
2598a86c6181SAlex Tomas 			if (path[i].p_hdr->eh_entries == 0 && i > 0) {
2599d0d856e8SRandy Dunlap 				/* index is empty, remove it;
2600a86c6181SAlex Tomas 				 * handle must be already prepared by the
2601a86c6181SAlex Tomas 				 * truncatei_leaf() */
2602a86c6181SAlex Tomas 				err = ext4_ext_rm_idx(handle, inode, path + i);
2603a86c6181SAlex Tomas 			}
2604d0d856e8SRandy Dunlap 			/* root level has p_bh == NULL, brelse() eats this */
2605a86c6181SAlex Tomas 			brelse(path[i].p_bh);
2606a86c6181SAlex Tomas 			path[i].p_bh = NULL;
2607a86c6181SAlex Tomas 			i--;
2608a86c6181SAlex Tomas 			ext_debug("return to level %d\n", i);
2609a86c6181SAlex Tomas 		}
2610a86c6181SAlex Tomas 	}
2611a86c6181SAlex Tomas 
2612d8990240SAditya Kali 	trace_ext4_ext_remove_space_done(inode, start, depth, partial_cluster,
2613d8990240SAditya Kali 			path->p_hdr->eh_entries);
2614d8990240SAditya Kali 
26157b415bf6SAditya Kali 	/* If we still have something in the partial cluster and we have removed
26167b415bf6SAditya Kali 	 * even the first extent, then we should free the blocks in the partial
26177b415bf6SAditya Kali 	 * cluster as well. */
26187b415bf6SAditya Kali 	if (partial_cluster && path->p_hdr->eh_entries == 0) {
26197b415bf6SAditya Kali 		int flags = EXT4_FREE_BLOCKS_FORGET;
26207b415bf6SAditya Kali 
26217b415bf6SAditya Kali 		if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
26227b415bf6SAditya Kali 			flags |= EXT4_FREE_BLOCKS_METADATA;
26237b415bf6SAditya Kali 
26247b415bf6SAditya Kali 		ext4_free_blocks(handle, inode, NULL,
26257b415bf6SAditya Kali 				 EXT4_C2B(EXT4_SB(sb), partial_cluster),
26267b415bf6SAditya Kali 				 EXT4_SB(sb)->s_cluster_ratio, flags);
26277b415bf6SAditya Kali 		partial_cluster = 0;
26287b415bf6SAditya Kali 	}
26297b415bf6SAditya Kali 
2630a86c6181SAlex Tomas 	/* TODO: flexible tree reduction should be here */
2631a86c6181SAlex Tomas 	if (path->p_hdr->eh_entries == 0) {
2632a86c6181SAlex Tomas 		/*
2633d0d856e8SRandy Dunlap 		 * truncate to zero freed all the tree,
2634d0d856e8SRandy Dunlap 		 * so we need to correct eh_depth
2635a86c6181SAlex Tomas 		 */
2636a86c6181SAlex Tomas 		err = ext4_ext_get_access(handle, inode, path);
2637a86c6181SAlex Tomas 		if (err == 0) {
2638a86c6181SAlex Tomas 			ext_inode_hdr(inode)->eh_depth = 0;
2639a86c6181SAlex Tomas 			ext_inode_hdr(inode)->eh_max =
264055ad63bfSTheodore Ts'o 				cpu_to_le16(ext4_ext_space_root(inode, 0));
2641a86c6181SAlex Tomas 			err = ext4_ext_dirty(handle, inode, path);
2642a86c6181SAlex Tomas 		}
2643a86c6181SAlex Tomas 	}
2644a86c6181SAlex Tomas out:
2645a86c6181SAlex Tomas 	ext4_ext_drop_refs(path);
2646a86c6181SAlex Tomas 	kfree(path);
26470617b83fSDmitry Monakhov 	if (err == -EAGAIN)
26480617b83fSDmitry Monakhov 		goto again;
2649a86c6181SAlex Tomas 	ext4_journal_stop(handle);
2650a86c6181SAlex Tomas 
2651a86c6181SAlex Tomas 	return err;
2652a86c6181SAlex Tomas }
2653a86c6181SAlex Tomas 
2654a86c6181SAlex Tomas /*
2655a86c6181SAlex Tomas  * called at mount time
2656a86c6181SAlex Tomas  */
2657a86c6181SAlex Tomas void ext4_ext_init(struct super_block *sb)
2658a86c6181SAlex Tomas {
2659a86c6181SAlex Tomas 	/*
2660a86c6181SAlex Tomas 	 * possible initialization would be here
2661a86c6181SAlex Tomas 	 */
2662a86c6181SAlex Tomas 
266383982b6fSTheodore Ts'o 	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
266490576c0bSTheodore Ts'o #if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS)
26654776004fSTheodore Ts'o 		printk(KERN_INFO "EXT4-fs: file extents enabled");
2666bbf2f9fbSRobert P. J. Day #ifdef AGGRESSIVE_TEST
2667bbf2f9fbSRobert P. J. Day 		printk(", aggressive tests");
2668a86c6181SAlex Tomas #endif
2669a86c6181SAlex Tomas #ifdef CHECK_BINSEARCH
2670a86c6181SAlex Tomas 		printk(", check binsearch");
2671a86c6181SAlex Tomas #endif
2672a86c6181SAlex Tomas #ifdef EXTENTS_STATS
2673a86c6181SAlex Tomas 		printk(", stats");
2674a86c6181SAlex Tomas #endif
2675a86c6181SAlex Tomas 		printk("\n");
267690576c0bSTheodore Ts'o #endif
2677a86c6181SAlex Tomas #ifdef EXTENTS_STATS
2678a86c6181SAlex Tomas 		spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock);
2679a86c6181SAlex Tomas 		EXT4_SB(sb)->s_ext_min = 1 << 30;
2680a86c6181SAlex Tomas 		EXT4_SB(sb)->s_ext_max = 0;
2681a86c6181SAlex Tomas #endif
2682a86c6181SAlex Tomas 	}
2683a86c6181SAlex Tomas }
2684a86c6181SAlex Tomas 
2685a86c6181SAlex Tomas /*
2686a86c6181SAlex Tomas  * called at umount time
2687a86c6181SAlex Tomas  */
2688a86c6181SAlex Tomas void ext4_ext_release(struct super_block *sb)
2689a86c6181SAlex Tomas {
269083982b6fSTheodore Ts'o 	if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS))
2691a86c6181SAlex Tomas 		return;
2692a86c6181SAlex Tomas 
2693a86c6181SAlex Tomas #ifdef EXTENTS_STATS
2694a86c6181SAlex Tomas 	if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) {
2695a86c6181SAlex Tomas 		struct ext4_sb_info *sbi = EXT4_SB(sb);
2696a86c6181SAlex Tomas 		printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n",
2697a86c6181SAlex Tomas 			sbi->s_ext_blocks, sbi->s_ext_extents,
2698a86c6181SAlex Tomas 			sbi->s_ext_blocks / sbi->s_ext_extents);
2699a86c6181SAlex Tomas 		printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n",
2700a86c6181SAlex Tomas 			sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max);
2701a86c6181SAlex Tomas 	}
2702a86c6181SAlex Tomas #endif
2703a86c6181SAlex Tomas }
2704a86c6181SAlex Tomas 
2705093a088bSAneesh Kumar K.V /* FIXME!! we need to try to merge to left or right after zero-out  */
2706093a088bSAneesh Kumar K.V static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
2707093a088bSAneesh Kumar K.V {
27082407518dSLukas Czerner 	ext4_fsblk_t ee_pblock;
27092407518dSLukas Czerner 	unsigned int ee_len;
2710b720303dSJing Zhang 	int ret;
2711093a088bSAneesh Kumar K.V 
2712093a088bSAneesh Kumar K.V 	ee_len    = ext4_ext_get_actual_len(ex);
2713bf89d16fSTheodore Ts'o 	ee_pblock = ext4_ext_pblock(ex);
2714093a088bSAneesh Kumar K.V 
2715a107e5a3STheodore Ts'o 	ret = sb_issue_zeroout(inode->i_sb, ee_pblock, ee_len, GFP_NOFS);
27162407518dSLukas Czerner 	if (ret > 0)
27172407518dSLukas Czerner 		ret = 0;
2718093a088bSAneesh Kumar K.V 
27192407518dSLukas Czerner 	return ret;
2720093a088bSAneesh Kumar K.V }
2721093a088bSAneesh Kumar K.V 
272247ea3bb5SYongqiang Yang /*
272347ea3bb5SYongqiang Yang  * used by extent splitting.
272447ea3bb5SYongqiang Yang  */
272547ea3bb5SYongqiang Yang #define EXT4_EXT_MAY_ZEROOUT	0x1  /* safe to zeroout if split fails \
272647ea3bb5SYongqiang Yang 					due to ENOSPC */
272747ea3bb5SYongqiang Yang #define EXT4_EXT_MARK_UNINIT1	0x2  /* mark first half uninitialized */
272847ea3bb5SYongqiang Yang #define EXT4_EXT_MARK_UNINIT2	0x4  /* mark second half uninitialized */
272947ea3bb5SYongqiang Yang 
273047ea3bb5SYongqiang Yang /*
273147ea3bb5SYongqiang Yang  * ext4_split_extent_at() splits an extent at given block.
273247ea3bb5SYongqiang Yang  *
273347ea3bb5SYongqiang Yang  * @handle: the journal handle
273447ea3bb5SYongqiang Yang  * @inode: the file inode
273547ea3bb5SYongqiang Yang  * @path: the path to the extent
273647ea3bb5SYongqiang Yang  * @split: the logical block where the extent is splitted.
273747ea3bb5SYongqiang Yang  * @split_flags: indicates if the extent could be zeroout if split fails, and
273847ea3bb5SYongqiang Yang  *		 the states(init or uninit) of new extents.
273947ea3bb5SYongqiang Yang  * @flags: flags used to insert new extent to extent tree.
274047ea3bb5SYongqiang Yang  *
274147ea3bb5SYongqiang Yang  *
274247ea3bb5SYongqiang Yang  * Splits extent [a, b] into two extents [a, @split) and [@split, b], states
274347ea3bb5SYongqiang Yang  * of which are deterimined by split_flag.
274447ea3bb5SYongqiang Yang  *
274547ea3bb5SYongqiang Yang  * There are two cases:
274647ea3bb5SYongqiang Yang  *  a> the extent are splitted into two extent.
274747ea3bb5SYongqiang Yang  *  b> split is not needed, and just mark the extent.
274847ea3bb5SYongqiang Yang  *
274947ea3bb5SYongqiang Yang  * return 0 on success.
275047ea3bb5SYongqiang Yang  */
275147ea3bb5SYongqiang Yang static int ext4_split_extent_at(handle_t *handle,
275247ea3bb5SYongqiang Yang 			     struct inode *inode,
275347ea3bb5SYongqiang Yang 			     struct ext4_ext_path *path,
275447ea3bb5SYongqiang Yang 			     ext4_lblk_t split,
275547ea3bb5SYongqiang Yang 			     int split_flag,
275647ea3bb5SYongqiang Yang 			     int flags)
275747ea3bb5SYongqiang Yang {
275847ea3bb5SYongqiang Yang 	ext4_fsblk_t newblock;
275947ea3bb5SYongqiang Yang 	ext4_lblk_t ee_block;
276047ea3bb5SYongqiang Yang 	struct ext4_extent *ex, newex, orig_ex;
276147ea3bb5SYongqiang Yang 	struct ext4_extent *ex2 = NULL;
276247ea3bb5SYongqiang Yang 	unsigned int ee_len, depth;
276347ea3bb5SYongqiang Yang 	int err = 0;
276447ea3bb5SYongqiang Yang 
276547ea3bb5SYongqiang Yang 	ext_debug("ext4_split_extents_at: inode %lu, logical"
276647ea3bb5SYongqiang Yang 		"block %llu\n", inode->i_ino, (unsigned long long)split);
276747ea3bb5SYongqiang Yang 
276847ea3bb5SYongqiang Yang 	ext4_ext_show_leaf(inode, path);
276947ea3bb5SYongqiang Yang 
277047ea3bb5SYongqiang Yang 	depth = ext_depth(inode);
277147ea3bb5SYongqiang Yang 	ex = path[depth].p_ext;
277247ea3bb5SYongqiang Yang 	ee_block = le32_to_cpu(ex->ee_block);
277347ea3bb5SYongqiang Yang 	ee_len = ext4_ext_get_actual_len(ex);
277447ea3bb5SYongqiang Yang 	newblock = split - ee_block + ext4_ext_pblock(ex);
277547ea3bb5SYongqiang Yang 
277647ea3bb5SYongqiang Yang 	BUG_ON(split < ee_block || split >= (ee_block + ee_len));
277747ea3bb5SYongqiang Yang 
277847ea3bb5SYongqiang Yang 	err = ext4_ext_get_access(handle, inode, path + depth);
277947ea3bb5SYongqiang Yang 	if (err)
278047ea3bb5SYongqiang Yang 		goto out;
278147ea3bb5SYongqiang Yang 
278247ea3bb5SYongqiang Yang 	if (split == ee_block) {
278347ea3bb5SYongqiang Yang 		/*
278447ea3bb5SYongqiang Yang 		 * case b: block @split is the block that the extent begins with
278547ea3bb5SYongqiang Yang 		 * then we just change the state of the extent, and splitting
278647ea3bb5SYongqiang Yang 		 * is not needed.
278747ea3bb5SYongqiang Yang 		 */
278847ea3bb5SYongqiang Yang 		if (split_flag & EXT4_EXT_MARK_UNINIT2)
278947ea3bb5SYongqiang Yang 			ext4_ext_mark_uninitialized(ex);
279047ea3bb5SYongqiang Yang 		else
279147ea3bb5SYongqiang Yang 			ext4_ext_mark_initialized(ex);
279247ea3bb5SYongqiang Yang 
279347ea3bb5SYongqiang Yang 		if (!(flags & EXT4_GET_BLOCKS_PRE_IO))
279447ea3bb5SYongqiang Yang 			ext4_ext_try_to_merge(inode, path, ex);
279547ea3bb5SYongqiang Yang 
279647ea3bb5SYongqiang Yang 		err = ext4_ext_dirty(handle, inode, path + depth);
279747ea3bb5SYongqiang Yang 		goto out;
279847ea3bb5SYongqiang Yang 	}
279947ea3bb5SYongqiang Yang 
280047ea3bb5SYongqiang Yang 	/* case a */
280147ea3bb5SYongqiang Yang 	memcpy(&orig_ex, ex, sizeof(orig_ex));
280247ea3bb5SYongqiang Yang 	ex->ee_len = cpu_to_le16(split - ee_block);
280347ea3bb5SYongqiang Yang 	if (split_flag & EXT4_EXT_MARK_UNINIT1)
280447ea3bb5SYongqiang Yang 		ext4_ext_mark_uninitialized(ex);
280547ea3bb5SYongqiang Yang 
280647ea3bb5SYongqiang Yang 	/*
280747ea3bb5SYongqiang Yang 	 * path may lead to new leaf, not to original leaf any more
280847ea3bb5SYongqiang Yang 	 * after ext4_ext_insert_extent() returns,
280947ea3bb5SYongqiang Yang 	 */
281047ea3bb5SYongqiang Yang 	err = ext4_ext_dirty(handle, inode, path + depth);
281147ea3bb5SYongqiang Yang 	if (err)
281247ea3bb5SYongqiang Yang 		goto fix_extent_len;
281347ea3bb5SYongqiang Yang 
281447ea3bb5SYongqiang Yang 	ex2 = &newex;
281547ea3bb5SYongqiang Yang 	ex2->ee_block = cpu_to_le32(split);
281647ea3bb5SYongqiang Yang 	ex2->ee_len   = cpu_to_le16(ee_len - (split - ee_block));
281747ea3bb5SYongqiang Yang 	ext4_ext_store_pblock(ex2, newblock);
281847ea3bb5SYongqiang Yang 	if (split_flag & EXT4_EXT_MARK_UNINIT2)
281947ea3bb5SYongqiang Yang 		ext4_ext_mark_uninitialized(ex2);
282047ea3bb5SYongqiang Yang 
282147ea3bb5SYongqiang Yang 	err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);
282247ea3bb5SYongqiang Yang 	if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) {
282347ea3bb5SYongqiang Yang 		err = ext4_ext_zeroout(inode, &orig_ex);
282447ea3bb5SYongqiang Yang 		if (err)
282547ea3bb5SYongqiang Yang 			goto fix_extent_len;
282647ea3bb5SYongqiang Yang 		/* update the extent length and mark as initialized */
282747ea3bb5SYongqiang Yang 		ex->ee_len = cpu_to_le32(ee_len);
282847ea3bb5SYongqiang Yang 		ext4_ext_try_to_merge(inode, path, ex);
282947ea3bb5SYongqiang Yang 		err = ext4_ext_dirty(handle, inode, path + depth);
283047ea3bb5SYongqiang Yang 		goto out;
283147ea3bb5SYongqiang Yang 	} else if (err)
283247ea3bb5SYongqiang Yang 		goto fix_extent_len;
283347ea3bb5SYongqiang Yang 
283447ea3bb5SYongqiang Yang out:
283547ea3bb5SYongqiang Yang 	ext4_ext_show_leaf(inode, path);
283647ea3bb5SYongqiang Yang 	return err;
283747ea3bb5SYongqiang Yang 
283847ea3bb5SYongqiang Yang fix_extent_len:
283947ea3bb5SYongqiang Yang 	ex->ee_len = orig_ex.ee_len;
284047ea3bb5SYongqiang Yang 	ext4_ext_dirty(handle, inode, path + depth);
284147ea3bb5SYongqiang Yang 	return err;
284247ea3bb5SYongqiang Yang }
284347ea3bb5SYongqiang Yang 
284447ea3bb5SYongqiang Yang /*
284547ea3bb5SYongqiang Yang  * ext4_split_extents() splits an extent and mark extent which is covered
284647ea3bb5SYongqiang Yang  * by @map as split_flags indicates
284747ea3bb5SYongqiang Yang  *
284847ea3bb5SYongqiang Yang  * It may result in splitting the extent into multiple extents (upto three)
284947ea3bb5SYongqiang Yang  * There are three possibilities:
285047ea3bb5SYongqiang Yang  *   a> There is no split required
285147ea3bb5SYongqiang Yang  *   b> Splits in two extents: Split is happening at either end of the extent
285247ea3bb5SYongqiang Yang  *   c> Splits in three extents: Somone is splitting in middle of the extent
285347ea3bb5SYongqiang Yang  *
285447ea3bb5SYongqiang Yang  */
285547ea3bb5SYongqiang Yang static int ext4_split_extent(handle_t *handle,
285647ea3bb5SYongqiang Yang 			      struct inode *inode,
285747ea3bb5SYongqiang Yang 			      struct ext4_ext_path *path,
285847ea3bb5SYongqiang Yang 			      struct ext4_map_blocks *map,
285947ea3bb5SYongqiang Yang 			      int split_flag,
286047ea3bb5SYongqiang Yang 			      int flags)
286147ea3bb5SYongqiang Yang {
286247ea3bb5SYongqiang Yang 	ext4_lblk_t ee_block;
286347ea3bb5SYongqiang Yang 	struct ext4_extent *ex;
286447ea3bb5SYongqiang Yang 	unsigned int ee_len, depth;
286547ea3bb5SYongqiang Yang 	int err = 0;
286647ea3bb5SYongqiang Yang 	int uninitialized;
286747ea3bb5SYongqiang Yang 	int split_flag1, flags1;
286847ea3bb5SYongqiang Yang 
286947ea3bb5SYongqiang Yang 	depth = ext_depth(inode);
287047ea3bb5SYongqiang Yang 	ex = path[depth].p_ext;
287147ea3bb5SYongqiang Yang 	ee_block = le32_to_cpu(ex->ee_block);
287247ea3bb5SYongqiang Yang 	ee_len = ext4_ext_get_actual_len(ex);
287347ea3bb5SYongqiang Yang 	uninitialized = ext4_ext_is_uninitialized(ex);
287447ea3bb5SYongqiang Yang 
287547ea3bb5SYongqiang Yang 	if (map->m_lblk + map->m_len < ee_block + ee_len) {
287647ea3bb5SYongqiang Yang 		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ?
287747ea3bb5SYongqiang Yang 			      EXT4_EXT_MAY_ZEROOUT : 0;
287847ea3bb5SYongqiang Yang 		flags1 = flags | EXT4_GET_BLOCKS_PRE_IO;
287947ea3bb5SYongqiang Yang 		if (uninitialized)
288047ea3bb5SYongqiang Yang 			split_flag1 |= EXT4_EXT_MARK_UNINIT1 |
288147ea3bb5SYongqiang Yang 				       EXT4_EXT_MARK_UNINIT2;
288247ea3bb5SYongqiang Yang 		err = ext4_split_extent_at(handle, inode, path,
288347ea3bb5SYongqiang Yang 				map->m_lblk + map->m_len, split_flag1, flags1);
288493917411SYongqiang Yang 		if (err)
288593917411SYongqiang Yang 			goto out;
288647ea3bb5SYongqiang Yang 	}
288747ea3bb5SYongqiang Yang 
288847ea3bb5SYongqiang Yang 	ext4_ext_drop_refs(path);
288947ea3bb5SYongqiang Yang 	path = ext4_ext_find_extent(inode, map->m_lblk, path);
289047ea3bb5SYongqiang Yang 	if (IS_ERR(path))
289147ea3bb5SYongqiang Yang 		return PTR_ERR(path);
289247ea3bb5SYongqiang Yang 
289347ea3bb5SYongqiang Yang 	if (map->m_lblk >= ee_block) {
289447ea3bb5SYongqiang Yang 		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ?
289547ea3bb5SYongqiang Yang 			      EXT4_EXT_MAY_ZEROOUT : 0;
289647ea3bb5SYongqiang Yang 		if (uninitialized)
289747ea3bb5SYongqiang Yang 			split_flag1 |= EXT4_EXT_MARK_UNINIT1;
289847ea3bb5SYongqiang Yang 		if (split_flag & EXT4_EXT_MARK_UNINIT2)
289947ea3bb5SYongqiang Yang 			split_flag1 |= EXT4_EXT_MARK_UNINIT2;
290047ea3bb5SYongqiang Yang 		err = ext4_split_extent_at(handle, inode, path,
290147ea3bb5SYongqiang Yang 				map->m_lblk, split_flag1, flags);
290247ea3bb5SYongqiang Yang 		if (err)
290347ea3bb5SYongqiang Yang 			goto out;
290447ea3bb5SYongqiang Yang 	}
290547ea3bb5SYongqiang Yang 
290647ea3bb5SYongqiang Yang 	ext4_ext_show_leaf(inode, path);
290747ea3bb5SYongqiang Yang out:
290847ea3bb5SYongqiang Yang 	return err ? err : map->m_len;
290947ea3bb5SYongqiang Yang }
291047ea3bb5SYongqiang Yang 
29113977c965SAneesh Kumar K.V #define EXT4_EXT_ZERO_LEN 7
291256055d3aSAmit Arora /*
2913e35fd660STheodore Ts'o  * This function is called by ext4_ext_map_blocks() if someone tries to write
291456055d3aSAmit Arora  * to an uninitialized extent. It may result in splitting the uninitialized
291556055d3aSAmit Arora  * extent into multiple extents (up to three - one initialized and two
291656055d3aSAmit Arora  * uninitialized).
291756055d3aSAmit Arora  * There are three possibilities:
291856055d3aSAmit Arora  *   a> There is no split required: Entire extent should be initialized
291956055d3aSAmit Arora  *   b> Splits in two extents: Write is happening at either end of the extent
292056055d3aSAmit Arora  *   c> Splits in three extents: Somone is writing in middle of the extent
292156055d3aSAmit Arora  */
2922725d26d3SAneesh Kumar K.V static int ext4_ext_convert_to_initialized(handle_t *handle,
2923725d26d3SAneesh Kumar K.V 					   struct inode *inode,
2924e35fd660STheodore Ts'o 					   struct ext4_map_blocks *map,
2925e35fd660STheodore Ts'o 					   struct ext4_ext_path *path)
292656055d3aSAmit Arora {
2927667eff35SYongqiang Yang 	struct ext4_map_blocks split_map;
2928667eff35SYongqiang Yang 	struct ext4_extent zero_ex;
2929667eff35SYongqiang Yang 	struct ext4_extent *ex;
293021ca087aSDmitry Monakhov 	ext4_lblk_t ee_block, eof_block;
2931*f85b287aSDan Carpenter 	unsigned int ee_len, depth;
2932*f85b287aSDan Carpenter 	int allocated;
293356055d3aSAmit Arora 	int err = 0;
2934667eff35SYongqiang Yang 	int split_flag = 0;
293521ca087aSDmitry Monakhov 
293621ca087aSDmitry Monakhov 	ext_debug("ext4_ext_convert_to_initialized: inode %lu, logical"
293721ca087aSDmitry Monakhov 		"block %llu, max_blocks %u\n", inode->i_ino,
2938e35fd660STheodore Ts'o 		(unsigned long long)map->m_lblk, map->m_len);
293921ca087aSDmitry Monakhov 
294021ca087aSDmitry Monakhov 	eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >>
294121ca087aSDmitry Monakhov 		inode->i_sb->s_blocksize_bits;
2942e35fd660STheodore Ts'o 	if (eof_block < map->m_lblk + map->m_len)
2943e35fd660STheodore Ts'o 		eof_block = map->m_lblk + map->m_len;
294456055d3aSAmit Arora 
294556055d3aSAmit Arora 	depth = ext_depth(inode);
294656055d3aSAmit Arora 	ex = path[depth].p_ext;
294756055d3aSAmit Arora 	ee_block = le32_to_cpu(ex->ee_block);
294856055d3aSAmit Arora 	ee_len = ext4_ext_get_actual_len(ex);
2949e35fd660STheodore Ts'o 	allocated = ee_len - (map->m_lblk - ee_block);
295021ca087aSDmitry Monakhov 
2951667eff35SYongqiang Yang 	WARN_ON(map->m_lblk < ee_block);
295221ca087aSDmitry Monakhov 	/*
295321ca087aSDmitry Monakhov 	 * It is safe to convert extent to initialized via explicit
295421ca087aSDmitry Monakhov 	 * zeroout only if extent is fully insde i_size or new_size.
295521ca087aSDmitry Monakhov 	 */
2956667eff35SYongqiang Yang 	split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0;
295721ca087aSDmitry Monakhov 
29583977c965SAneesh Kumar K.V 	/* If extent has less than 2*EXT4_EXT_ZERO_LEN zerout directly */
2959667eff35SYongqiang Yang 	if (ee_len <= 2*EXT4_EXT_ZERO_LEN &&
2960667eff35SYongqiang Yang 	    (EXT4_EXT_MAY_ZEROOUT & split_flag)) {
2961667eff35SYongqiang Yang 		err = ext4_ext_zeroout(inode, ex);
29623977c965SAneesh Kumar K.V 		if (err)
296356055d3aSAmit Arora 			goto out;
29649df5643aSAneesh Kumar K.V 
29659df5643aSAneesh Kumar K.V 		err = ext4_ext_get_access(handle, inode, path + depth);
29669df5643aSAneesh Kumar K.V 		if (err)
29679df5643aSAneesh Kumar K.V 			goto out;
2968667eff35SYongqiang Yang 		ext4_ext_mark_initialized(ex);
2969667eff35SYongqiang Yang 		ext4_ext_try_to_merge(inode, path, ex);
297056055d3aSAmit Arora 		err = ext4_ext_dirty(handle, inode, path + depth);
297156055d3aSAmit Arora 		goto out;
2972667eff35SYongqiang Yang 	}
2973093a088bSAneesh Kumar K.V 
2974667eff35SYongqiang Yang 	/*
2975667eff35SYongqiang Yang 	 * four cases:
2976667eff35SYongqiang Yang 	 * 1. split the extent into three extents.
2977667eff35SYongqiang Yang 	 * 2. split the extent into two extents, zeroout the first half.
2978667eff35SYongqiang Yang 	 * 3. split the extent into two extents, zeroout the second half.
2979667eff35SYongqiang Yang 	 * 4. split the extent into two extents with out zeroout.
2980667eff35SYongqiang Yang 	 */
2981667eff35SYongqiang Yang 	split_map.m_lblk = map->m_lblk;
2982667eff35SYongqiang Yang 	split_map.m_len = map->m_len;
2983667eff35SYongqiang Yang 
2984667eff35SYongqiang Yang 	if (allocated > map->m_len) {
2985667eff35SYongqiang Yang 		if (allocated <= EXT4_EXT_ZERO_LEN &&
2986667eff35SYongqiang Yang 		    (EXT4_EXT_MAY_ZEROOUT & split_flag)) {
2987667eff35SYongqiang Yang 			/* case 3 */
2988667eff35SYongqiang Yang 			zero_ex.ee_block =
29899b940f8eSAllison Henderson 					 cpu_to_le32(map->m_lblk);
29909b940f8eSAllison Henderson 			zero_ex.ee_len = cpu_to_le16(allocated);
2991667eff35SYongqiang Yang 			ext4_ext_store_pblock(&zero_ex,
2992667eff35SYongqiang Yang 				ext4_ext_pblock(ex) + map->m_lblk - ee_block);
2993667eff35SYongqiang Yang 			err = ext4_ext_zeroout(inode, &zero_ex);
2994667eff35SYongqiang Yang 			if (err)
2995667eff35SYongqiang Yang 				goto out;
2996667eff35SYongqiang Yang 			split_map.m_lblk = map->m_lblk;
2997667eff35SYongqiang Yang 			split_map.m_len = allocated;
2998667eff35SYongqiang Yang 		} else if ((map->m_lblk - ee_block + map->m_len <
2999667eff35SYongqiang Yang 			   EXT4_EXT_ZERO_LEN) &&
3000667eff35SYongqiang Yang 			   (EXT4_EXT_MAY_ZEROOUT & split_flag)) {
3001667eff35SYongqiang Yang 			/* case 2 */
3002667eff35SYongqiang Yang 			if (map->m_lblk != ee_block) {
3003667eff35SYongqiang Yang 				zero_ex.ee_block = ex->ee_block;
3004667eff35SYongqiang Yang 				zero_ex.ee_len = cpu_to_le16(map->m_lblk -
3005667eff35SYongqiang Yang 							ee_block);
3006667eff35SYongqiang Yang 				ext4_ext_store_pblock(&zero_ex,
3007667eff35SYongqiang Yang 						      ext4_ext_pblock(ex));
3008667eff35SYongqiang Yang 				err = ext4_ext_zeroout(inode, &zero_ex);
3009667eff35SYongqiang Yang 				if (err)
3010667eff35SYongqiang Yang 					goto out;
3011667eff35SYongqiang Yang 			}
3012667eff35SYongqiang Yang 
3013667eff35SYongqiang Yang 			split_map.m_lblk = ee_block;
30149b940f8eSAllison Henderson 			split_map.m_len = map->m_lblk - ee_block + map->m_len;
30159b940f8eSAllison Henderson 			allocated = map->m_len;
3016667eff35SYongqiang Yang 		}
3017667eff35SYongqiang Yang 	}
3018667eff35SYongqiang Yang 
3019667eff35SYongqiang Yang 	allocated = ext4_split_extent(handle, inode, path,
3020667eff35SYongqiang Yang 				       &split_map, split_flag, 0);
3021667eff35SYongqiang Yang 	if (allocated < 0)
3022667eff35SYongqiang Yang 		err = allocated;
3023667eff35SYongqiang Yang 
3024667eff35SYongqiang Yang out:
3025667eff35SYongqiang Yang 	return err ? err : allocated;
302656055d3aSAmit Arora }
302756055d3aSAmit Arora 
3028c278bfecSAneesh Kumar K.V /*
3029e35fd660STheodore Ts'o  * This function is called by ext4_ext_map_blocks() from
30300031462bSMingming Cao  * ext4_get_blocks_dio_write() when DIO to write
30310031462bSMingming Cao  * to an uninitialized extent.
30320031462bSMingming Cao  *
3033fd018fe8SPaul Bolle  * Writing to an uninitialized extent may result in splitting the uninitialized
3034b595076aSUwe Kleine-König  * extent into multiple /initialized uninitialized extents (up to three)
30350031462bSMingming Cao  * There are three possibilities:
30360031462bSMingming Cao  *   a> There is no split required: Entire extent should be uninitialized
30370031462bSMingming Cao  *   b> Splits in two extents: Write is happening at either end of the extent
30380031462bSMingming Cao  *   c> Splits in three extents: Somone is writing in middle of the extent
30390031462bSMingming Cao  *
30400031462bSMingming Cao  * One of more index blocks maybe needed if the extent tree grow after
3041b595076aSUwe Kleine-König  * the uninitialized extent split. To prevent ENOSPC occur at the IO
30420031462bSMingming Cao  * complete, we need to split the uninitialized extent before DIO submit
3043421f91d2SUwe Kleine-König  * the IO. The uninitialized extent called at this time will be split
30440031462bSMingming Cao  * into three uninitialized extent(at most). After IO complete, the part
30450031462bSMingming Cao  * being filled will be convert to initialized by the end_io callback function
30460031462bSMingming Cao  * via ext4_convert_unwritten_extents().
3047ba230c3fSMingming  *
3048ba230c3fSMingming  * Returns the size of uninitialized extent to be written on success.
30490031462bSMingming Cao  */
30500031462bSMingming Cao static int ext4_split_unwritten_extents(handle_t *handle,
30510031462bSMingming Cao 					struct inode *inode,
3052e35fd660STheodore Ts'o 					struct ext4_map_blocks *map,
30530031462bSMingming Cao 					struct ext4_ext_path *path,
30540031462bSMingming Cao 					int flags)
30550031462bSMingming Cao {
3056667eff35SYongqiang Yang 	ext4_lblk_t eof_block;
3057667eff35SYongqiang Yang 	ext4_lblk_t ee_block;
3058667eff35SYongqiang Yang 	struct ext4_extent *ex;
3059667eff35SYongqiang Yang 	unsigned int ee_len;
3060667eff35SYongqiang Yang 	int split_flag = 0, depth;
30610031462bSMingming Cao 
306221ca087aSDmitry Monakhov 	ext_debug("ext4_split_unwritten_extents: inode %lu, logical"
306321ca087aSDmitry Monakhov 		"block %llu, max_blocks %u\n", inode->i_ino,
3064e35fd660STheodore Ts'o 		(unsigned long long)map->m_lblk, map->m_len);
306521ca087aSDmitry Monakhov 
306621ca087aSDmitry Monakhov 	eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >>
306721ca087aSDmitry Monakhov 		inode->i_sb->s_blocksize_bits;
3068e35fd660STheodore Ts'o 	if (eof_block < map->m_lblk + map->m_len)
3069e35fd660STheodore Ts'o 		eof_block = map->m_lblk + map->m_len;
30700031462bSMingming Cao 	/*
307121ca087aSDmitry Monakhov 	 * It is safe to convert extent to initialized via explicit
307221ca087aSDmitry Monakhov 	 * zeroout only if extent is fully insde i_size or new_size.
307321ca087aSDmitry Monakhov 	 */
3074667eff35SYongqiang Yang 	depth = ext_depth(inode);
30750031462bSMingming Cao 	ex = path[depth].p_ext;
3076667eff35SYongqiang Yang 	ee_block = le32_to_cpu(ex->ee_block);
3077667eff35SYongqiang Yang 	ee_len = ext4_ext_get_actual_len(ex);
30780031462bSMingming Cao 
3079667eff35SYongqiang Yang 	split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0;
3080667eff35SYongqiang Yang 	split_flag |= EXT4_EXT_MARK_UNINIT2;
30810031462bSMingming Cao 
3082667eff35SYongqiang Yang 	flags |= EXT4_GET_BLOCKS_PRE_IO;
3083667eff35SYongqiang Yang 	return ext4_split_extent(handle, inode, path, map, split_flag, flags);
30840031462bSMingming Cao }
3085197217a5SYongqiang Yang 
3086c7064ef1SJiaying Zhang static int ext4_convert_unwritten_extents_endio(handle_t *handle,
30870031462bSMingming Cao 					      struct inode *inode,
30880031462bSMingming Cao 					      struct ext4_ext_path *path)
30890031462bSMingming Cao {
30900031462bSMingming Cao 	struct ext4_extent *ex;
30910031462bSMingming Cao 	int depth;
30920031462bSMingming Cao 	int err = 0;
30930031462bSMingming Cao 
30940031462bSMingming Cao 	depth = ext_depth(inode);
30950031462bSMingming Cao 	ex = path[depth].p_ext;
30960031462bSMingming Cao 
3097197217a5SYongqiang Yang 	ext_debug("ext4_convert_unwritten_extents_endio: inode %lu, logical"
3098197217a5SYongqiang Yang 		"block %llu, max_blocks %u\n", inode->i_ino,
3099197217a5SYongqiang Yang 		(unsigned long long)le32_to_cpu(ex->ee_block),
3100197217a5SYongqiang Yang 		ext4_ext_get_actual_len(ex));
3101197217a5SYongqiang Yang 
31020031462bSMingming Cao 	err = ext4_ext_get_access(handle, inode, path + depth);
31030031462bSMingming Cao 	if (err)
31040031462bSMingming Cao 		goto out;
31050031462bSMingming Cao 	/* first mark the extent as initialized */
31060031462bSMingming Cao 	ext4_ext_mark_initialized(ex);
31070031462bSMingming Cao 
3108197217a5SYongqiang Yang 	/* note: ext4_ext_correct_indexes() isn't needed here because
3109197217a5SYongqiang Yang 	 * borders are not changed
31100031462bSMingming Cao 	 */
3111197217a5SYongqiang Yang 	ext4_ext_try_to_merge(inode, path, ex);
3112197217a5SYongqiang Yang 
31130031462bSMingming Cao 	/* Mark modified extent as dirty */
31140031462bSMingming Cao 	err = ext4_ext_dirty(handle, inode, path + depth);
31150031462bSMingming Cao out:
31160031462bSMingming Cao 	ext4_ext_show_leaf(inode, path);
31170031462bSMingming Cao 	return err;
31180031462bSMingming Cao }
31190031462bSMingming Cao 
3120515f41c3SAneesh Kumar K.V static void unmap_underlying_metadata_blocks(struct block_device *bdev,
3121515f41c3SAneesh Kumar K.V 			sector_t block, int count)
3122515f41c3SAneesh Kumar K.V {
3123515f41c3SAneesh Kumar K.V 	int i;
3124515f41c3SAneesh Kumar K.V 	for (i = 0; i < count; i++)
3125515f41c3SAneesh Kumar K.V                 unmap_underlying_metadata(bdev, block + i);
3126515f41c3SAneesh Kumar K.V }
3127515f41c3SAneesh Kumar K.V 
312858590b06STheodore Ts'o /*
312958590b06STheodore Ts'o  * Handle EOFBLOCKS_FL flag, clearing it if necessary
313058590b06STheodore Ts'o  */
313158590b06STheodore Ts'o static int check_eofblocks_fl(handle_t *handle, struct inode *inode,
3132d002ebf1SEric Sandeen 			      ext4_lblk_t lblk,
313358590b06STheodore Ts'o 			      struct ext4_ext_path *path,
313458590b06STheodore Ts'o 			      unsigned int len)
313558590b06STheodore Ts'o {
313658590b06STheodore Ts'o 	int i, depth;
313758590b06STheodore Ts'o 	struct ext4_extent_header *eh;
313865922cb5SSergey Senozhatsky 	struct ext4_extent *last_ex;
313958590b06STheodore Ts'o 
314058590b06STheodore Ts'o 	if (!ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS))
314158590b06STheodore Ts'o 		return 0;
314258590b06STheodore Ts'o 
314358590b06STheodore Ts'o 	depth = ext_depth(inode);
314458590b06STheodore Ts'o 	eh = path[depth].p_hdr;
314558590b06STheodore Ts'o 
314658590b06STheodore Ts'o 	if (unlikely(!eh->eh_entries)) {
314758590b06STheodore Ts'o 		EXT4_ERROR_INODE(inode, "eh->eh_entries == 0 and "
314858590b06STheodore Ts'o 				 "EOFBLOCKS_FL set");
314958590b06STheodore Ts'o 		return -EIO;
315058590b06STheodore Ts'o 	}
315158590b06STheodore Ts'o 	last_ex = EXT_LAST_EXTENT(eh);
315258590b06STheodore Ts'o 	/*
315358590b06STheodore Ts'o 	 * We should clear the EOFBLOCKS_FL flag if we are writing the
315458590b06STheodore Ts'o 	 * last block in the last extent in the file.  We test this by
315558590b06STheodore Ts'o 	 * first checking to see if the caller to
315658590b06STheodore Ts'o 	 * ext4_ext_get_blocks() was interested in the last block (or
315758590b06STheodore Ts'o 	 * a block beyond the last block) in the current extent.  If
315858590b06STheodore Ts'o 	 * this turns out to be false, we can bail out from this
315958590b06STheodore Ts'o 	 * function immediately.
316058590b06STheodore Ts'o 	 */
3161d002ebf1SEric Sandeen 	if (lblk + len < le32_to_cpu(last_ex->ee_block) +
316258590b06STheodore Ts'o 	    ext4_ext_get_actual_len(last_ex))
316358590b06STheodore Ts'o 		return 0;
316458590b06STheodore Ts'o 	/*
316558590b06STheodore Ts'o 	 * If the caller does appear to be planning to write at or
316658590b06STheodore Ts'o 	 * beyond the end of the current extent, we then test to see
316758590b06STheodore Ts'o 	 * if the current extent is the last extent in the file, by
316858590b06STheodore Ts'o 	 * checking to make sure it was reached via the rightmost node
316958590b06STheodore Ts'o 	 * at each level of the tree.
317058590b06STheodore Ts'o 	 */
317158590b06STheodore Ts'o 	for (i = depth-1; i >= 0; i--)
317258590b06STheodore Ts'o 		if (path[i].p_idx != EXT_LAST_INDEX(path[i].p_hdr))
317358590b06STheodore Ts'o 			return 0;
317458590b06STheodore Ts'o 	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
317558590b06STheodore Ts'o 	return ext4_mark_inode_dirty(handle, inode);
317658590b06STheodore Ts'o }
317758590b06STheodore Ts'o 
31787b415bf6SAditya Kali /**
31797b415bf6SAditya Kali  * ext4_find_delalloc_range: find delayed allocated block in the given range.
31807b415bf6SAditya Kali  *
31817b415bf6SAditya Kali  * Goes through the buffer heads in the range [lblk_start, lblk_end] and returns
31827b415bf6SAditya Kali  * whether there are any buffers marked for delayed allocation. It returns '1'
31837b415bf6SAditya Kali  * on the first delalloc'ed buffer head found. If no buffer head in the given
31847b415bf6SAditya Kali  * range is marked for delalloc, it returns 0.
31857b415bf6SAditya Kali  * lblk_start should always be <= lblk_end.
31867b415bf6SAditya Kali  * search_hint_reverse is to indicate that searching in reverse from lblk_end to
31877b415bf6SAditya Kali  * lblk_start might be more efficient (i.e., we will likely hit the delalloc'ed
31887b415bf6SAditya Kali  * block sooner). This is useful when blocks are truncated sequentially from
31897b415bf6SAditya Kali  * lblk_start towards lblk_end.
31907b415bf6SAditya Kali  */
31917b415bf6SAditya Kali static int ext4_find_delalloc_range(struct inode *inode,
31927b415bf6SAditya Kali 				    ext4_lblk_t lblk_start,
31937b415bf6SAditya Kali 				    ext4_lblk_t lblk_end,
31947b415bf6SAditya Kali 				    int search_hint_reverse)
31957b415bf6SAditya Kali {
31967b415bf6SAditya Kali 	struct address_space *mapping = inode->i_mapping;
31977b415bf6SAditya Kali 	struct buffer_head *head, *bh = NULL;
31987b415bf6SAditya Kali 	struct page *page;
31997b415bf6SAditya Kali 	ext4_lblk_t i, pg_lblk;
32007b415bf6SAditya Kali 	pgoff_t index;
32017b415bf6SAditya Kali 
32027b415bf6SAditya Kali 	/* reverse search wont work if fs block size is less than page size */
32037b415bf6SAditya Kali 	if (inode->i_blkbits < PAGE_CACHE_SHIFT)
32047b415bf6SAditya Kali 		search_hint_reverse = 0;
32057b415bf6SAditya Kali 
32067b415bf6SAditya Kali 	if (search_hint_reverse)
32077b415bf6SAditya Kali 		i = lblk_end;
32087b415bf6SAditya Kali 	else
32097b415bf6SAditya Kali 		i = lblk_start;
32107b415bf6SAditya Kali 
32117b415bf6SAditya Kali 	index = i >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
32127b415bf6SAditya Kali 
32137b415bf6SAditya Kali 	while ((i >= lblk_start) && (i <= lblk_end)) {
32147b415bf6SAditya Kali 		page = find_get_page(mapping, index);
32155356f261SAditya Kali 		if (!page)
32167b415bf6SAditya Kali 			goto nextpage;
32177b415bf6SAditya Kali 
32187b415bf6SAditya Kali 		if (!page_has_buffers(page))
32197b415bf6SAditya Kali 			goto nextpage;
32207b415bf6SAditya Kali 
32217b415bf6SAditya Kali 		head = page_buffers(page);
32227b415bf6SAditya Kali 		if (!head)
32237b415bf6SAditya Kali 			goto nextpage;
32247b415bf6SAditya Kali 
32257b415bf6SAditya Kali 		bh = head;
32267b415bf6SAditya Kali 		pg_lblk = index << (PAGE_CACHE_SHIFT -
32277b415bf6SAditya Kali 						inode->i_blkbits);
32287b415bf6SAditya Kali 		do {
32297b415bf6SAditya Kali 			if (unlikely(pg_lblk < lblk_start)) {
32307b415bf6SAditya Kali 				/*
32317b415bf6SAditya Kali 				 * This is possible when fs block size is less
32327b415bf6SAditya Kali 				 * than page size and our cluster starts/ends in
32337b415bf6SAditya Kali 				 * middle of the page. So we need to skip the
32347b415bf6SAditya Kali 				 * initial few blocks till we reach the 'lblk'
32357b415bf6SAditya Kali 				 */
32367b415bf6SAditya Kali 				pg_lblk++;
32377b415bf6SAditya Kali 				continue;
32387b415bf6SAditya Kali 			}
32397b415bf6SAditya Kali 
32405356f261SAditya Kali 			/* Check if the buffer is delayed allocated and that it
32415356f261SAditya Kali 			 * is not yet mapped. (when da-buffers are mapped during
32425356f261SAditya Kali 			 * their writeout, their da_mapped bit is set.)
32435356f261SAditya Kali 			 */
32445356f261SAditya Kali 			if (buffer_delay(bh) && !buffer_da_mapped(bh)) {
32457b415bf6SAditya Kali 				page_cache_release(page);
3246d8990240SAditya Kali 				trace_ext4_find_delalloc_range(inode,
3247d8990240SAditya Kali 						lblk_start, lblk_end,
3248d8990240SAditya Kali 						search_hint_reverse,
3249d8990240SAditya Kali 						1, i);
32507b415bf6SAditya Kali 				return 1;
32517b415bf6SAditya Kali 			}
32527b415bf6SAditya Kali 			if (search_hint_reverse)
32537b415bf6SAditya Kali 				i--;
32547b415bf6SAditya Kali 			else
32557b415bf6SAditya Kali 				i++;
32567b415bf6SAditya Kali 		} while ((i >= lblk_start) && (i <= lblk_end) &&
32577b415bf6SAditya Kali 				((bh = bh->b_this_page) != head));
32587b415bf6SAditya Kali nextpage:
32597b415bf6SAditya Kali 		if (page)
32607b415bf6SAditya Kali 			page_cache_release(page);
32617b415bf6SAditya Kali 		/*
32627b415bf6SAditya Kali 		 * Move to next page. 'i' will be the first lblk in the next
32637b415bf6SAditya Kali 		 * page.
32647b415bf6SAditya Kali 		 */
32657b415bf6SAditya Kali 		if (search_hint_reverse)
32667b415bf6SAditya Kali 			index--;
32677b415bf6SAditya Kali 		else
32687b415bf6SAditya Kali 			index++;
32697b415bf6SAditya Kali 		i = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
32707b415bf6SAditya Kali 	}
32717b415bf6SAditya Kali 
3272d8990240SAditya Kali 	trace_ext4_find_delalloc_range(inode, lblk_start, lblk_end,
3273d8990240SAditya Kali 					search_hint_reverse, 0, 0);
32747b415bf6SAditya Kali 	return 0;
32757b415bf6SAditya Kali }
32767b415bf6SAditya Kali 
32777b415bf6SAditya Kali int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk,
32787b415bf6SAditya Kali 			       int search_hint_reverse)
32797b415bf6SAditya Kali {
32807b415bf6SAditya Kali 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
32817b415bf6SAditya Kali 	ext4_lblk_t lblk_start, lblk_end;
32827b415bf6SAditya Kali 	lblk_start = lblk & (~(sbi->s_cluster_ratio - 1));
32837b415bf6SAditya Kali 	lblk_end = lblk_start + sbi->s_cluster_ratio - 1;
32847b415bf6SAditya Kali 
32857b415bf6SAditya Kali 	return ext4_find_delalloc_range(inode, lblk_start, lblk_end,
32867b415bf6SAditya Kali 					search_hint_reverse);
32877b415bf6SAditya Kali }
32887b415bf6SAditya Kali 
32897b415bf6SAditya Kali /**
32907b415bf6SAditya Kali  * Determines how many complete clusters (out of those specified by the 'map')
32917b415bf6SAditya Kali  * are under delalloc and were reserved quota for.
32927b415bf6SAditya Kali  * This function is called when we are writing out the blocks that were
32937b415bf6SAditya Kali  * originally written with their allocation delayed, but then the space was
32947b415bf6SAditya Kali  * allocated using fallocate() before the delayed allocation could be resolved.
32957b415bf6SAditya Kali  * The cases to look for are:
32967b415bf6SAditya Kali  * ('=' indicated delayed allocated blocks
32977b415bf6SAditya Kali  *  '-' indicates non-delayed allocated blocks)
32987b415bf6SAditya Kali  * (a) partial clusters towards beginning and/or end outside of allocated range
32997b415bf6SAditya Kali  *     are not delalloc'ed.
33007b415bf6SAditya Kali  *	Ex:
33017b415bf6SAditya Kali  *	|----c---=|====c====|====c====|===-c----|
33027b415bf6SAditya Kali  *	         |++++++ allocated ++++++|
33037b415bf6SAditya Kali  *	==> 4 complete clusters in above example
33047b415bf6SAditya Kali  *
33057b415bf6SAditya Kali  * (b) partial cluster (outside of allocated range) towards either end is
33067b415bf6SAditya Kali  *     marked for delayed allocation. In this case, we will exclude that
33077b415bf6SAditya Kali  *     cluster.
33087b415bf6SAditya Kali  *	Ex:
33097b415bf6SAditya Kali  *	|----====c========|========c========|
33107b415bf6SAditya Kali  *	     |++++++ allocated ++++++|
33117b415bf6SAditya Kali  *	==> 1 complete clusters in above example
33127b415bf6SAditya Kali  *
33137b415bf6SAditya Kali  *	Ex:
33147b415bf6SAditya Kali  *	|================c================|
33157b415bf6SAditya Kali  *            |++++++ allocated ++++++|
33167b415bf6SAditya Kali  *	==> 0 complete clusters in above example
33177b415bf6SAditya Kali  *
33187b415bf6SAditya Kali  * The ext4_da_update_reserve_space will be called only if we
33197b415bf6SAditya Kali  * determine here that there were some "entire" clusters that span
33207b415bf6SAditya Kali  * this 'allocated' range.
33217b415bf6SAditya Kali  * In the non-bigalloc case, this function will just end up returning num_blks
33227b415bf6SAditya Kali  * without ever calling ext4_find_delalloc_range.
33237b415bf6SAditya Kali  */
33247b415bf6SAditya Kali static unsigned int
33257b415bf6SAditya Kali get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start,
33267b415bf6SAditya Kali 			   unsigned int num_blks)
33277b415bf6SAditya Kali {
33287b415bf6SAditya Kali 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
33297b415bf6SAditya Kali 	ext4_lblk_t alloc_cluster_start, alloc_cluster_end;
33307b415bf6SAditya Kali 	ext4_lblk_t lblk_from, lblk_to, c_offset;
33317b415bf6SAditya Kali 	unsigned int allocated_clusters = 0;
33327b415bf6SAditya Kali 
33337b415bf6SAditya Kali 	alloc_cluster_start = EXT4_B2C(sbi, lblk_start);
33347b415bf6SAditya Kali 	alloc_cluster_end = EXT4_B2C(sbi, lblk_start + num_blks - 1);
33357b415bf6SAditya Kali 
33367b415bf6SAditya Kali 	/* max possible clusters for this allocation */
33377b415bf6SAditya Kali 	allocated_clusters = alloc_cluster_end - alloc_cluster_start + 1;
33387b415bf6SAditya Kali 
3339d8990240SAditya Kali 	trace_ext4_get_reserved_cluster_alloc(inode, lblk_start, num_blks);
3340d8990240SAditya Kali 
33417b415bf6SAditya Kali 	/* Check towards left side */
33427b415bf6SAditya Kali 	c_offset = lblk_start & (sbi->s_cluster_ratio - 1);
33437b415bf6SAditya Kali 	if (c_offset) {
33447b415bf6SAditya Kali 		lblk_from = lblk_start & (~(sbi->s_cluster_ratio - 1));
33457b415bf6SAditya Kali 		lblk_to = lblk_from + c_offset - 1;
33467b415bf6SAditya Kali 
33477b415bf6SAditya Kali 		if (ext4_find_delalloc_range(inode, lblk_from, lblk_to, 0))
33487b415bf6SAditya Kali 			allocated_clusters--;
33497b415bf6SAditya Kali 	}
33507b415bf6SAditya Kali 
33517b415bf6SAditya Kali 	/* Now check towards right. */
33527b415bf6SAditya Kali 	c_offset = (lblk_start + num_blks) & (sbi->s_cluster_ratio - 1);
33537b415bf6SAditya Kali 	if (allocated_clusters && c_offset) {
33547b415bf6SAditya Kali 		lblk_from = lblk_start + num_blks;
33557b415bf6SAditya Kali 		lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1;
33567b415bf6SAditya Kali 
33577b415bf6SAditya Kali 		if (ext4_find_delalloc_range(inode, lblk_from, lblk_to, 0))
33587b415bf6SAditya Kali 			allocated_clusters--;
33597b415bf6SAditya Kali 	}
33607b415bf6SAditya Kali 
33617b415bf6SAditya Kali 	return allocated_clusters;
33627b415bf6SAditya Kali }
33637b415bf6SAditya Kali 
33640031462bSMingming Cao static int
33650031462bSMingming Cao ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,
3366e35fd660STheodore Ts'o 			struct ext4_map_blocks *map,
33670031462bSMingming Cao 			struct ext4_ext_path *path, int flags,
3368e35fd660STheodore Ts'o 			unsigned int allocated, ext4_fsblk_t newblock)
33690031462bSMingming Cao {
33700031462bSMingming Cao 	int ret = 0;
33710031462bSMingming Cao 	int err = 0;
33728d5d02e6SMingming Cao 	ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio;
33730031462bSMingming Cao 
33740031462bSMingming Cao 	ext_debug("ext4_ext_handle_uninitialized_extents: inode %lu, logical"
33750031462bSMingming Cao 		  "block %llu, max_blocks %u, flags %d, allocated %u",
3376e35fd660STheodore Ts'o 		  inode->i_ino, (unsigned long long)map->m_lblk, map->m_len,
33770031462bSMingming Cao 		  flags, allocated);
33780031462bSMingming Cao 	ext4_ext_show_leaf(inode, path);
33790031462bSMingming Cao 
3380d8990240SAditya Kali 	trace_ext4_ext_handle_uninitialized_extents(inode, map, allocated,
3381d8990240SAditya Kali 						    newblock);
3382d8990240SAditya Kali 
3383c7064ef1SJiaying Zhang 	/* get_block() before submit the IO, split the extent */
3384744692dcSJiaying Zhang 	if ((flags & EXT4_GET_BLOCKS_PRE_IO)) {
3385e35fd660STheodore Ts'o 		ret = ext4_split_unwritten_extents(handle, inode, map,
3386e35fd660STheodore Ts'o 						   path, flags);
33875f524950SMingming 		/*
33885f524950SMingming 		 * Flag the inode(non aio case) or end_io struct (aio case)
338925985edcSLucas De Marchi 		 * that this IO needs to conversion to written when IO is
33905f524950SMingming 		 * completed
33915f524950SMingming 		 */
3392e9e3bcecSEric Sandeen 		if (io && !(io->flag & EXT4_IO_END_UNWRITTEN)) {
3393bd2d0210STheodore Ts'o 			io->flag = EXT4_IO_END_UNWRITTEN;
3394e9e3bcecSEric Sandeen 			atomic_inc(&EXT4_I(inode)->i_aiodio_unwritten);
3395e9e3bcecSEric Sandeen 		} else
339619f5fb7aSTheodore Ts'o 			ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
3397744692dcSJiaying Zhang 		if (ext4_should_dioread_nolock(inode))
3398e35fd660STheodore Ts'o 			map->m_flags |= EXT4_MAP_UNINIT;
33990031462bSMingming Cao 		goto out;
34000031462bSMingming Cao 	}
3401c7064ef1SJiaying Zhang 	/* IO end_io complete, convert the filled extent to written */
3402744692dcSJiaying Zhang 	if ((flags & EXT4_GET_BLOCKS_CONVERT)) {
3403c7064ef1SJiaying Zhang 		ret = ext4_convert_unwritten_extents_endio(handle, inode,
34040031462bSMingming Cao 							path);
340558590b06STheodore Ts'o 		if (ret >= 0) {
3406b436b9beSJan Kara 			ext4_update_inode_fsync_trans(handle, inode, 1);
3407d002ebf1SEric Sandeen 			err = check_eofblocks_fl(handle, inode, map->m_lblk,
3408d002ebf1SEric Sandeen 						 path, map->m_len);
340958590b06STheodore Ts'o 		} else
341058590b06STheodore Ts'o 			err = ret;
34110031462bSMingming Cao 		goto out2;
34120031462bSMingming Cao 	}
34130031462bSMingming Cao 	/* buffered IO case */
34140031462bSMingming Cao 	/*
34150031462bSMingming Cao 	 * repeat fallocate creation request
34160031462bSMingming Cao 	 * we already have an unwritten extent
34170031462bSMingming Cao 	 */
34180031462bSMingming Cao 	if (flags & EXT4_GET_BLOCKS_UNINIT_EXT)
34190031462bSMingming Cao 		goto map_out;
34200031462bSMingming Cao 
34210031462bSMingming Cao 	/* buffered READ or buffered write_begin() lookup */
34220031462bSMingming Cao 	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
34230031462bSMingming Cao 		/*
34240031462bSMingming Cao 		 * We have blocks reserved already.  We
34250031462bSMingming Cao 		 * return allocated blocks so that delalloc
34260031462bSMingming Cao 		 * won't do block reservation for us.  But
34270031462bSMingming Cao 		 * the buffer head will be unmapped so that
34280031462bSMingming Cao 		 * a read from the block returns 0s.
34290031462bSMingming Cao 		 */
3430e35fd660STheodore Ts'o 		map->m_flags |= EXT4_MAP_UNWRITTEN;
34310031462bSMingming Cao 		goto out1;
34320031462bSMingming Cao 	}
34330031462bSMingming Cao 
34340031462bSMingming Cao 	/* buffered write, writepage time, convert*/
3435e35fd660STheodore Ts'o 	ret = ext4_ext_convert_to_initialized(handle, inode, map, path);
3436a4e5d88bSDmitry Monakhov 	if (ret >= 0)
3437b436b9beSJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 1);
34380031462bSMingming Cao out:
34390031462bSMingming Cao 	if (ret <= 0) {
34400031462bSMingming Cao 		err = ret;
34410031462bSMingming Cao 		goto out2;
34420031462bSMingming Cao 	} else
34430031462bSMingming Cao 		allocated = ret;
3444e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_NEW;
3445515f41c3SAneesh Kumar K.V 	/*
3446515f41c3SAneesh Kumar K.V 	 * if we allocated more blocks than requested
3447515f41c3SAneesh Kumar K.V 	 * we need to make sure we unmap the extra block
3448515f41c3SAneesh Kumar K.V 	 * allocated. The actual needed block will get
3449515f41c3SAneesh Kumar K.V 	 * unmapped later when we find the buffer_head marked
3450515f41c3SAneesh Kumar K.V 	 * new.
3451515f41c3SAneesh Kumar K.V 	 */
3452e35fd660STheodore Ts'o 	if (allocated > map->m_len) {
3453515f41c3SAneesh Kumar K.V 		unmap_underlying_metadata_blocks(inode->i_sb->s_bdev,
3454e35fd660STheodore Ts'o 					newblock + map->m_len,
3455e35fd660STheodore Ts'o 					allocated - map->m_len);
3456e35fd660STheodore Ts'o 		allocated = map->m_len;
3457515f41c3SAneesh Kumar K.V 	}
34585f634d06SAneesh Kumar K.V 
34595f634d06SAneesh Kumar K.V 	/*
34605f634d06SAneesh Kumar K.V 	 * If we have done fallocate with the offset that is already
34615f634d06SAneesh Kumar K.V 	 * delayed allocated, we would have block reservation
34625f634d06SAneesh Kumar K.V 	 * and quota reservation done in the delayed write path.
34635f634d06SAneesh Kumar K.V 	 * But fallocate would have already updated quota and block
34645f634d06SAneesh Kumar K.V 	 * count for this offset. So cancel these reservation
34655f634d06SAneesh Kumar K.V 	 */
34667b415bf6SAditya Kali 	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
34677b415bf6SAditya Kali 		unsigned int reserved_clusters;
34687b415bf6SAditya Kali 		reserved_clusters = get_reserved_cluster_alloc(inode,
34697b415bf6SAditya Kali 				map->m_lblk, map->m_len);
34707b415bf6SAditya Kali 		if (reserved_clusters)
34717b415bf6SAditya Kali 			ext4_da_update_reserve_space(inode,
34727b415bf6SAditya Kali 						     reserved_clusters,
34737b415bf6SAditya Kali 						     0);
34747b415bf6SAditya Kali 	}
34755f634d06SAneesh Kumar K.V 
34760031462bSMingming Cao map_out:
3477e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_MAPPED;
3478a4e5d88bSDmitry Monakhov 	if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0) {
3479a4e5d88bSDmitry Monakhov 		err = check_eofblocks_fl(handle, inode, map->m_lblk, path,
3480a4e5d88bSDmitry Monakhov 					 map->m_len);
3481a4e5d88bSDmitry Monakhov 		if (err < 0)
3482a4e5d88bSDmitry Monakhov 			goto out2;
3483a4e5d88bSDmitry Monakhov 	}
34840031462bSMingming Cao out1:
3485e35fd660STheodore Ts'o 	if (allocated > map->m_len)
3486e35fd660STheodore Ts'o 		allocated = map->m_len;
34870031462bSMingming Cao 	ext4_ext_show_leaf(inode, path);
3488e35fd660STheodore Ts'o 	map->m_pblk = newblock;
3489e35fd660STheodore Ts'o 	map->m_len = allocated;
34900031462bSMingming Cao out2:
34910031462bSMingming Cao 	if (path) {
34920031462bSMingming Cao 		ext4_ext_drop_refs(path);
34930031462bSMingming Cao 		kfree(path);
34940031462bSMingming Cao 	}
34950031462bSMingming Cao 	return err ? err : allocated;
34960031462bSMingming Cao }
349758590b06STheodore Ts'o 
34980031462bSMingming Cao /*
34994d33b1efSTheodore Ts'o  * get_implied_cluster_alloc - check to see if the requested
35004d33b1efSTheodore Ts'o  * allocation (in the map structure) overlaps with a cluster already
35014d33b1efSTheodore Ts'o  * allocated in an extent.
3502d8990240SAditya Kali  *	@sb	The filesystem superblock structure
35034d33b1efSTheodore Ts'o  *	@map	The requested lblk->pblk mapping
35044d33b1efSTheodore Ts'o  *	@ex	The extent structure which might contain an implied
35054d33b1efSTheodore Ts'o  *			cluster allocation
35064d33b1efSTheodore Ts'o  *
35074d33b1efSTheodore Ts'o  * This function is called by ext4_ext_map_blocks() after we failed to
35084d33b1efSTheodore Ts'o  * find blocks that were already in the inode's extent tree.  Hence,
35094d33b1efSTheodore Ts'o  * we know that the beginning of the requested region cannot overlap
35104d33b1efSTheodore Ts'o  * the extent from the inode's extent tree.  There are three cases we
35114d33b1efSTheodore Ts'o  * want to catch.  The first is this case:
35124d33b1efSTheodore Ts'o  *
35134d33b1efSTheodore Ts'o  *		 |--- cluster # N--|
35144d33b1efSTheodore Ts'o  *    |--- extent ---|	|---- requested region ---|
35154d33b1efSTheodore Ts'o  *			|==========|
35164d33b1efSTheodore Ts'o  *
35174d33b1efSTheodore Ts'o  * The second case that we need to test for is this one:
35184d33b1efSTheodore Ts'o  *
35194d33b1efSTheodore Ts'o  *   |--------- cluster # N ----------------|
35204d33b1efSTheodore Ts'o  *	   |--- requested region --|   |------- extent ----|
35214d33b1efSTheodore Ts'o  *	   |=======================|
35224d33b1efSTheodore Ts'o  *
35234d33b1efSTheodore Ts'o  * The third case is when the requested region lies between two extents
35244d33b1efSTheodore Ts'o  * within the same cluster:
35254d33b1efSTheodore Ts'o  *          |------------- cluster # N-------------|
35264d33b1efSTheodore Ts'o  * |----- ex -----|                  |---- ex_right ----|
35274d33b1efSTheodore Ts'o  *                  |------ requested region ------|
35284d33b1efSTheodore Ts'o  *                  |================|
35294d33b1efSTheodore Ts'o  *
35304d33b1efSTheodore Ts'o  * In each of the above cases, we need to set the map->m_pblk and
35314d33b1efSTheodore Ts'o  * map->m_len so it corresponds to the return the extent labelled as
35324d33b1efSTheodore Ts'o  * "|====|" from cluster #N, since it is already in use for data in
35334d33b1efSTheodore Ts'o  * cluster EXT4_B2C(sbi, map->m_lblk).	We will then return 1 to
35344d33b1efSTheodore Ts'o  * signal to ext4_ext_map_blocks() that map->m_pblk should be treated
35354d33b1efSTheodore Ts'o  * as a new "allocated" block region.  Otherwise, we will return 0 and
35364d33b1efSTheodore Ts'o  * ext4_ext_map_blocks() will then allocate one or more new clusters
35374d33b1efSTheodore Ts'o  * by calling ext4_mb_new_blocks().
35384d33b1efSTheodore Ts'o  */
3539d8990240SAditya Kali static int get_implied_cluster_alloc(struct super_block *sb,
35404d33b1efSTheodore Ts'o 				     struct ext4_map_blocks *map,
35414d33b1efSTheodore Ts'o 				     struct ext4_extent *ex,
35424d33b1efSTheodore Ts'o 				     struct ext4_ext_path *path)
35434d33b1efSTheodore Ts'o {
3544d8990240SAditya Kali 	struct ext4_sb_info *sbi = EXT4_SB(sb);
35454d33b1efSTheodore Ts'o 	ext4_lblk_t c_offset = map->m_lblk & (sbi->s_cluster_ratio-1);
35464d33b1efSTheodore Ts'o 	ext4_lblk_t ex_cluster_start, ex_cluster_end;
35474d33b1efSTheodore Ts'o 	ext4_lblk_t rr_cluster_start, rr_cluster_end;
35484d33b1efSTheodore Ts'o 	ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
35494d33b1efSTheodore Ts'o 	ext4_fsblk_t ee_start = ext4_ext_pblock(ex);
35504d33b1efSTheodore Ts'o 	unsigned short ee_len = ext4_ext_get_actual_len(ex);
35514d33b1efSTheodore Ts'o 
35524d33b1efSTheodore Ts'o 	/* The extent passed in that we are trying to match */
35534d33b1efSTheodore Ts'o 	ex_cluster_start = EXT4_B2C(sbi, ee_block);
35544d33b1efSTheodore Ts'o 	ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1);
35554d33b1efSTheodore Ts'o 
35564d33b1efSTheodore Ts'o 	/* The requested region passed into ext4_map_blocks() */
35574d33b1efSTheodore Ts'o 	rr_cluster_start = EXT4_B2C(sbi, map->m_lblk);
35584d33b1efSTheodore Ts'o 	rr_cluster_end = EXT4_B2C(sbi, map->m_lblk + map->m_len - 1);
35594d33b1efSTheodore Ts'o 
35604d33b1efSTheodore Ts'o 	if ((rr_cluster_start == ex_cluster_end) ||
35614d33b1efSTheodore Ts'o 	    (rr_cluster_start == ex_cluster_start)) {
35624d33b1efSTheodore Ts'o 		if (rr_cluster_start == ex_cluster_end)
35634d33b1efSTheodore Ts'o 			ee_start += ee_len - 1;
35644d33b1efSTheodore Ts'o 		map->m_pblk = (ee_start & ~(sbi->s_cluster_ratio - 1)) +
35654d33b1efSTheodore Ts'o 			c_offset;
35664d33b1efSTheodore Ts'o 		map->m_len = min(map->m_len,
35674d33b1efSTheodore Ts'o 				 (unsigned) sbi->s_cluster_ratio - c_offset);
35684d33b1efSTheodore Ts'o 		/*
35694d33b1efSTheodore Ts'o 		 * Check for and handle this case:
35704d33b1efSTheodore Ts'o 		 *
35714d33b1efSTheodore Ts'o 		 *   |--------- cluster # N-------------|
35724d33b1efSTheodore Ts'o 		 *		       |------- extent ----|
35734d33b1efSTheodore Ts'o 		 *	   |--- requested region ---|
35744d33b1efSTheodore Ts'o 		 *	   |===========|
35754d33b1efSTheodore Ts'o 		 */
35764d33b1efSTheodore Ts'o 
35774d33b1efSTheodore Ts'o 		if (map->m_lblk < ee_block)
35784d33b1efSTheodore Ts'o 			map->m_len = min(map->m_len, ee_block - map->m_lblk);
35794d33b1efSTheodore Ts'o 
35804d33b1efSTheodore Ts'o 		/*
35814d33b1efSTheodore Ts'o 		 * Check for the case where there is already another allocated
35824d33b1efSTheodore Ts'o 		 * block to the right of 'ex' but before the end of the cluster.
35834d33b1efSTheodore Ts'o 		 *
35844d33b1efSTheodore Ts'o 		 *          |------------- cluster # N-------------|
35854d33b1efSTheodore Ts'o 		 * |----- ex -----|                  |---- ex_right ----|
35864d33b1efSTheodore Ts'o 		 *                  |------ requested region ------|
35874d33b1efSTheodore Ts'o 		 *                  |================|
35884d33b1efSTheodore Ts'o 		 */
35894d33b1efSTheodore Ts'o 		if (map->m_lblk > ee_block) {
35904d33b1efSTheodore Ts'o 			ext4_lblk_t next = ext4_ext_next_allocated_block(path);
35914d33b1efSTheodore Ts'o 			map->m_len = min(map->m_len, next - map->m_lblk);
35924d33b1efSTheodore Ts'o 		}
3593d8990240SAditya Kali 
3594d8990240SAditya Kali 		trace_ext4_get_implied_cluster_alloc_exit(sb, map, 1);
35954d33b1efSTheodore Ts'o 		return 1;
35964d33b1efSTheodore Ts'o 	}
3597d8990240SAditya Kali 
3598d8990240SAditya Kali 	trace_ext4_get_implied_cluster_alloc_exit(sb, map, 0);
35994d33b1efSTheodore Ts'o 	return 0;
36004d33b1efSTheodore Ts'o }
36014d33b1efSTheodore Ts'o 
36024d33b1efSTheodore Ts'o 
36034d33b1efSTheodore Ts'o /*
3604f5ab0d1fSMingming Cao  * Block allocation/map/preallocation routine for extents based files
3605f5ab0d1fSMingming Cao  *
3606f5ab0d1fSMingming Cao  *
3607c278bfecSAneesh Kumar K.V  * Need to be called with
36080e855ac8SAneesh Kumar K.V  * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
36090e855ac8SAneesh Kumar K.V  * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
3610f5ab0d1fSMingming Cao  *
3611f5ab0d1fSMingming Cao  * return > 0, number of of blocks already mapped/allocated
3612f5ab0d1fSMingming Cao  *          if create == 0 and these are pre-allocated blocks
3613f5ab0d1fSMingming Cao  *          	buffer head is unmapped
3614f5ab0d1fSMingming Cao  *          otherwise blocks are mapped
3615f5ab0d1fSMingming Cao  *
3616f5ab0d1fSMingming Cao  * return = 0, if plain look up failed (blocks have not been allocated)
3617f5ab0d1fSMingming Cao  *          buffer head is unmapped
3618f5ab0d1fSMingming Cao  *
3619f5ab0d1fSMingming Cao  * return < 0, error case.
3620c278bfecSAneesh Kumar K.V  */
3621e35fd660STheodore Ts'o int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
3622e35fd660STheodore Ts'o 			struct ext4_map_blocks *map, int flags)
3623a86c6181SAlex Tomas {
3624a86c6181SAlex Tomas 	struct ext4_ext_path *path = NULL;
36254d33b1efSTheodore Ts'o 	struct ext4_extent newex, *ex, *ex2;
36264d33b1efSTheodore Ts'o 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
36270562e0baSJiaying Zhang 	ext4_fsblk_t newblock = 0;
36284d33b1efSTheodore Ts'o 	int free_on_err = 0, err = 0, depth, ret;
36294d33b1efSTheodore Ts'o 	unsigned int allocated = 0, offset = 0;
36307b415bf6SAditya Kali 	unsigned int allocated_clusters = 0, reserved_clusters = 0;
3631e861304bSAllison Henderson 	unsigned int punched_out = 0;
3632e861304bSAllison Henderson 	unsigned int result = 0;
3633c9de560dSAlex Tomas 	struct ext4_allocation_request ar;
36348d5d02e6SMingming Cao 	ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio;
36354d33b1efSTheodore Ts'o 	ext4_lblk_t cluster_offset;
3636e861304bSAllison Henderson 	struct ext4_map_blocks punch_map;
3637a86c6181SAlex Tomas 
363884fe3befSMingming 	ext_debug("blocks %u/%u requested for inode %lu\n",
3639e35fd660STheodore Ts'o 		  map->m_lblk, map->m_len, inode->i_ino);
36400562e0baSJiaying Zhang 	trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
3641a86c6181SAlex Tomas 
3642a86c6181SAlex Tomas 	/* check in cache */
3643015861baSRobin Dong 	if (!(flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) &&
3644015861baSRobin Dong 		ext4_ext_in_cache(inode, map->m_lblk, &newex)) {
3645b05e6ae5STheodore Ts'o 		if (!newex.ee_start_lo && !newex.ee_start_hi) {
36467b415bf6SAditya Kali 			if ((sbi->s_cluster_ratio > 1) &&
36477b415bf6SAditya Kali 			    ext4_find_delalloc_cluster(inode, map->m_lblk, 0))
36487b415bf6SAditya Kali 				map->m_flags |= EXT4_MAP_FROM_CLUSTER;
36497b415bf6SAditya Kali 
3650c2177057STheodore Ts'o 			if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
365156055d3aSAmit Arora 				/*
365256055d3aSAmit Arora 				 * block isn't allocated yet and
365356055d3aSAmit Arora 				 * user doesn't want to allocate it
365456055d3aSAmit Arora 				 */
3655a86c6181SAlex Tomas 				goto out2;
3656a86c6181SAlex Tomas 			}
3657a86c6181SAlex Tomas 			/* we should allocate requested block */
3658b05e6ae5STheodore Ts'o 		} else {
3659a86c6181SAlex Tomas 			/* block is already allocated */
36607b415bf6SAditya Kali 			if (sbi->s_cluster_ratio > 1)
36617b415bf6SAditya Kali 				map->m_flags |= EXT4_MAP_FROM_CLUSTER;
3662e35fd660STheodore Ts'o 			newblock = map->m_lblk
3663a86c6181SAlex Tomas 				   - le32_to_cpu(newex.ee_block)
3664bf89d16fSTheodore Ts'o 				   + ext4_ext_pblock(&newex);
3665d0d856e8SRandy Dunlap 			/* number of remaining blocks in the extent */
3666b939e376SAneesh Kumar K.V 			allocated = ext4_ext_get_actual_len(&newex) -
3667e35fd660STheodore Ts'o 				(map->m_lblk - le32_to_cpu(newex.ee_block));
3668a86c6181SAlex Tomas 			goto out;
3669a86c6181SAlex Tomas 		}
3670a86c6181SAlex Tomas 	}
3671a86c6181SAlex Tomas 
3672a86c6181SAlex Tomas 	/* find extent for this block */
3673e35fd660STheodore Ts'o 	path = ext4_ext_find_extent(inode, map->m_lblk, NULL);
3674a86c6181SAlex Tomas 	if (IS_ERR(path)) {
3675a86c6181SAlex Tomas 		err = PTR_ERR(path);
3676a86c6181SAlex Tomas 		path = NULL;
3677a86c6181SAlex Tomas 		goto out2;
3678a86c6181SAlex Tomas 	}
3679a86c6181SAlex Tomas 
3680a86c6181SAlex Tomas 	depth = ext_depth(inode);
3681a86c6181SAlex Tomas 
3682a86c6181SAlex Tomas 	/*
3683d0d856e8SRandy Dunlap 	 * consistent leaf must not be empty;
3684d0d856e8SRandy Dunlap 	 * this situation is possible, though, _during_ tree modification;
3685a86c6181SAlex Tomas 	 * this is why assert can't be put in ext4_ext_find_extent()
3686a86c6181SAlex Tomas 	 */
3687273df556SFrank Mayhar 	if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
3688273df556SFrank Mayhar 		EXT4_ERROR_INODE(inode, "bad extent address "
3689f70f362bSTheodore Ts'o 				 "lblock: %lu, depth: %d pblock %lld",
3690f70f362bSTheodore Ts'o 				 (unsigned long) map->m_lblk, depth,
3691f70f362bSTheodore Ts'o 				 path[depth].p_block);
3692034fb4c9SSurbhi Palande 		err = -EIO;
3693034fb4c9SSurbhi Palande 		goto out2;
3694034fb4c9SSurbhi Palande 	}
3695a86c6181SAlex Tomas 
36967e028976SAvantika Mathur 	ex = path[depth].p_ext;
36977e028976SAvantika Mathur 	if (ex) {
3698725d26d3SAneesh Kumar K.V 		ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
3699bf89d16fSTheodore Ts'o 		ext4_fsblk_t ee_start = ext4_ext_pblock(ex);
3700a2df2a63SAmit Arora 		unsigned short ee_len;
3701471d4011SSuparna Bhattacharya 
3702471d4011SSuparna Bhattacharya 		/*
3703471d4011SSuparna Bhattacharya 		 * Uninitialized extents are treated as holes, except that
370456055d3aSAmit Arora 		 * we split out initialized portions during a write.
3705471d4011SSuparna Bhattacharya 		 */
3706a2df2a63SAmit Arora 		ee_len = ext4_ext_get_actual_len(ex);
3707d8990240SAditya Kali 
3708d8990240SAditya Kali 		trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len);
3709d8990240SAditya Kali 
3710d0d856e8SRandy Dunlap 		/* if found extent covers block, simply return it */
3711e35fd660STheodore Ts'o 		if (in_range(map->m_lblk, ee_block, ee_len)) {
37120aa06000STheodore Ts'o 			ext4_fsblk_t partial_cluster = 0;
37130aa06000STheodore Ts'o 
3714e35fd660STheodore Ts'o 			newblock = map->m_lblk - ee_block + ee_start;
3715d0d856e8SRandy Dunlap 			/* number of remaining blocks in the extent */
3716e35fd660STheodore Ts'o 			allocated = ee_len - (map->m_lblk - ee_block);
3717e35fd660STheodore Ts'o 			ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk,
3718a86c6181SAlex Tomas 				  ee_block, ee_len, newblock);
371956055d3aSAmit Arora 
3720e861304bSAllison Henderson 			if ((flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) == 0) {
3721e861304bSAllison Henderson 				/*
3722e861304bSAllison Henderson 				 * Do not put uninitialized extent
3723e861304bSAllison Henderson 				 * in the cache
3724e861304bSAllison Henderson 				 */
372556055d3aSAmit Arora 				if (!ext4_ext_is_uninitialized(ex)) {
3726a2df2a63SAmit Arora 					ext4_ext_put_in_cache(inode, ee_block,
3727b05e6ae5STheodore Ts'o 						ee_len, ee_start);
3728a86c6181SAlex Tomas 					goto out;
3729a86c6181SAlex Tomas 				}
3730e861304bSAllison Henderson 				ret = ext4_ext_handle_uninitialized_extents(
3731e861304bSAllison Henderson 					handle, inode, map, path, flags,
3732e861304bSAllison Henderson 					allocated, newblock);
37330031462bSMingming Cao 				return ret;
373456055d3aSAmit Arora 			}
3735e861304bSAllison Henderson 
3736e861304bSAllison Henderson 			/*
3737e861304bSAllison Henderson 			 * Punch out the map length, but only to the
3738e861304bSAllison Henderson 			 * end of the extent
3739e861304bSAllison Henderson 			 */
3740e861304bSAllison Henderson 			punched_out = allocated < map->m_len ?
3741e861304bSAllison Henderson 				allocated : map->m_len;
3742e861304bSAllison Henderson 
3743e861304bSAllison Henderson 			/*
3744e861304bSAllison Henderson 			 * Sense extents need to be converted to
3745e861304bSAllison Henderson 			 * uninitialized, they must fit in an
3746e861304bSAllison Henderson 			 * uninitialized extent
3747e861304bSAllison Henderson 			 */
3748e861304bSAllison Henderson 			if (punched_out > EXT_UNINIT_MAX_LEN)
3749e861304bSAllison Henderson 				punched_out = EXT_UNINIT_MAX_LEN;
3750e861304bSAllison Henderson 
3751e861304bSAllison Henderson 			punch_map.m_lblk = map->m_lblk;
3752e861304bSAllison Henderson 			punch_map.m_pblk = newblock;
3753e861304bSAllison Henderson 			punch_map.m_len = punched_out;
3754e861304bSAllison Henderson 			punch_map.m_flags = 0;
3755e861304bSAllison Henderson 
3756e861304bSAllison Henderson 			/* Check to see if the extent needs to be split */
3757e861304bSAllison Henderson 			if (punch_map.m_len != ee_len ||
3758e861304bSAllison Henderson 				punch_map.m_lblk != ee_block) {
3759e861304bSAllison Henderson 
3760e861304bSAllison Henderson 				ret = ext4_split_extent(handle, inode,
3761e861304bSAllison Henderson 				path, &punch_map, 0,
3762e861304bSAllison Henderson 				EXT4_GET_BLOCKS_PUNCH_OUT_EXT |
3763e861304bSAllison Henderson 				EXT4_GET_BLOCKS_PRE_IO);
3764e861304bSAllison Henderson 
3765e861304bSAllison Henderson 				if (ret < 0) {
3766e861304bSAllison Henderson 					err = ret;
3767e861304bSAllison Henderson 					goto out2;
3768e861304bSAllison Henderson 				}
3769e861304bSAllison Henderson 				/*
3770e861304bSAllison Henderson 				 * find extent for the block at
3771e861304bSAllison Henderson 				 * the start of the hole
3772e861304bSAllison Henderson 				 */
3773e861304bSAllison Henderson 				ext4_ext_drop_refs(path);
3774e861304bSAllison Henderson 				kfree(path);
3775e861304bSAllison Henderson 
3776e861304bSAllison Henderson 				path = ext4_ext_find_extent(inode,
3777e861304bSAllison Henderson 				map->m_lblk, NULL);
3778e861304bSAllison Henderson 				if (IS_ERR(path)) {
3779e861304bSAllison Henderson 					err = PTR_ERR(path);
3780e861304bSAllison Henderson 					path = NULL;
3781e861304bSAllison Henderson 					goto out2;
3782e861304bSAllison Henderson 				}
3783e861304bSAllison Henderson 
3784e861304bSAllison Henderson 				depth = ext_depth(inode);
3785e861304bSAllison Henderson 				ex = path[depth].p_ext;
3786e861304bSAllison Henderson 				ee_len = ext4_ext_get_actual_len(ex);
3787e861304bSAllison Henderson 				ee_block = le32_to_cpu(ex->ee_block);
3788e861304bSAllison Henderson 				ee_start = ext4_ext_pblock(ex);
3789e861304bSAllison Henderson 
3790e861304bSAllison Henderson 			}
3791e861304bSAllison Henderson 
3792e861304bSAllison Henderson 			ext4_ext_mark_uninitialized(ex);
3793e861304bSAllison Henderson 
3794f7d0d379SAllison Henderson 			ext4_ext_invalidate_cache(inode);
3795f7d0d379SAllison Henderson 
3796f7d0d379SAllison Henderson 			err = ext4_ext_rm_leaf(handle, inode, path,
37970aa06000STheodore Ts'o 					       &partial_cluster, map->m_lblk,
37980aa06000STheodore Ts'o 					       map->m_lblk + punched_out);
3799f7d0d379SAllison Henderson 
3800f7d0d379SAllison Henderson 			if (!err && path->p_hdr->eh_entries == 0) {
3801f7d0d379SAllison Henderson 				/*
3802f7d0d379SAllison Henderson 				 * Punch hole freed all of this sub tree,
3803f7d0d379SAllison Henderson 				 * so we need to correct eh_depth
3804f7d0d379SAllison Henderson 				 */
3805f7d0d379SAllison Henderson 				err = ext4_ext_get_access(handle, inode, path);
3806f7d0d379SAllison Henderson 				if (err == 0) {
3807f7d0d379SAllison Henderson 					ext_inode_hdr(inode)->eh_depth = 0;
3808f7d0d379SAllison Henderson 					ext_inode_hdr(inode)->eh_max =
3809f7d0d379SAllison Henderson 					cpu_to_le16(ext4_ext_space_root(
3810f7d0d379SAllison Henderson 						inode, 0));
3811f7d0d379SAllison Henderson 
3812f7d0d379SAllison Henderson 					err = ext4_ext_dirty(
3813f7d0d379SAllison Henderson 						handle, inode, path);
3814f7d0d379SAllison Henderson 				}
3815f7d0d379SAllison Henderson 			}
3816e861304bSAllison Henderson 
3817e861304bSAllison Henderson 			goto out2;
3818e861304bSAllison Henderson 		}
3819a86c6181SAlex Tomas 	}
3820a86c6181SAlex Tomas 
38217b415bf6SAditya Kali 	if ((sbi->s_cluster_ratio > 1) &&
38227b415bf6SAditya Kali 	    ext4_find_delalloc_cluster(inode, map->m_lblk, 0))
38237b415bf6SAditya Kali 		map->m_flags |= EXT4_MAP_FROM_CLUSTER;
38247b415bf6SAditya Kali 
3825a86c6181SAlex Tomas 	/*
3826d0d856e8SRandy Dunlap 	 * requested block isn't allocated yet;
3827a86c6181SAlex Tomas 	 * we couldn't try to create block if create flag is zero
3828a86c6181SAlex Tomas 	 */
3829c2177057STheodore Ts'o 	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
383056055d3aSAmit Arora 		/*
383156055d3aSAmit Arora 		 * put just found gap into cache to speed up
383256055d3aSAmit Arora 		 * subsequent requests
383356055d3aSAmit Arora 		 */
3834e35fd660STheodore Ts'o 		ext4_ext_put_gap_in_cache(inode, path, map->m_lblk);
3835a86c6181SAlex Tomas 		goto out2;
3836a86c6181SAlex Tomas 	}
38374d33b1efSTheodore Ts'o 
3838a86c6181SAlex Tomas 	/*
3839c2ea3fdeSTheodore Ts'o 	 * Okay, we need to do block allocation.
3840a86c6181SAlex Tomas 	 */
38417b415bf6SAditya Kali 	map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;
38424d33b1efSTheodore Ts'o 	newex.ee_block = cpu_to_le32(map->m_lblk);
38434d33b1efSTheodore Ts'o 	cluster_offset = map->m_lblk & (sbi->s_cluster_ratio-1);
38444d33b1efSTheodore Ts'o 
38454d33b1efSTheodore Ts'o 	/*
38464d33b1efSTheodore Ts'o 	 * If we are doing bigalloc, check to see if the extent returned
38474d33b1efSTheodore Ts'o 	 * by ext4_ext_find_extent() implies a cluster we can use.
38484d33b1efSTheodore Ts'o 	 */
38494d33b1efSTheodore Ts'o 	if (cluster_offset && ex &&
3850d8990240SAditya Kali 	    get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {
38514d33b1efSTheodore Ts'o 		ar.len = allocated = map->m_len;
38524d33b1efSTheodore Ts'o 		newblock = map->m_pblk;
38537b415bf6SAditya Kali 		map->m_flags |= EXT4_MAP_FROM_CLUSTER;
38544d33b1efSTheodore Ts'o 		goto got_allocated_blocks;
38554d33b1efSTheodore Ts'o 	}
3856a86c6181SAlex Tomas 
3857c9de560dSAlex Tomas 	/* find neighbour allocated blocks */
3858e35fd660STheodore Ts'o 	ar.lleft = map->m_lblk;
3859c9de560dSAlex Tomas 	err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
3860c9de560dSAlex Tomas 	if (err)
3861c9de560dSAlex Tomas 		goto out2;
3862e35fd660STheodore Ts'o 	ar.lright = map->m_lblk;
38634d33b1efSTheodore Ts'o 	ex2 = NULL;
38644d33b1efSTheodore Ts'o 	err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2);
3865c9de560dSAlex Tomas 	if (err)
3866c9de560dSAlex Tomas 		goto out2;
386725d14f98SAmit Arora 
38684d33b1efSTheodore Ts'o 	/* Check if the extent after searching to the right implies a
38694d33b1efSTheodore Ts'o 	 * cluster we can use. */
38704d33b1efSTheodore Ts'o 	if ((sbi->s_cluster_ratio > 1) && ex2 &&
3871d8990240SAditya Kali 	    get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) {
38724d33b1efSTheodore Ts'o 		ar.len = allocated = map->m_len;
38734d33b1efSTheodore Ts'o 		newblock = map->m_pblk;
38747b415bf6SAditya Kali 		map->m_flags |= EXT4_MAP_FROM_CLUSTER;
38754d33b1efSTheodore Ts'o 		goto got_allocated_blocks;
38764d33b1efSTheodore Ts'o 	}
38774d33b1efSTheodore Ts'o 
3878749269faSAmit Arora 	/*
3879749269faSAmit Arora 	 * See if request is beyond maximum number of blocks we can have in
3880749269faSAmit Arora 	 * a single extent. For an initialized extent this limit is
3881749269faSAmit Arora 	 * EXT_INIT_MAX_LEN and for an uninitialized extent this limit is
3882749269faSAmit Arora 	 * EXT_UNINIT_MAX_LEN.
3883749269faSAmit Arora 	 */
3884e35fd660STheodore Ts'o 	if (map->m_len > EXT_INIT_MAX_LEN &&
3885c2177057STheodore Ts'o 	    !(flags & EXT4_GET_BLOCKS_UNINIT_EXT))
3886e35fd660STheodore Ts'o 		map->m_len = EXT_INIT_MAX_LEN;
3887e35fd660STheodore Ts'o 	else if (map->m_len > EXT_UNINIT_MAX_LEN &&
3888c2177057STheodore Ts'o 		 (flags & EXT4_GET_BLOCKS_UNINIT_EXT))
3889e35fd660STheodore Ts'o 		map->m_len = EXT_UNINIT_MAX_LEN;
3890749269faSAmit Arora 
3891e35fd660STheodore Ts'o 	/* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */
3892e35fd660STheodore Ts'o 	newex.ee_len = cpu_to_le16(map->m_len);
38934d33b1efSTheodore Ts'o 	err = ext4_ext_check_overlap(sbi, inode, &newex, path);
389425d14f98SAmit Arora 	if (err)
3895b939e376SAneesh Kumar K.V 		allocated = ext4_ext_get_actual_len(&newex);
389625d14f98SAmit Arora 	else
3897e35fd660STheodore Ts'o 		allocated = map->m_len;
3898c9de560dSAlex Tomas 
3899c9de560dSAlex Tomas 	/* allocate new block */
3900c9de560dSAlex Tomas 	ar.inode = inode;
3901e35fd660STheodore Ts'o 	ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);
3902e35fd660STheodore Ts'o 	ar.logical = map->m_lblk;
39034d33b1efSTheodore Ts'o 	/*
39044d33b1efSTheodore Ts'o 	 * We calculate the offset from the beginning of the cluster
39054d33b1efSTheodore Ts'o 	 * for the logical block number, since when we allocate a
39064d33b1efSTheodore Ts'o 	 * physical cluster, the physical block should start at the
39074d33b1efSTheodore Ts'o 	 * same offset from the beginning of the cluster.  This is
39084d33b1efSTheodore Ts'o 	 * needed so that future calls to get_implied_cluster_alloc()
39094d33b1efSTheodore Ts'o 	 * work correctly.
39104d33b1efSTheodore Ts'o 	 */
39114d33b1efSTheodore Ts'o 	offset = map->m_lblk & (sbi->s_cluster_ratio - 1);
39124d33b1efSTheodore Ts'o 	ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
39134d33b1efSTheodore Ts'o 	ar.goal -= offset;
39144d33b1efSTheodore Ts'o 	ar.logical -= offset;
3915c9de560dSAlex Tomas 	if (S_ISREG(inode->i_mode))
3916c9de560dSAlex Tomas 		ar.flags = EXT4_MB_HINT_DATA;
3917c9de560dSAlex Tomas 	else
3918c9de560dSAlex Tomas 		/* disable in-core preallocation for non-regular files */
3919c9de560dSAlex Tomas 		ar.flags = 0;
3920556b27abSVivek Haldar 	if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE)
3921556b27abSVivek Haldar 		ar.flags |= EXT4_MB_HINT_NOPREALLOC;
3922c9de560dSAlex Tomas 	newblock = ext4_mb_new_blocks(handle, &ar, &err);
3923a86c6181SAlex Tomas 	if (!newblock)
3924a86c6181SAlex Tomas 		goto out2;
392584fe3befSMingming 	ext_debug("allocate new block: goal %llu, found %llu/%u\n",
3926498e5f24STheodore Ts'o 		  ar.goal, newblock, allocated);
39274d33b1efSTheodore Ts'o 	free_on_err = 1;
39287b415bf6SAditya Kali 	allocated_clusters = ar.len;
39294d33b1efSTheodore Ts'o 	ar.len = EXT4_C2B(sbi, ar.len) - offset;
39304d33b1efSTheodore Ts'o 	if (ar.len > allocated)
39314d33b1efSTheodore Ts'o 		ar.len = allocated;
3932a86c6181SAlex Tomas 
39334d33b1efSTheodore Ts'o got_allocated_blocks:
3934a86c6181SAlex Tomas 	/* try to insert new extent into found leaf and return */
39354d33b1efSTheodore Ts'o 	ext4_ext_store_pblock(&newex, newblock + offset);
3936c9de560dSAlex Tomas 	newex.ee_len = cpu_to_le16(ar.len);
39378d5d02e6SMingming Cao 	/* Mark uninitialized */
39388d5d02e6SMingming Cao 	if (flags & EXT4_GET_BLOCKS_UNINIT_EXT){
3939a2df2a63SAmit Arora 		ext4_ext_mark_uninitialized(&newex);
39408d5d02e6SMingming Cao 		/*
3941744692dcSJiaying Zhang 		 * io_end structure was created for every IO write to an
394225985edcSLucas De Marchi 		 * uninitialized extent. To avoid unnecessary conversion,
3943744692dcSJiaying Zhang 		 * here we flag the IO that really needs the conversion.
39445f524950SMingming 		 * For non asycn direct IO case, flag the inode state
394525985edcSLucas De Marchi 		 * that we need to perform conversion when IO is done.
39468d5d02e6SMingming Cao 		 */
3947744692dcSJiaying Zhang 		if ((flags & EXT4_GET_BLOCKS_PRE_IO)) {
3948e9e3bcecSEric Sandeen 			if (io && !(io->flag & EXT4_IO_END_UNWRITTEN)) {
3949bd2d0210STheodore Ts'o 				io->flag = EXT4_IO_END_UNWRITTEN;
3950e9e3bcecSEric Sandeen 				atomic_inc(&EXT4_I(inode)->i_aiodio_unwritten);
3951e9e3bcecSEric Sandeen 			} else
395219f5fb7aSTheodore Ts'o 				ext4_set_inode_state(inode,
395319f5fb7aSTheodore Ts'o 						     EXT4_STATE_DIO_UNWRITTEN);
39545f524950SMingming 		}
3955744692dcSJiaying Zhang 		if (ext4_should_dioread_nolock(inode))
3956e35fd660STheodore Ts'o 			map->m_flags |= EXT4_MAP_UNINIT;
39578d5d02e6SMingming Cao 	}
3958c8d46e41SJiaying Zhang 
3959a4e5d88bSDmitry Monakhov 	err = 0;
3960a4e5d88bSDmitry Monakhov 	if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0)
3961a4e5d88bSDmitry Monakhov 		err = check_eofblocks_fl(handle, inode, map->m_lblk,
3962a4e5d88bSDmitry Monakhov 					 path, ar.len);
3963575a1d4bSJiaying Zhang 	if (!err)
3964575a1d4bSJiaying Zhang 		err = ext4_ext_insert_extent(handle, inode, path,
3965575a1d4bSJiaying Zhang 					     &newex, flags);
39664d33b1efSTheodore Ts'o 	if (err && free_on_err) {
39677132de74SMaxim Patlasov 		int fb_flags = flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ?
39687132de74SMaxim Patlasov 			EXT4_FREE_BLOCKS_NO_QUOT_UPDATE : 0;
3969315054f0SAlex Tomas 		/* free data blocks we just allocated */
3970c9de560dSAlex Tomas 		/* not a good idea to call discard here directly,
3971c9de560dSAlex Tomas 		 * but otherwise we'd need to call it every free() */
3972c2ea3fdeSTheodore Ts'o 		ext4_discard_preallocations(inode);
39737dc57615SPeter Huewe 		ext4_free_blocks(handle, inode, NULL, ext4_ext_pblock(&newex),
39747132de74SMaxim Patlasov 				 ext4_ext_get_actual_len(&newex), fb_flags);
3975a86c6181SAlex Tomas 		goto out2;
3976315054f0SAlex Tomas 	}
3977a86c6181SAlex Tomas 
3978a86c6181SAlex Tomas 	/* previous routine could use block we allocated */
3979bf89d16fSTheodore Ts'o 	newblock = ext4_ext_pblock(&newex);
3980b939e376SAneesh Kumar K.V 	allocated = ext4_ext_get_actual_len(&newex);
3981e35fd660STheodore Ts'o 	if (allocated > map->m_len)
3982e35fd660STheodore Ts'o 		allocated = map->m_len;
3983e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_NEW;
3984a86c6181SAlex Tomas 
3985b436b9beSJan Kara 	/*
39865f634d06SAneesh Kumar K.V 	 * Update reserved blocks/metadata blocks after successful
39875f634d06SAneesh Kumar K.V 	 * block allocation which had been deferred till now.
39885f634d06SAneesh Kumar K.V 	 */
39897b415bf6SAditya Kali 	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
39907b415bf6SAditya Kali 		/*
39917b415bf6SAditya Kali 		 * Check how many clusters we had reserved this allocted range.
39927b415bf6SAditya Kali 		 */
39937b415bf6SAditya Kali 		reserved_clusters = get_reserved_cluster_alloc(inode,
39947b415bf6SAditya Kali 						map->m_lblk, allocated);
39957b415bf6SAditya Kali 		if (map->m_flags & EXT4_MAP_FROM_CLUSTER) {
39967b415bf6SAditya Kali 			if (reserved_clusters) {
39977b415bf6SAditya Kali 				/*
39987b415bf6SAditya Kali 				 * We have clusters reserved for this range.
39997b415bf6SAditya Kali 				 * But since we are not doing actual allocation
40007b415bf6SAditya Kali 				 * and are simply using blocks from previously
40017b415bf6SAditya Kali 				 * allocated cluster, we should release the
40027b415bf6SAditya Kali 				 * reservation and not claim quota.
40037b415bf6SAditya Kali 				 */
40047b415bf6SAditya Kali 				ext4_da_update_reserve_space(inode,
40057b415bf6SAditya Kali 						reserved_clusters, 0);
40067b415bf6SAditya Kali 			}
40077b415bf6SAditya Kali 		} else {
40087b415bf6SAditya Kali 			BUG_ON(allocated_clusters < reserved_clusters);
40097b415bf6SAditya Kali 			/* We will claim quota for all newly allocated blocks.*/
40107b415bf6SAditya Kali 			ext4_da_update_reserve_space(inode, allocated_clusters,
40117b415bf6SAditya Kali 							1);
40127b415bf6SAditya Kali 			if (reserved_clusters < allocated_clusters) {
40135356f261SAditya Kali 				struct ext4_inode_info *ei = EXT4_I(inode);
40147b415bf6SAditya Kali 				int reservation = allocated_clusters -
40157b415bf6SAditya Kali 						  reserved_clusters;
40167b415bf6SAditya Kali 				/*
40177b415bf6SAditya Kali 				 * It seems we claimed few clusters outside of
40187b415bf6SAditya Kali 				 * the range of this allocation. We should give
40197b415bf6SAditya Kali 				 * it back to the reservation pool. This can
40207b415bf6SAditya Kali 				 * happen in the following case:
40217b415bf6SAditya Kali 				 *
40227b415bf6SAditya Kali 				 * * Suppose s_cluster_ratio is 4 (i.e., each
40237b415bf6SAditya Kali 				 *   cluster has 4 blocks. Thus, the clusters
40247b415bf6SAditya Kali 				 *   are [0-3],[4-7],[8-11]...
40257b415bf6SAditya Kali 				 * * First comes delayed allocation write for
40267b415bf6SAditya Kali 				 *   logical blocks 10 & 11. Since there were no
40277b415bf6SAditya Kali 				 *   previous delayed allocated blocks in the
40287b415bf6SAditya Kali 				 *   range [8-11], we would reserve 1 cluster
40297b415bf6SAditya Kali 				 *   for this write.
40307b415bf6SAditya Kali 				 * * Next comes write for logical blocks 3 to 8.
40317b415bf6SAditya Kali 				 *   In this case, we will reserve 2 clusters
40327b415bf6SAditya Kali 				 *   (for [0-3] and [4-7]; and not for [8-11] as
40337b415bf6SAditya Kali 				 *   that range has a delayed allocated blocks.
40347b415bf6SAditya Kali 				 *   Thus total reserved clusters now becomes 3.
40357b415bf6SAditya Kali 				 * * Now, during the delayed allocation writeout
40367b415bf6SAditya Kali 				 *   time, we will first write blocks [3-8] and
40377b415bf6SAditya Kali 				 *   allocate 3 clusters for writing these
40387b415bf6SAditya Kali 				 *   blocks. Also, we would claim all these
40397b415bf6SAditya Kali 				 *   three clusters above.
40407b415bf6SAditya Kali 				 * * Now when we come here to writeout the
40417b415bf6SAditya Kali 				 *   blocks [10-11], we would expect to claim
40427b415bf6SAditya Kali 				 *   the reservation of 1 cluster we had made
40437b415bf6SAditya Kali 				 *   (and we would claim it since there are no
40447b415bf6SAditya Kali 				 *   more delayed allocated blocks in the range
40457b415bf6SAditya Kali 				 *   [8-11]. But our reserved cluster count had
40467b415bf6SAditya Kali 				 *   already gone to 0.
40477b415bf6SAditya Kali 				 *
40487b415bf6SAditya Kali 				 *   Thus, at the step 4 above when we determine
40497b415bf6SAditya Kali 				 *   that there are still some unwritten delayed
40507b415bf6SAditya Kali 				 *   allocated blocks outside of our current
40517b415bf6SAditya Kali 				 *   block range, we should increment the
40527b415bf6SAditya Kali 				 *   reserved clusters count so that when the
40537b415bf6SAditya Kali 				 *   remaining blocks finally gets written, we
40547b415bf6SAditya Kali 				 *   could claim them.
40557b415bf6SAditya Kali 				 */
40565356f261SAditya Kali 				dquot_reserve_block(inode,
40575356f261SAditya Kali 						EXT4_C2B(sbi, reservation));
40585356f261SAditya Kali 				spin_lock(&ei->i_block_reservation_lock);
40595356f261SAditya Kali 				ei->i_reserved_data_blocks += reservation;
40605356f261SAditya Kali 				spin_unlock(&ei->i_block_reservation_lock);
40617b415bf6SAditya Kali 			}
40627b415bf6SAditya Kali 		}
40637b415bf6SAditya Kali 	}
40645f634d06SAneesh Kumar K.V 
40655f634d06SAneesh Kumar K.V 	/*
4066b436b9beSJan Kara 	 * Cache the extent and update transaction to commit on fdatasync only
4067b436b9beSJan Kara 	 * when it is _not_ an uninitialized extent.
4068b436b9beSJan Kara 	 */
4069b436b9beSJan Kara 	if ((flags & EXT4_GET_BLOCKS_UNINIT_EXT) == 0) {
4070b05e6ae5STheodore Ts'o 		ext4_ext_put_in_cache(inode, map->m_lblk, allocated, newblock);
4071b436b9beSJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 1);
4072b436b9beSJan Kara 	} else
4073b436b9beSJan Kara 		ext4_update_inode_fsync_trans(handle, inode, 0);
4074a86c6181SAlex Tomas out:
4075e35fd660STheodore Ts'o 	if (allocated > map->m_len)
4076e35fd660STheodore Ts'o 		allocated = map->m_len;
4077a86c6181SAlex Tomas 	ext4_ext_show_leaf(inode, path);
4078e35fd660STheodore Ts'o 	map->m_flags |= EXT4_MAP_MAPPED;
4079e35fd660STheodore Ts'o 	map->m_pblk = newblock;
4080e35fd660STheodore Ts'o 	map->m_len = allocated;
4081a86c6181SAlex Tomas out2:
4082a86c6181SAlex Tomas 	if (path) {
4083a86c6181SAlex Tomas 		ext4_ext_drop_refs(path);
4084a86c6181SAlex Tomas 		kfree(path);
4085a86c6181SAlex Tomas 	}
40860562e0baSJiaying Zhang 	trace_ext4_ext_map_blocks_exit(inode, map->m_lblk,
40870562e0baSJiaying Zhang 		newblock, map->m_len, err ? err : allocated);
4088e861304bSAllison Henderson 
4089e861304bSAllison Henderson 	result = (flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) ?
4090e861304bSAllison Henderson 			punched_out : allocated;
4091e861304bSAllison Henderson 
4092e861304bSAllison Henderson 	return err ? err : result;
4093a86c6181SAlex Tomas }
4094a86c6181SAlex Tomas 
4095cf108bcaSJan Kara void ext4_ext_truncate(struct inode *inode)
4096a86c6181SAlex Tomas {
4097a86c6181SAlex Tomas 	struct address_space *mapping = inode->i_mapping;
4098a86c6181SAlex Tomas 	struct super_block *sb = inode->i_sb;
4099725d26d3SAneesh Kumar K.V 	ext4_lblk_t last_block;
4100a86c6181SAlex Tomas 	handle_t *handle;
4101189e868fSAllison Henderson 	loff_t page_len;
4102a86c6181SAlex Tomas 	int err = 0;
4103a86c6181SAlex Tomas 
4104a86c6181SAlex Tomas 	/*
41053889fd57SJiaying Zhang 	 * finish any pending end_io work so we won't run the risk of
41063889fd57SJiaying Zhang 	 * converting any truncated blocks to initialized later
41073889fd57SJiaying Zhang 	 */
41083889fd57SJiaying Zhang 	ext4_flush_completed_IO(inode);
41093889fd57SJiaying Zhang 
41103889fd57SJiaying Zhang 	/*
4111a86c6181SAlex Tomas 	 * probably first extent we're gonna free will be last in block
4112a86c6181SAlex Tomas 	 */
4113f3bd1f3fSMingming Cao 	err = ext4_writepage_trans_blocks(inode);
4114a86c6181SAlex Tomas 	handle = ext4_journal_start(inode, err);
4115cf108bcaSJan Kara 	if (IS_ERR(handle))
4116a86c6181SAlex Tomas 		return;
4117a86c6181SAlex Tomas 
4118189e868fSAllison Henderson 	if (inode->i_size % PAGE_CACHE_SIZE != 0) {
4119189e868fSAllison Henderson 		page_len = PAGE_CACHE_SIZE -
4120189e868fSAllison Henderson 			(inode->i_size & (PAGE_CACHE_SIZE - 1));
4121189e868fSAllison Henderson 
4122189e868fSAllison Henderson 		err = ext4_discard_partial_page_buffers(handle,
4123189e868fSAllison Henderson 			mapping, inode->i_size, page_len, 0);
4124189e868fSAllison Henderson 
4125189e868fSAllison Henderson 		if (err)
4126189e868fSAllison Henderson 			goto out_stop;
4127189e868fSAllison Henderson 	}
4128a86c6181SAlex Tomas 
41299ddfc3dcSJan Kara 	if (ext4_orphan_add(handle, inode))
41309ddfc3dcSJan Kara 		goto out_stop;
41319ddfc3dcSJan Kara 
41320e855ac8SAneesh Kumar K.V 	down_write(&EXT4_I(inode)->i_data_sem);
4133a86c6181SAlex Tomas 	ext4_ext_invalidate_cache(inode);
4134a86c6181SAlex Tomas 
4135c2ea3fdeSTheodore Ts'o 	ext4_discard_preallocations(inode);
4136c9de560dSAlex Tomas 
4137a86c6181SAlex Tomas 	/*
4138d0d856e8SRandy Dunlap 	 * TODO: optimization is possible here.
4139d0d856e8SRandy Dunlap 	 * Probably we need not scan at all,
4140d0d856e8SRandy Dunlap 	 * because page truncation is enough.
4141a86c6181SAlex Tomas 	 */
4142a86c6181SAlex Tomas 
4143a86c6181SAlex Tomas 	/* we have to know where to truncate from in crash case */
4144a86c6181SAlex Tomas 	EXT4_I(inode)->i_disksize = inode->i_size;
4145a86c6181SAlex Tomas 	ext4_mark_inode_dirty(handle, inode);
4146a86c6181SAlex Tomas 
4147a86c6181SAlex Tomas 	last_block = (inode->i_size + sb->s_blocksize - 1)
4148a86c6181SAlex Tomas 			>> EXT4_BLOCK_SIZE_BITS(sb);
4149c6a0371cSAllison Henderson 	err = ext4_ext_remove_space(inode, last_block);
4150a86c6181SAlex Tomas 
4151a86c6181SAlex Tomas 	/* In a multi-transaction truncate, we only make the final
415256055d3aSAmit Arora 	 * transaction synchronous.
415356055d3aSAmit Arora 	 */
4154a86c6181SAlex Tomas 	if (IS_SYNC(inode))
41550390131bSFrank Mayhar 		ext4_handle_sync(handle);
4156a86c6181SAlex Tomas 
41579ddfc3dcSJan Kara 	up_write(&EXT4_I(inode)->i_data_sem);
4158f6d2f6b3SEric Gouriou 
4159f6d2f6b3SEric Gouriou out_stop:
4160a86c6181SAlex Tomas 	/*
4161d0d856e8SRandy Dunlap 	 * If this was a simple ftruncate() and the file will remain alive,
4162a86c6181SAlex Tomas 	 * then we need to clear up the orphan record which we created above.
4163a86c6181SAlex Tomas 	 * However, if this was a real unlink then we were called by
4164a86c6181SAlex Tomas 	 * ext4_delete_inode(), and we allow that function to clean up the
4165a86c6181SAlex Tomas 	 * orphan info for us.
4166a86c6181SAlex Tomas 	 */
4167a86c6181SAlex Tomas 	if (inode->i_nlink)
4168a86c6181SAlex Tomas 		ext4_orphan_del(handle, inode);
4169a86c6181SAlex Tomas 
4170ef737728SSolofo Ramangalahy 	inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
4171ef737728SSolofo Ramangalahy 	ext4_mark_inode_dirty(handle, inode);
4172a86c6181SAlex Tomas 	ext4_journal_stop(handle);
4173a86c6181SAlex Tomas }
4174a86c6181SAlex Tomas 
4175fd28784aSAneesh Kumar K.V static void ext4_falloc_update_inode(struct inode *inode,
4176fd28784aSAneesh Kumar K.V 				int mode, loff_t new_size, int update_ctime)
4177fd28784aSAneesh Kumar K.V {
4178fd28784aSAneesh Kumar K.V 	struct timespec now;
4179fd28784aSAneesh Kumar K.V 
4180fd28784aSAneesh Kumar K.V 	if (update_ctime) {
4181fd28784aSAneesh Kumar K.V 		now = current_fs_time(inode->i_sb);
4182fd28784aSAneesh Kumar K.V 		if (!timespec_equal(&inode->i_ctime, &now))
4183fd28784aSAneesh Kumar K.V 			inode->i_ctime = now;
4184fd28784aSAneesh Kumar K.V 	}
4185fd28784aSAneesh Kumar K.V 	/*
4186fd28784aSAneesh Kumar K.V 	 * Update only when preallocation was requested beyond
4187fd28784aSAneesh Kumar K.V 	 * the file size.
4188fd28784aSAneesh Kumar K.V 	 */
4189cf17fea6SAneesh Kumar K.V 	if (!(mode & FALLOC_FL_KEEP_SIZE)) {
4190cf17fea6SAneesh Kumar K.V 		if (new_size > i_size_read(inode))
4191fd28784aSAneesh Kumar K.V 			i_size_write(inode, new_size);
4192cf17fea6SAneesh Kumar K.V 		if (new_size > EXT4_I(inode)->i_disksize)
4193cf17fea6SAneesh Kumar K.V 			ext4_update_i_disksize(inode, new_size);
4194c8d46e41SJiaying Zhang 	} else {
4195c8d46e41SJiaying Zhang 		/*
4196c8d46e41SJiaying Zhang 		 * Mark that we allocate beyond EOF so the subsequent truncate
4197c8d46e41SJiaying Zhang 		 * can proceed even if the new size is the same as i_size.
4198c8d46e41SJiaying Zhang 		 */
4199c8d46e41SJiaying Zhang 		if (new_size > i_size_read(inode))
420012e9b892SDmitry Monakhov 			ext4_set_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
4201fd28784aSAneesh Kumar K.V 	}
4202fd28784aSAneesh Kumar K.V 
4203fd28784aSAneesh Kumar K.V }
4204fd28784aSAneesh Kumar K.V 
4205a2df2a63SAmit Arora /*
42062fe17c10SChristoph Hellwig  * preallocate space for a file. This implements ext4's fallocate file
4207a2df2a63SAmit Arora  * operation, which gets called from sys_fallocate system call.
4208a2df2a63SAmit Arora  * For block-mapped files, posix_fallocate should fall back to the method
4209a2df2a63SAmit Arora  * of writing zeroes to the required new blocks (the same behavior which is
4210a2df2a63SAmit Arora  * expected for file systems which do not support fallocate() system call).
4211a2df2a63SAmit Arora  */
42122fe17c10SChristoph Hellwig long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
4213a2df2a63SAmit Arora {
42142fe17c10SChristoph Hellwig 	struct inode *inode = file->f_path.dentry->d_inode;
4215a2df2a63SAmit Arora 	handle_t *handle;
4216fd28784aSAneesh Kumar K.V 	loff_t new_size;
4217498e5f24STheodore Ts'o 	unsigned int max_blocks;
4218a2df2a63SAmit Arora 	int ret = 0;
4219a2df2a63SAmit Arora 	int ret2 = 0;
4220a2df2a63SAmit Arora 	int retries = 0;
4221a4e5d88bSDmitry Monakhov 	int flags;
42222ed88685STheodore Ts'o 	struct ext4_map_blocks map;
4223a2df2a63SAmit Arora 	unsigned int credits, blkbits = inode->i_blkbits;
4224a2df2a63SAmit Arora 
4225a2df2a63SAmit Arora 	/*
4226a2df2a63SAmit Arora 	 * currently supporting (pre)allocate mode for extent-based
4227a2df2a63SAmit Arora 	 * files _only_
4228a2df2a63SAmit Arora 	 */
422912e9b892SDmitry Monakhov 	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
4230a2df2a63SAmit Arora 		return -EOPNOTSUPP;
4231a2df2a63SAmit Arora 
4232a4bb6b64SAllison Henderson 	/* Return error if mode is not supported */
4233a4bb6b64SAllison Henderson 	if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
4234a4bb6b64SAllison Henderson 		return -EOPNOTSUPP;
4235a4bb6b64SAllison Henderson 
4236a4bb6b64SAllison Henderson 	if (mode & FALLOC_FL_PUNCH_HOLE)
4237a4bb6b64SAllison Henderson 		return ext4_punch_hole(file, offset, len);
4238a4bb6b64SAllison Henderson 
42390562e0baSJiaying Zhang 	trace_ext4_fallocate_enter(inode, offset, len, mode);
42402ed88685STheodore Ts'o 	map.m_lblk = offset >> blkbits;
4241fd28784aSAneesh Kumar K.V 	/*
4242fd28784aSAneesh Kumar K.V 	 * We can't just convert len to max_blocks because
4243fd28784aSAneesh Kumar K.V 	 * If blocksize = 4096 offset = 3072 and len = 2048
4244fd28784aSAneesh Kumar K.V 	 */
4245a2df2a63SAmit Arora 	max_blocks = (EXT4_BLOCK_ALIGN(len + offset, blkbits) >> blkbits)
42462ed88685STheodore Ts'o 		- map.m_lblk;
4247a2df2a63SAmit Arora 	/*
4248f3bd1f3fSMingming Cao 	 * credits to insert 1 extent into extent tree
4249a2df2a63SAmit Arora 	 */
4250f3bd1f3fSMingming Cao 	credits = ext4_chunk_trans_blocks(inode, max_blocks);
425155bd725aSAneesh Kumar K.V 	mutex_lock(&inode->i_mutex);
42526d19c42bSNikanth Karthikesan 	ret = inode_newsize_ok(inode, (len + offset));
42536d19c42bSNikanth Karthikesan 	if (ret) {
42546d19c42bSNikanth Karthikesan 		mutex_unlock(&inode->i_mutex);
42550562e0baSJiaying Zhang 		trace_ext4_fallocate_exit(inode, offset, max_blocks, ret);
42566d19c42bSNikanth Karthikesan 		return ret;
42576d19c42bSNikanth Karthikesan 	}
4258a4e5d88bSDmitry Monakhov 	flags = EXT4_GET_BLOCKS_CREATE_UNINIT_EXT |
4259a4e5d88bSDmitry Monakhov 		EXT4_GET_BLOCKS_NO_NORMALIZE;
4260a4e5d88bSDmitry Monakhov 	if (mode & FALLOC_FL_KEEP_SIZE)
4261a4e5d88bSDmitry Monakhov 		flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
4262a2df2a63SAmit Arora retry:
4263a2df2a63SAmit Arora 	while (ret >= 0 && ret < max_blocks) {
42642ed88685STheodore Ts'o 		map.m_lblk = map.m_lblk + ret;
42652ed88685STheodore Ts'o 		map.m_len = max_blocks = max_blocks - ret;
4266a2df2a63SAmit Arora 		handle = ext4_journal_start(inode, credits);
4267a2df2a63SAmit Arora 		if (IS_ERR(handle)) {
4268a2df2a63SAmit Arora 			ret = PTR_ERR(handle);
4269a2df2a63SAmit Arora 			break;
4270a2df2a63SAmit Arora 		}
4271a4e5d88bSDmitry Monakhov 		ret = ext4_map_blocks(handle, inode, &map, flags);
4272221879c9SAneesh Kumar K.V 		if (ret <= 0) {
42732c98615dSAneesh Kumar K.V #ifdef EXT4FS_DEBUG
42742c98615dSAneesh Kumar K.V 			WARN_ON(ret <= 0);
4275e35fd660STheodore Ts'o 			printk(KERN_ERR "%s: ext4_ext_map_blocks "
42762c98615dSAneesh Kumar K.V 				    "returned error inode#%lu, block=%u, "
42779fd9784cSThadeu Lima de Souza Cascardo 				    "max_blocks=%u", __func__,
4278a6371b63SKazuya Mio 				    inode->i_ino, map.m_lblk, max_blocks);
42792c98615dSAneesh Kumar K.V #endif
4280a2df2a63SAmit Arora 			ext4_mark_inode_dirty(handle, inode);
4281a2df2a63SAmit Arora 			ret2 = ext4_journal_stop(handle);
4282a2df2a63SAmit Arora 			break;
4283a2df2a63SAmit Arora 		}
42842ed88685STheodore Ts'o 		if ((map.m_lblk + ret) >= (EXT4_BLOCK_ALIGN(offset + len,
4285fd28784aSAneesh Kumar K.V 						blkbits) >> blkbits))
4286fd28784aSAneesh Kumar K.V 			new_size = offset + len;
4287fd28784aSAneesh Kumar K.V 		else
428829ae07b7SUtako Kusaka 			new_size = ((loff_t) map.m_lblk + ret) << blkbits;
4289a2df2a63SAmit Arora 
4290fd28784aSAneesh Kumar K.V 		ext4_falloc_update_inode(inode, mode, new_size,
42912ed88685STheodore Ts'o 					 (map.m_flags & EXT4_MAP_NEW));
4292a2df2a63SAmit Arora 		ext4_mark_inode_dirty(handle, inode);
4293a2df2a63SAmit Arora 		ret2 = ext4_journal_stop(handle);
4294a2df2a63SAmit Arora 		if (ret2)
4295a2df2a63SAmit Arora 			break;
4296a2df2a63SAmit Arora 	}
4297fd28784aSAneesh Kumar K.V 	if (ret == -ENOSPC &&
4298fd28784aSAneesh Kumar K.V 			ext4_should_retry_alloc(inode->i_sb, &retries)) {
4299fd28784aSAneesh Kumar K.V 		ret = 0;
4300a2df2a63SAmit Arora 		goto retry;
4301a2df2a63SAmit Arora 	}
430255bd725aSAneesh Kumar K.V 	mutex_unlock(&inode->i_mutex);
43030562e0baSJiaying Zhang 	trace_ext4_fallocate_exit(inode, offset, max_blocks,
43040562e0baSJiaying Zhang 				ret > 0 ? ret2 : ret);
4305a2df2a63SAmit Arora 	return ret > 0 ? ret2 : ret;
4306a2df2a63SAmit Arora }
43076873fa0dSEric Sandeen 
43086873fa0dSEric Sandeen /*
43090031462bSMingming Cao  * This function convert a range of blocks to written extents
43100031462bSMingming Cao  * The caller of this function will pass the start offset and the size.
43110031462bSMingming Cao  * all unwritten extents within this range will be converted to
43120031462bSMingming Cao  * written extents.
43130031462bSMingming Cao  *
43140031462bSMingming Cao  * This function is called from the direct IO end io call back
43150031462bSMingming Cao  * function, to convert the fallocated extents after IO is completed.
4316109f5565SMingming  * Returns 0 on success.
43170031462bSMingming Cao  */
43180031462bSMingming Cao int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset,
4319a1de02dcSEric Sandeen 				    ssize_t len)
43200031462bSMingming Cao {
43210031462bSMingming Cao 	handle_t *handle;
43220031462bSMingming Cao 	unsigned int max_blocks;
43230031462bSMingming Cao 	int ret = 0;
43240031462bSMingming Cao 	int ret2 = 0;
43252ed88685STheodore Ts'o 	struct ext4_map_blocks map;
43260031462bSMingming Cao 	unsigned int credits, blkbits = inode->i_blkbits;
43270031462bSMingming Cao 
43282ed88685STheodore Ts'o 	map.m_lblk = offset >> blkbits;
43290031462bSMingming Cao 	/*
43300031462bSMingming Cao 	 * We can't just convert len to max_blocks because
43310031462bSMingming Cao 	 * If blocksize = 4096 offset = 3072 and len = 2048
43320031462bSMingming Cao 	 */
43332ed88685STheodore Ts'o 	max_blocks = ((EXT4_BLOCK_ALIGN(len + offset, blkbits) >> blkbits) -
43342ed88685STheodore Ts'o 		      map.m_lblk);
43350031462bSMingming Cao 	/*
43360031462bSMingming Cao 	 * credits to insert 1 extent into extent tree
43370031462bSMingming Cao 	 */
43380031462bSMingming Cao 	credits = ext4_chunk_trans_blocks(inode, max_blocks);
43390031462bSMingming Cao 	while (ret >= 0 && ret < max_blocks) {
43402ed88685STheodore Ts'o 		map.m_lblk += ret;
43412ed88685STheodore Ts'o 		map.m_len = (max_blocks -= ret);
43420031462bSMingming Cao 		handle = ext4_journal_start(inode, credits);
43430031462bSMingming Cao 		if (IS_ERR(handle)) {
43440031462bSMingming Cao 			ret = PTR_ERR(handle);
43450031462bSMingming Cao 			break;
43460031462bSMingming Cao 		}
43472ed88685STheodore Ts'o 		ret = ext4_map_blocks(handle, inode, &map,
4348c7064ef1SJiaying Zhang 				      EXT4_GET_BLOCKS_IO_CONVERT_EXT);
43490031462bSMingming Cao 		if (ret <= 0) {
43500031462bSMingming Cao 			WARN_ON(ret <= 0);
4351e35fd660STheodore Ts'o 			printk(KERN_ERR "%s: ext4_ext_map_blocks "
43520031462bSMingming Cao 				    "returned error inode#%lu, block=%u, "
43530031462bSMingming Cao 				    "max_blocks=%u", __func__,
43542ed88685STheodore Ts'o 				    inode->i_ino, map.m_lblk, map.m_len);
43550031462bSMingming Cao 		}
43560031462bSMingming Cao 		ext4_mark_inode_dirty(handle, inode);
43570031462bSMingming Cao 		ret2 = ext4_journal_stop(handle);
43580031462bSMingming Cao 		if (ret <= 0 || ret2 )
43590031462bSMingming Cao 			break;
43600031462bSMingming Cao 	}
43610031462bSMingming Cao 	return ret > 0 ? ret2 : ret;
43620031462bSMingming Cao }
43636d9c85ebSYongqiang Yang 
43640031462bSMingming Cao /*
43656873fa0dSEric Sandeen  * Callback function called for each extent to gather FIEMAP information.
43666873fa0dSEric Sandeen  */
4367c03f8aa9SLukas Czerner static int ext4_ext_fiemap_cb(struct inode *inode, ext4_lblk_t next,
43686873fa0dSEric Sandeen 		       struct ext4_ext_cache *newex, struct ext4_extent *ex,
43696873fa0dSEric Sandeen 		       void *data)
43706873fa0dSEric Sandeen {
43716873fa0dSEric Sandeen 	__u64	logical;
43726873fa0dSEric Sandeen 	__u64	physical;
43736873fa0dSEric Sandeen 	__u64	length;
43746873fa0dSEric Sandeen 	__u32	flags = 0;
43756d9c85ebSYongqiang Yang 	int		ret = 0;
43766d9c85ebSYongqiang Yang 	struct fiemap_extent_info *fieinfo = data;
43776d9c85ebSYongqiang Yang 	unsigned char blksize_bits;
43786873fa0dSEric Sandeen 
43796d9c85ebSYongqiang Yang 	blksize_bits = inode->i_sb->s_blocksize_bits;
43806873fa0dSEric Sandeen 	logical = (__u64)newex->ec_block << blksize_bits;
43816873fa0dSEric Sandeen 
4382b05e6ae5STheodore Ts'o 	if (newex->ec_start == 0) {
43836d9c85ebSYongqiang Yang 		/*
43846d9c85ebSYongqiang Yang 		 * No extent in extent-tree contains block @newex->ec_start,
43856d9c85ebSYongqiang Yang 		 * then the block may stay in 1)a hole or 2)delayed-extent.
43866d9c85ebSYongqiang Yang 		 *
43876d9c85ebSYongqiang Yang 		 * Holes or delayed-extents are processed as follows.
43886d9c85ebSYongqiang Yang 		 * 1. lookup dirty pages with specified range in pagecache.
43896d9c85ebSYongqiang Yang 		 *    If no page is got, then there is no delayed-extent and
43906d9c85ebSYongqiang Yang 		 *    return with EXT_CONTINUE.
43916d9c85ebSYongqiang Yang 		 * 2. find the 1st mapped buffer,
43926d9c85ebSYongqiang Yang 		 * 3. check if the mapped buffer is both in the request range
43936d9c85ebSYongqiang Yang 		 *    and a delayed buffer. If not, there is no delayed-extent,
43946d9c85ebSYongqiang Yang 		 *    then return.
43956d9c85ebSYongqiang Yang 		 * 4. a delayed-extent is found, the extent will be collected.
43966d9c85ebSYongqiang Yang 		 */
43976d9c85ebSYongqiang Yang 		ext4_lblk_t	end = 0;
43986d9c85ebSYongqiang Yang 		pgoff_t		last_offset;
43996873fa0dSEric Sandeen 		pgoff_t		offset;
44006d9c85ebSYongqiang Yang 		pgoff_t		index;
4401b221349fSYongqiang Yang 		pgoff_t		start_index = 0;
44026d9c85ebSYongqiang Yang 		struct page	**pages = NULL;
44036873fa0dSEric Sandeen 		struct buffer_head *bh = NULL;
44046d9c85ebSYongqiang Yang 		struct buffer_head *head = NULL;
44056d9c85ebSYongqiang Yang 		unsigned int nr_pages = PAGE_SIZE / sizeof(struct page *);
44066d9c85ebSYongqiang Yang 
44076d9c85ebSYongqiang Yang 		pages = kmalloc(PAGE_SIZE, GFP_KERNEL);
44086d9c85ebSYongqiang Yang 		if (pages == NULL)
44096d9c85ebSYongqiang Yang 			return -ENOMEM;
44106873fa0dSEric Sandeen 
44116873fa0dSEric Sandeen 		offset = logical >> PAGE_SHIFT;
44126d9c85ebSYongqiang Yang repeat:
44136d9c85ebSYongqiang Yang 		last_offset = offset;
44146d9c85ebSYongqiang Yang 		head = NULL;
44156d9c85ebSYongqiang Yang 		ret = find_get_pages_tag(inode->i_mapping, &offset,
44166d9c85ebSYongqiang Yang 					PAGECACHE_TAG_DIRTY, nr_pages, pages);
44176873fa0dSEric Sandeen 
44186d9c85ebSYongqiang Yang 		if (!(flags & FIEMAP_EXTENT_DELALLOC)) {
44196d9c85ebSYongqiang Yang 			/* First time, try to find a mapped buffer. */
44206d9c85ebSYongqiang Yang 			if (ret == 0) {
44216d9c85ebSYongqiang Yang out:
44226d9c85ebSYongqiang Yang 				for (index = 0; index < ret; index++)
44236d9c85ebSYongqiang Yang 					page_cache_release(pages[index]);
44246d9c85ebSYongqiang Yang 				/* just a hole. */
44256d9c85ebSYongqiang Yang 				kfree(pages);
44266873fa0dSEric Sandeen 				return EXT_CONTINUE;
44276873fa0dSEric Sandeen 			}
4428b221349fSYongqiang Yang 			index = 0;
44296d9c85ebSYongqiang Yang 
4430b221349fSYongqiang Yang next_page:
44316d9c85ebSYongqiang Yang 			/* Try to find the 1st mapped buffer. */
4432b221349fSYongqiang Yang 			end = ((__u64)pages[index]->index << PAGE_SHIFT) >>
44336d9c85ebSYongqiang Yang 				  blksize_bits;
4434b221349fSYongqiang Yang 			if (!page_has_buffers(pages[index]))
44356d9c85ebSYongqiang Yang 				goto out;
4436b221349fSYongqiang Yang 			head = page_buffers(pages[index]);
44376d9c85ebSYongqiang Yang 			if (!head)
44386d9c85ebSYongqiang Yang 				goto out;
44396d9c85ebSYongqiang Yang 
4440b221349fSYongqiang Yang 			index++;
44416d9c85ebSYongqiang Yang 			bh = head;
44426d9c85ebSYongqiang Yang 			do {
4443b221349fSYongqiang Yang 				if (end >= newex->ec_block +
44446d9c85ebSYongqiang Yang 					newex->ec_len)
44456d9c85ebSYongqiang Yang 					/* The buffer is out of
44466d9c85ebSYongqiang Yang 					 * the request range.
44476d9c85ebSYongqiang Yang 					 */
44486d9c85ebSYongqiang Yang 					goto out;
4449b221349fSYongqiang Yang 
4450b221349fSYongqiang Yang 				if (buffer_mapped(bh) &&
4451b221349fSYongqiang Yang 				    end >= newex->ec_block) {
4452b221349fSYongqiang Yang 					start_index = index - 1;
4453b221349fSYongqiang Yang 					/* get the 1st mapped buffer. */
44546d9c85ebSYongqiang Yang 					goto found_mapped_buffer;
44556d9c85ebSYongqiang Yang 				}
4456b221349fSYongqiang Yang 
44576d9c85ebSYongqiang Yang 				bh = bh->b_this_page;
44586d9c85ebSYongqiang Yang 				end++;
44596d9c85ebSYongqiang Yang 			} while (bh != head);
44606d9c85ebSYongqiang Yang 
4461b221349fSYongqiang Yang 			/* No mapped buffer in the range found in this page,
4462b221349fSYongqiang Yang 			 * We need to look up next page.
4463b221349fSYongqiang Yang 			 */
4464b221349fSYongqiang Yang 			if (index >= ret) {
4465b221349fSYongqiang Yang 				/* There is no page left, but we need to limit
4466b221349fSYongqiang Yang 				 * newex->ec_len.
4467b221349fSYongqiang Yang 				 */
4468b221349fSYongqiang Yang 				newex->ec_len = end - newex->ec_block;
44696d9c85ebSYongqiang Yang 				goto out;
4470b221349fSYongqiang Yang 			}
4471b221349fSYongqiang Yang 			goto next_page;
44726d9c85ebSYongqiang Yang 		} else {
44736d9c85ebSYongqiang Yang 			/*Find contiguous delayed buffers. */
44746d9c85ebSYongqiang Yang 			if (ret > 0 && pages[0]->index == last_offset)
44756d9c85ebSYongqiang Yang 				head = page_buffers(pages[0]);
44766d9c85ebSYongqiang Yang 			bh = head;
4477b221349fSYongqiang Yang 			index = 1;
4478b221349fSYongqiang Yang 			start_index = 0;
44796d9c85ebSYongqiang Yang 		}
44806d9c85ebSYongqiang Yang 
44816d9c85ebSYongqiang Yang found_mapped_buffer:
44826d9c85ebSYongqiang Yang 		if (bh != NULL && buffer_delay(bh)) {
44836d9c85ebSYongqiang Yang 			/* 1st or contiguous delayed buffer found. */
44846d9c85ebSYongqiang Yang 			if (!(flags & FIEMAP_EXTENT_DELALLOC)) {
44856d9c85ebSYongqiang Yang 				/*
44866d9c85ebSYongqiang Yang 				 * 1st delayed buffer found, record
44876d9c85ebSYongqiang Yang 				 * the start of extent.
44886d9c85ebSYongqiang Yang 				 */
44896d9c85ebSYongqiang Yang 				flags |= FIEMAP_EXTENT_DELALLOC;
44906d9c85ebSYongqiang Yang 				newex->ec_block = end;
44916d9c85ebSYongqiang Yang 				logical = (__u64)end << blksize_bits;
44926d9c85ebSYongqiang Yang 			}
44936d9c85ebSYongqiang Yang 			/* Find contiguous delayed buffers. */
44946d9c85ebSYongqiang Yang 			do {
44956d9c85ebSYongqiang Yang 				if (!buffer_delay(bh))
44966d9c85ebSYongqiang Yang 					goto found_delayed_extent;
44976d9c85ebSYongqiang Yang 				bh = bh->b_this_page;
44986d9c85ebSYongqiang Yang 				end++;
44996d9c85ebSYongqiang Yang 			} while (bh != head);
45006d9c85ebSYongqiang Yang 
4501b221349fSYongqiang Yang 			for (; index < ret; index++) {
45026d9c85ebSYongqiang Yang 				if (!page_has_buffers(pages[index])) {
45036d9c85ebSYongqiang Yang 					bh = NULL;
45046d9c85ebSYongqiang Yang 					break;
45056d9c85ebSYongqiang Yang 				}
45066d9c85ebSYongqiang Yang 				head = page_buffers(pages[index]);
45076d9c85ebSYongqiang Yang 				if (!head) {
45086d9c85ebSYongqiang Yang 					bh = NULL;
45096d9c85ebSYongqiang Yang 					break;
45106d9c85ebSYongqiang Yang 				}
4511b221349fSYongqiang Yang 
45126d9c85ebSYongqiang Yang 				if (pages[index]->index !=
4513b221349fSYongqiang Yang 				    pages[start_index]->index + index
4514b221349fSYongqiang Yang 				    - start_index) {
45156d9c85ebSYongqiang Yang 					/* Blocks are not contiguous. */
45166d9c85ebSYongqiang Yang 					bh = NULL;
45176d9c85ebSYongqiang Yang 					break;
45186d9c85ebSYongqiang Yang 				}
45196d9c85ebSYongqiang Yang 				bh = head;
45206d9c85ebSYongqiang Yang 				do {
45216d9c85ebSYongqiang Yang 					if (!buffer_delay(bh))
45226d9c85ebSYongqiang Yang 						/* Delayed-extent ends. */
45236d9c85ebSYongqiang Yang 						goto found_delayed_extent;
45246d9c85ebSYongqiang Yang 					bh = bh->b_this_page;
45256d9c85ebSYongqiang Yang 					end++;
45266d9c85ebSYongqiang Yang 				} while (bh != head);
45276d9c85ebSYongqiang Yang 			}
45286d9c85ebSYongqiang Yang 		} else if (!(flags & FIEMAP_EXTENT_DELALLOC))
45296d9c85ebSYongqiang Yang 			/* a hole found. */
45306d9c85ebSYongqiang Yang 			goto out;
45316d9c85ebSYongqiang Yang 
45326d9c85ebSYongqiang Yang found_delayed_extent:
45336d9c85ebSYongqiang Yang 		newex->ec_len = min(end - newex->ec_block,
45346d9c85ebSYongqiang Yang 						(ext4_lblk_t)EXT_INIT_MAX_LEN);
45356d9c85ebSYongqiang Yang 		if (ret == nr_pages && bh != NULL &&
45366d9c85ebSYongqiang Yang 			newex->ec_len < EXT_INIT_MAX_LEN &&
45376d9c85ebSYongqiang Yang 			buffer_delay(bh)) {
45386d9c85ebSYongqiang Yang 			/* Have not collected an extent and continue. */
45396d9c85ebSYongqiang Yang 			for (index = 0; index < ret; index++)
45406d9c85ebSYongqiang Yang 				page_cache_release(pages[index]);
45416d9c85ebSYongqiang Yang 			goto repeat;
45426d9c85ebSYongqiang Yang 		}
45436d9c85ebSYongqiang Yang 
45446d9c85ebSYongqiang Yang 		for (index = 0; index < ret; index++)
45456d9c85ebSYongqiang Yang 			page_cache_release(pages[index]);
45466d9c85ebSYongqiang Yang 		kfree(pages);
45476873fa0dSEric Sandeen 	}
45486873fa0dSEric Sandeen 
45496873fa0dSEric Sandeen 	physical = (__u64)newex->ec_start << blksize_bits;
45506873fa0dSEric Sandeen 	length =   (__u64)newex->ec_len << blksize_bits;
45516873fa0dSEric Sandeen 
45526873fa0dSEric Sandeen 	if (ex && ext4_ext_is_uninitialized(ex))
45536873fa0dSEric Sandeen 		flags |= FIEMAP_EXTENT_UNWRITTEN;
45546873fa0dSEric Sandeen 
4555c03f8aa9SLukas Czerner 	if (next == EXT_MAX_BLOCKS)
45566873fa0dSEric Sandeen 		flags |= FIEMAP_EXTENT_LAST;
45576873fa0dSEric Sandeen 
45586d9c85ebSYongqiang Yang 	ret = fiemap_fill_next_extent(fieinfo, logical, physical,
45596873fa0dSEric Sandeen 					length, flags);
45606d9c85ebSYongqiang Yang 	if (ret < 0)
45616d9c85ebSYongqiang Yang 		return ret;
45626d9c85ebSYongqiang Yang 	if (ret == 1)
45636873fa0dSEric Sandeen 		return EXT_BREAK;
45646873fa0dSEric Sandeen 	return EXT_CONTINUE;
45656873fa0dSEric Sandeen }
45666873fa0dSEric Sandeen /* fiemap flags we can handle specified here */
45676873fa0dSEric Sandeen #define EXT4_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
45686873fa0dSEric Sandeen 
45693a06d778SAneesh Kumar K.V static int ext4_xattr_fiemap(struct inode *inode,
45703a06d778SAneesh Kumar K.V 				struct fiemap_extent_info *fieinfo)
45716873fa0dSEric Sandeen {
45726873fa0dSEric Sandeen 	__u64 physical = 0;
45736873fa0dSEric Sandeen 	__u64 length;
45746873fa0dSEric Sandeen 	__u32 flags = FIEMAP_EXTENT_LAST;
45756873fa0dSEric Sandeen 	int blockbits = inode->i_sb->s_blocksize_bits;
45766873fa0dSEric Sandeen 	int error = 0;
45776873fa0dSEric Sandeen 
45786873fa0dSEric Sandeen 	/* in-inode? */
457919f5fb7aSTheodore Ts'o 	if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
45806873fa0dSEric Sandeen 		struct ext4_iloc iloc;
45816873fa0dSEric Sandeen 		int offset;	/* offset of xattr in inode */
45826873fa0dSEric Sandeen 
45836873fa0dSEric Sandeen 		error = ext4_get_inode_loc(inode, &iloc);
45846873fa0dSEric Sandeen 		if (error)
45856873fa0dSEric Sandeen 			return error;
45866873fa0dSEric Sandeen 		physical = iloc.bh->b_blocknr << blockbits;
45876873fa0dSEric Sandeen 		offset = EXT4_GOOD_OLD_INODE_SIZE +
45886873fa0dSEric Sandeen 				EXT4_I(inode)->i_extra_isize;
45896873fa0dSEric Sandeen 		physical += offset;
45906873fa0dSEric Sandeen 		length = EXT4_SB(inode->i_sb)->s_inode_size - offset;
45916873fa0dSEric Sandeen 		flags |= FIEMAP_EXTENT_DATA_INLINE;
4592fd2dd9fbSCurt Wohlgemuth 		brelse(iloc.bh);
45936873fa0dSEric Sandeen 	} else { /* external block */
45946873fa0dSEric Sandeen 		physical = EXT4_I(inode)->i_file_acl << blockbits;
45956873fa0dSEric Sandeen 		length = inode->i_sb->s_blocksize;
45966873fa0dSEric Sandeen 	}
45976873fa0dSEric Sandeen 
45986873fa0dSEric Sandeen 	if (physical)
45996873fa0dSEric Sandeen 		error = fiemap_fill_next_extent(fieinfo, 0, physical,
46006873fa0dSEric Sandeen 						length, flags);
46016873fa0dSEric Sandeen 	return (error < 0 ? error : 0);
46026873fa0dSEric Sandeen }
46036873fa0dSEric Sandeen 
4604a4bb6b64SAllison Henderson /*
4605a4bb6b64SAllison Henderson  * ext4_ext_punch_hole
4606a4bb6b64SAllison Henderson  *
4607a4bb6b64SAllison Henderson  * Punches a hole of "length" bytes in a file starting
4608a4bb6b64SAllison Henderson  * at byte "offset"
4609a4bb6b64SAllison Henderson  *
4610a4bb6b64SAllison Henderson  * @inode:  The inode of the file to punch a hole in
4611a4bb6b64SAllison Henderson  * @offset: The starting byte offset of the hole
4612a4bb6b64SAllison Henderson  * @length: The length of the hole
4613a4bb6b64SAllison Henderson  *
4614a4bb6b64SAllison Henderson  * Returns the number of blocks removed or negative on err
4615a4bb6b64SAllison Henderson  */
4616a4bb6b64SAllison Henderson int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length)
4617a4bb6b64SAllison Henderson {
4618a4bb6b64SAllison Henderson 	struct inode *inode = file->f_path.dentry->d_inode;
4619a4bb6b64SAllison Henderson 	struct super_block *sb = inode->i_sb;
4620a4bb6b64SAllison Henderson 	struct ext4_ext_cache cache_ex;
4621a4bb6b64SAllison Henderson 	ext4_lblk_t first_block, last_block, num_blocks, iblock, max_blocks;
4622a4bb6b64SAllison Henderson 	struct address_space *mapping = inode->i_mapping;
4623a4bb6b64SAllison Henderson 	struct ext4_map_blocks map;
4624a4bb6b64SAllison Henderson 	handle_t *handle;
4625ba06208aSAllison Henderson 	loff_t first_page, last_page, page_len;
4626ba06208aSAllison Henderson 	loff_t first_page_offset, last_page_offset;
4627a4bb6b64SAllison Henderson 	int ret, credits, blocks_released, err = 0;
4628a4bb6b64SAllison Henderson 
46292be4751bSAllison Henderson 	/* No need to punch hole beyond i_size */
46302be4751bSAllison Henderson 	if (offset >= inode->i_size)
46312be4751bSAllison Henderson 		return 0;
46322be4751bSAllison Henderson 
46332be4751bSAllison Henderson 	/*
46342be4751bSAllison Henderson 	 * If the hole extends beyond i_size, set the hole
46352be4751bSAllison Henderson 	 * to end after the page that contains i_size
46362be4751bSAllison Henderson 	 */
46372be4751bSAllison Henderson 	if (offset + length > inode->i_size) {
46382be4751bSAllison Henderson 		length = inode->i_size +
46392be4751bSAllison Henderson 		   PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) -
46402be4751bSAllison Henderson 		   offset;
46412be4751bSAllison Henderson 	}
46422be4751bSAllison Henderson 
4643a4bb6b64SAllison Henderson 	first_block = (offset + sb->s_blocksize - 1) >>
4644a4bb6b64SAllison Henderson 		EXT4_BLOCK_SIZE_BITS(sb);
4645a4bb6b64SAllison Henderson 	last_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb);
4646a4bb6b64SAllison Henderson 
4647a4bb6b64SAllison Henderson 	first_page = (offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
4648a4bb6b64SAllison Henderson 	last_page = (offset + length) >> PAGE_CACHE_SHIFT;
4649a4bb6b64SAllison Henderson 
4650a4bb6b64SAllison Henderson 	first_page_offset = first_page << PAGE_CACHE_SHIFT;
4651a4bb6b64SAllison Henderson 	last_page_offset = last_page << PAGE_CACHE_SHIFT;
4652a4bb6b64SAllison Henderson 
4653a4bb6b64SAllison Henderson 	/*
4654a4bb6b64SAllison Henderson 	 * Write out all dirty pages to avoid race conditions
4655a4bb6b64SAllison Henderson 	 * Then release them.
4656a4bb6b64SAllison Henderson 	 */
4657a4bb6b64SAllison Henderson 	if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
4658a4bb6b64SAllison Henderson 		err = filemap_write_and_wait_range(mapping,
46592be4751bSAllison Henderson 			offset, offset + length - 1);
4660a4bb6b64SAllison Henderson 
4661a4bb6b64SAllison Henderson 		if (err)
4662a4bb6b64SAllison Henderson 			return err;
4663a4bb6b64SAllison Henderson 	}
4664a4bb6b64SAllison Henderson 
4665a4bb6b64SAllison Henderson 	/* Now release the pages */
4666a4bb6b64SAllison Henderson 	if (last_page_offset > first_page_offset) {
4667a4bb6b64SAllison Henderson 		truncate_inode_pages_range(mapping, first_page_offset,
4668a4bb6b64SAllison Henderson 					   last_page_offset-1);
4669a4bb6b64SAllison Henderson 	}
4670a4bb6b64SAllison Henderson 
4671a4bb6b64SAllison Henderson 	/* finish any pending end_io work */
4672a4bb6b64SAllison Henderson 	ext4_flush_completed_IO(inode);
4673a4bb6b64SAllison Henderson 
4674a4bb6b64SAllison Henderson 	credits = ext4_writepage_trans_blocks(inode);
4675a4bb6b64SAllison Henderson 	handle = ext4_journal_start(inode, credits);
4676a4bb6b64SAllison Henderson 	if (IS_ERR(handle))
4677a4bb6b64SAllison Henderson 		return PTR_ERR(handle);
4678a4bb6b64SAllison Henderson 
4679a4bb6b64SAllison Henderson 	err = ext4_orphan_add(handle, inode);
4680a4bb6b64SAllison Henderson 	if (err)
4681a4bb6b64SAllison Henderson 		goto out;
4682a4bb6b64SAllison Henderson 
4683a4bb6b64SAllison Henderson 	/*
4684ba06208aSAllison Henderson 	 * Now we need to zero out the non-page-aligned data in the
4685ba06208aSAllison Henderson 	 * pages at the start and tail of the hole, and unmap the buffer
4686ba06208aSAllison Henderson 	 * heads for the block aligned regions of the page that were
4687ba06208aSAllison Henderson 	 * completely zeroed.
4688a4bb6b64SAllison Henderson 	 */
4689ba06208aSAllison Henderson 	if (first_page > last_page) {
4690ba06208aSAllison Henderson 		/*
4691ba06208aSAllison Henderson 		 * If the file space being truncated is contained within a page
4692ba06208aSAllison Henderson 		 * just zero out and unmap the middle of that page
4693ba06208aSAllison Henderson 		 */
4694ba06208aSAllison Henderson 		err = ext4_discard_partial_page_buffers(handle,
4695ba06208aSAllison Henderson 			mapping, offset, length, 0);
4696a4bb6b64SAllison Henderson 
4697ba06208aSAllison Henderson 		if (err)
4698ba06208aSAllison Henderson 			goto out;
4699ba06208aSAllison Henderson 	} else {
4700ba06208aSAllison Henderson 		/*
4701ba06208aSAllison Henderson 		 * zero out and unmap the partial page that contains
4702ba06208aSAllison Henderson 		 * the start of the hole
4703ba06208aSAllison Henderson 		 */
4704ba06208aSAllison Henderson 		page_len  = first_page_offset - offset;
4705ba06208aSAllison Henderson 		if (page_len > 0) {
4706ba06208aSAllison Henderson 			err = ext4_discard_partial_page_buffers(handle, mapping,
4707ba06208aSAllison Henderson 						   offset, page_len, 0);
4708ba06208aSAllison Henderson 			if (err)
4709ba06208aSAllison Henderson 				goto out;
4710ba06208aSAllison Henderson 		}
4711ba06208aSAllison Henderson 
4712ba06208aSAllison Henderson 		/*
4713ba06208aSAllison Henderson 		 * zero out and unmap the partial page that contains
4714ba06208aSAllison Henderson 		 * the end of the hole
4715ba06208aSAllison Henderson 		 */
4716ba06208aSAllison Henderson 		page_len = offset + length - last_page_offset;
4717ba06208aSAllison Henderson 		if (page_len > 0) {
4718ba06208aSAllison Henderson 			err = ext4_discard_partial_page_buffers(handle, mapping,
4719ba06208aSAllison Henderson 					last_page_offset, page_len, 0);
4720ba06208aSAllison Henderson 			if (err)
4721ba06208aSAllison Henderson 				goto out;
4722a4bb6b64SAllison Henderson 		}
4723a4bb6b64SAllison Henderson 	}
4724a4bb6b64SAllison Henderson 
47252be4751bSAllison Henderson 
47262be4751bSAllison Henderson 	/*
47272be4751bSAllison Henderson 	 * If i_size is contained in the last page, we need to
47282be4751bSAllison Henderson 	 * unmap and zero the partial page after i_size
47292be4751bSAllison Henderson 	 */
47302be4751bSAllison Henderson 	if (inode->i_size >> PAGE_CACHE_SHIFT == last_page &&
47312be4751bSAllison Henderson 	   inode->i_size % PAGE_CACHE_SIZE != 0) {
47322be4751bSAllison Henderson 
47332be4751bSAllison Henderson 		page_len = PAGE_CACHE_SIZE -
47342be4751bSAllison Henderson 			(inode->i_size & (PAGE_CACHE_SIZE - 1));
47352be4751bSAllison Henderson 
47362be4751bSAllison Henderson 		if (page_len > 0) {
47372be4751bSAllison Henderson 			err = ext4_discard_partial_page_buffers(handle,
47382be4751bSAllison Henderson 			  mapping, inode->i_size, page_len, 0);
47392be4751bSAllison Henderson 
47402be4751bSAllison Henderson 			if (err)
47412be4751bSAllison Henderson 				goto out;
47422be4751bSAllison Henderson 		}
47432be4751bSAllison Henderson 	}
47442be4751bSAllison Henderson 
4745a4bb6b64SAllison Henderson 	/* If there are no blocks to remove, return now */
4746a4bb6b64SAllison Henderson 	if (first_block >= last_block)
4747a4bb6b64SAllison Henderson 		goto out;
4748a4bb6b64SAllison Henderson 
4749a4bb6b64SAllison Henderson 	down_write(&EXT4_I(inode)->i_data_sem);
4750a4bb6b64SAllison Henderson 	ext4_ext_invalidate_cache(inode);
4751a4bb6b64SAllison Henderson 	ext4_discard_preallocations(inode);
4752a4bb6b64SAllison Henderson 
4753a4bb6b64SAllison Henderson 	/*
4754a4bb6b64SAllison Henderson 	 * Loop over all the blocks and identify blocks
4755a4bb6b64SAllison Henderson 	 * that need to be punched out
4756a4bb6b64SAllison Henderson 	 */
4757a4bb6b64SAllison Henderson 	iblock = first_block;
4758a4bb6b64SAllison Henderson 	blocks_released = 0;
4759a4bb6b64SAllison Henderson 	while (iblock < last_block) {
4760a4bb6b64SAllison Henderson 		max_blocks = last_block - iblock;
4761a4bb6b64SAllison Henderson 		num_blocks = 1;
4762a4bb6b64SAllison Henderson 		memset(&map, 0, sizeof(map));
4763a4bb6b64SAllison Henderson 		map.m_lblk = iblock;
4764a4bb6b64SAllison Henderson 		map.m_len = max_blocks;
4765a4bb6b64SAllison Henderson 		ret = ext4_ext_map_blocks(handle, inode, &map,
4766a4bb6b64SAllison Henderson 			EXT4_GET_BLOCKS_PUNCH_OUT_EXT);
4767a4bb6b64SAllison Henderson 
4768a4bb6b64SAllison Henderson 		if (ret > 0) {
4769a4bb6b64SAllison Henderson 			blocks_released += ret;
4770a4bb6b64SAllison Henderson 			num_blocks = ret;
4771a4bb6b64SAllison Henderson 		} else if (ret == 0) {
4772a4bb6b64SAllison Henderson 			/*
4773a4bb6b64SAllison Henderson 			 * If map blocks could not find the block,
4774a4bb6b64SAllison Henderson 			 * then it is in a hole.  If the hole was
4775a4bb6b64SAllison Henderson 			 * not already cached, then map blocks should
4776a4bb6b64SAllison Henderson 			 * put it in the cache.  So we can get the hole
4777a4bb6b64SAllison Henderson 			 * out of the cache
4778a4bb6b64SAllison Henderson 			 */
4779a4bb6b64SAllison Henderson 			memset(&cache_ex, 0, sizeof(cache_ex));
4780a4bb6b64SAllison Henderson 			if ((ext4_ext_check_cache(inode, iblock, &cache_ex)) &&
4781a4bb6b64SAllison Henderson 				!cache_ex.ec_start) {
4782a4bb6b64SAllison Henderson 
4783a4bb6b64SAllison Henderson 				/* The hole is cached */
4784a4bb6b64SAllison Henderson 				num_blocks = cache_ex.ec_block +
4785a4bb6b64SAllison Henderson 				cache_ex.ec_len - iblock;
4786a4bb6b64SAllison Henderson 
4787a4bb6b64SAllison Henderson 			} else {
4788a4bb6b64SAllison Henderson 				/* The block could not be identified */
4789a4bb6b64SAllison Henderson 				err = -EIO;
4790a4bb6b64SAllison Henderson 				break;
4791a4bb6b64SAllison Henderson 			}
4792a4bb6b64SAllison Henderson 		} else {
4793a4bb6b64SAllison Henderson 			/* Map blocks error */
4794a4bb6b64SAllison Henderson 			err = ret;
4795a4bb6b64SAllison Henderson 			break;
4796a4bb6b64SAllison Henderson 		}
4797a4bb6b64SAllison Henderson 
4798a4bb6b64SAllison Henderson 		if (num_blocks == 0) {
4799a4bb6b64SAllison Henderson 			/* This condition should never happen */
4800a4bb6b64SAllison Henderson 			ext_debug("Block lookup failed");
4801a4bb6b64SAllison Henderson 			err = -EIO;
4802a4bb6b64SAllison Henderson 			break;
4803a4bb6b64SAllison Henderson 		}
4804a4bb6b64SAllison Henderson 
4805a4bb6b64SAllison Henderson 		iblock += num_blocks;
4806a4bb6b64SAllison Henderson 	}
4807a4bb6b64SAllison Henderson 
4808a4bb6b64SAllison Henderson 	if (blocks_released > 0) {
4809a4bb6b64SAllison Henderson 		ext4_ext_invalidate_cache(inode);
4810a4bb6b64SAllison Henderson 		ext4_discard_preallocations(inode);
4811a4bb6b64SAllison Henderson 	}
4812a4bb6b64SAllison Henderson 
4813a4bb6b64SAllison Henderson 	if (IS_SYNC(inode))
4814a4bb6b64SAllison Henderson 		ext4_handle_sync(handle);
4815a4bb6b64SAllison Henderson 
4816a4bb6b64SAllison Henderson 	up_write(&EXT4_I(inode)->i_data_sem);
4817a4bb6b64SAllison Henderson 
4818a4bb6b64SAllison Henderson out:
4819a4bb6b64SAllison Henderson 	ext4_orphan_del(handle, inode);
4820a4bb6b64SAllison Henderson 	inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
4821a4bb6b64SAllison Henderson 	ext4_mark_inode_dirty(handle, inode);
4822a4bb6b64SAllison Henderson 	ext4_journal_stop(handle);
4823a4bb6b64SAllison Henderson 	return err;
4824a4bb6b64SAllison Henderson }
48256873fa0dSEric Sandeen int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
48266873fa0dSEric Sandeen 		__u64 start, __u64 len)
48276873fa0dSEric Sandeen {
48286873fa0dSEric Sandeen 	ext4_lblk_t start_blk;
48296873fa0dSEric Sandeen 	int error = 0;
48306873fa0dSEric Sandeen 
48316873fa0dSEric Sandeen 	/* fallback to generic here if not in extents fmt */
483212e9b892SDmitry Monakhov 	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
48336873fa0dSEric Sandeen 		return generic_block_fiemap(inode, fieinfo, start, len,
48346873fa0dSEric Sandeen 			ext4_get_block);
48356873fa0dSEric Sandeen 
48366873fa0dSEric Sandeen 	if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS))
48376873fa0dSEric Sandeen 		return -EBADR;
48386873fa0dSEric Sandeen 
48396873fa0dSEric Sandeen 	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
48406873fa0dSEric Sandeen 		error = ext4_xattr_fiemap(inode, fieinfo);
48416873fa0dSEric Sandeen 	} else {
4842aca92ff6SLeonard Michlmayr 		ext4_lblk_t len_blks;
4843aca92ff6SLeonard Michlmayr 		__u64 last_blk;
4844aca92ff6SLeonard Michlmayr 
48456873fa0dSEric Sandeen 		start_blk = start >> inode->i_sb->s_blocksize_bits;
4846aca92ff6SLeonard Michlmayr 		last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
4847f17722f9SLukas Czerner 		if (last_blk >= EXT_MAX_BLOCKS)
4848f17722f9SLukas Czerner 			last_blk = EXT_MAX_BLOCKS-1;
4849aca92ff6SLeonard Michlmayr 		len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;
48506873fa0dSEric Sandeen 
48516873fa0dSEric Sandeen 		/*
48526873fa0dSEric Sandeen 		 * Walk the extent tree gathering extent information.
48536873fa0dSEric Sandeen 		 * ext4_ext_fiemap_cb will push extents back to user.
48546873fa0dSEric Sandeen 		 */
48556873fa0dSEric Sandeen 		error = ext4_ext_walk_space(inode, start_blk, len_blks,
48566873fa0dSEric Sandeen 					  ext4_ext_fiemap_cb, fieinfo);
48576873fa0dSEric Sandeen 	}
48586873fa0dSEric Sandeen 
48596873fa0dSEric Sandeen 	return error;
48606873fa0dSEric Sandeen }
4861