blob: 82027841022009346fbf638d9fe658c79e64adb8 [file] [log] [blame]
Alex Tomasa86c6182006-10-11 01:21:03 -07001/*
2 * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
3 * Written by Alex Tomas <alex@clusterfs.com>
4 *
5 * Architecture independence:
6 * Copyright (c) 2005, Bull S.A.
7 * Written by Pierre Peiffer <pierre.peiffer@bull.net>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public Licens
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
21 */
22
23/*
24 * Extents support for EXT4
25 *
26 * TODO:
27 * - ext4*_error() should be used in some situations
28 * - analyze all BUG()/BUG_ON(), use -EIO where appropriate
29 * - smart tree reduction
30 */
31
32#include <linux/module.h>
33#include <linux/fs.h>
34#include <linux/time.h>
Mingming Caocd02ff02007-10-16 18:38:25 -040035#include <linux/jbd2.h>
Alex Tomasa86c6182006-10-11 01:21:03 -070036#include <linux/highuid.h>
37#include <linux/pagemap.h>
38#include <linux/quotaops.h>
39#include <linux/string.h>
40#include <linux/slab.h>
Amit Aroraa2df2a62007-07-17 21:42:41 -040041#include <linux/falloc.h>
Alex Tomasa86c6182006-10-11 01:21:03 -070042#include <asm/uaccess.h>
Eric Sandeen6873fa02008-10-07 00:46:36 -040043#include <linux/fiemap.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040044#include "ext4_jbd2.h"
45#include "ext4_extents.h"
Alex Tomasa86c6182006-10-11 01:21:03 -070046
47
Randy Dunlapd0d856e2006-10-11 01:21:07 -070048/*
49 * ext_pblock:
50 * combine low and high parts of physical block number into ext4_fsblk_t
51 */
Akira Fujita748de672009-06-17 19:24:03 -040052ext4_fsblk_t ext_pblock(struct ext4_extent *ex)
Alex Tomasf65e6fb2006-10-11 01:21:05 -070053{
54 ext4_fsblk_t block;
55
Aneesh Kumar K.Vb3776112007-10-16 18:38:25 -040056 block = le32_to_cpu(ex->ee_start_lo);
Mingming Cao9b8f1f02006-10-11 01:21:13 -070057 block |= ((ext4_fsblk_t) le16_to_cpu(ex->ee_start_hi) << 31) << 1;
Alex Tomasf65e6fb2006-10-11 01:21:05 -070058 return block;
59}
60
Randy Dunlapd0d856e2006-10-11 01:21:07 -070061/*
62 * idx_pblock:
63 * combine low and high parts of a leaf physical block number into ext4_fsblk_t
64 */
Aneesh Kumar K.Vc14c6fd2008-01-28 23:58:26 -050065ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
Alex Tomasf65e6fb2006-10-11 01:21:05 -070066{
67 ext4_fsblk_t block;
68
Aneesh Kumar K.Vd8dd0b42007-10-16 18:38:25 -040069 block = le32_to_cpu(ix->ei_leaf_lo);
Mingming Cao9b8f1f02006-10-11 01:21:13 -070070 block |= ((ext4_fsblk_t) le16_to_cpu(ix->ei_leaf_hi) << 31) << 1;
Alex Tomasf65e6fb2006-10-11 01:21:05 -070071 return block;
72}
73
Randy Dunlapd0d856e2006-10-11 01:21:07 -070074/*
75 * ext4_ext_store_pblock:
76 * stores a large physical block number into an extent struct,
77 * breaking it into parts
78 */
Aneesh Kumar K.Vc14c6fd2008-01-28 23:58:26 -050079void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
Alex Tomasf65e6fb2006-10-11 01:21:05 -070080{
Aneesh Kumar K.Vb3776112007-10-16 18:38:25 -040081 ex->ee_start_lo = cpu_to_le32((unsigned long) (pb & 0xffffffff));
Mingming Cao9b8f1f02006-10-11 01:21:13 -070082 ex->ee_start_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
Alex Tomasf65e6fb2006-10-11 01:21:05 -070083}
84
Randy Dunlapd0d856e2006-10-11 01:21:07 -070085/*
86 * ext4_idx_store_pblock:
87 * stores a large physical block number into an index struct,
88 * breaking it into parts
89 */
Avantika Mathur09b88252006-12-06 20:41:36 -080090static void ext4_idx_store_pblock(struct ext4_extent_idx *ix, ext4_fsblk_t pb)
Alex Tomasf65e6fb2006-10-11 01:21:05 -070091{
Aneesh Kumar K.Vd8dd0b42007-10-16 18:38:25 -040092 ix->ei_leaf_lo = cpu_to_le32((unsigned long) (pb & 0xffffffff));
Mingming Cao9b8f1f02006-10-11 01:21:13 -070093 ix->ei_leaf_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
Alex Tomasf65e6fb2006-10-11 01:21:05 -070094}
95
Jan Kara487caee2009-08-17 22:17:20 -040096static int ext4_ext_truncate_extend_restart(handle_t *handle,
97 struct inode *inode,
98 int needed)
Alex Tomasa86c6182006-10-11 01:21:03 -070099{
100 int err;
101
Frank Mayhar03901312009-01-07 00:06:22 -0500102 if (!ext4_handle_valid(handle))
103 return 0;
Alex Tomasa86c6182006-10-11 01:21:03 -0700104 if (handle->h_buffer_credits > needed)
Shen Feng9102e4f2008-07-11 19:27:31 -0400105 return 0;
106 err = ext4_journal_extend(handle, needed);
Theodore Ts'o0123c932008-08-01 20:57:54 -0400107 if (err <= 0)
Shen Feng9102e4f2008-07-11 19:27:31 -0400108 return err;
Jan Kara487caee2009-08-17 22:17:20 -0400109 err = ext4_truncate_restart_trans(handle, inode, needed);
Dmitry Monakhov0617b832010-05-17 01:00:00 -0400110 if (err == 0)
111 err = -EAGAIN;
Jan Kara487caee2009-08-17 22:17:20 -0400112
113 return err;
Alex Tomasa86c6182006-10-11 01:21:03 -0700114}
115
116/*
117 * could return:
118 * - EROFS
119 * - ENOMEM
120 */
121static int ext4_ext_get_access(handle_t *handle, struct inode *inode,
122 struct ext4_ext_path *path)
123{
124 if (path->p_bh) {
125 /* path points to block */
126 return ext4_journal_get_write_access(handle, path->p_bh);
127 }
128 /* path points to leaf/index in inode body */
129 /* we use in-core data, no need to protect them */
130 return 0;
131}
132
133/*
134 * could return:
135 * - EROFS
136 * - ENOMEM
137 * - EIO
138 */
139static int ext4_ext_dirty(handle_t *handle, struct inode *inode,
140 struct ext4_ext_path *path)
141{
142 int err;
143 if (path->p_bh) {
144 /* path points to block */
Frank Mayhar03901312009-01-07 00:06:22 -0500145 err = ext4_handle_dirty_metadata(handle, inode, path->p_bh);
Alex Tomasa86c6182006-10-11 01:21:03 -0700146 } else {
147 /* path points to leaf/index in inode body */
148 err = ext4_mark_inode_dirty(handle, inode);
149 }
150 return err;
151}
152
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700153static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
Alex Tomasa86c6182006-10-11 01:21:03 -0700154 struct ext4_ext_path *path,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500155 ext4_lblk_t block)
Alex Tomasa86c6182006-10-11 01:21:03 -0700156{
157 struct ext4_inode_info *ei = EXT4_I(inode);
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700158 ext4_fsblk_t bg_start;
Valerie Clement74d34872008-02-15 13:43:07 -0500159 ext4_fsblk_t last_block;
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700160 ext4_grpblk_t colour;
Theodore Ts'oa4912122009-03-12 12:18:34 -0400161 ext4_group_t block_group;
162 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
Alex Tomasa86c6182006-10-11 01:21:03 -0700163 int depth;
164
165 if (path) {
166 struct ext4_extent *ex;
167 depth = path->p_depth;
168
169 /* try to predict block placement */
Avantika Mathur7e028972006-12-06 20:41:33 -0800170 ex = path[depth].p_ext;
171 if (ex)
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700172 return ext_pblock(ex)+(block-le32_to_cpu(ex->ee_block));
Alex Tomasa86c6182006-10-11 01:21:03 -0700173
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700174 /* it looks like index is empty;
175 * try to find starting block from index itself */
Alex Tomasa86c6182006-10-11 01:21:03 -0700176 if (path[depth].p_bh)
177 return path[depth].p_bh->b_blocknr;
178 }
179
180 /* OK. use inode's group */
Theodore Ts'oa4912122009-03-12 12:18:34 -0400181 block_group = ei->i_block_group;
182 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
183 /*
184 * If there are at least EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME
Theodore Ts'o60e66792010-05-17 07:00:00 -0400185 * block groups per flexgroup, reserve the first block
186 * group for directories and special files. Regular
Theodore Ts'oa4912122009-03-12 12:18:34 -0400187 * files will start at the second block group. This
Theodore Ts'o60e66792010-05-17 07:00:00 -0400188 * tends to speed up directory access and improves
Theodore Ts'oa4912122009-03-12 12:18:34 -0400189 * fsck times.
190 */
191 block_group &= ~(flex_size-1);
192 if (S_ISREG(inode->i_mode))
193 block_group++;
194 }
Akinobu Mita5661bd62010-03-03 23:53:39 -0500195 bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
Valerie Clement74d34872008-02-15 13:43:07 -0500196 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
197
Theodore Ts'oa4912122009-03-12 12:18:34 -0400198 /*
199 * If we are doing delayed allocation, we don't need take
200 * colour into account.
201 */
202 if (test_opt(inode->i_sb, DELALLOC))
203 return bg_start;
204
Valerie Clement74d34872008-02-15 13:43:07 -0500205 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
206 colour = (current->pid % 16) *
Alex Tomasa86c6182006-10-11 01:21:03 -0700207 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
Valerie Clement74d34872008-02-15 13:43:07 -0500208 else
209 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
Alex Tomasa86c6182006-10-11 01:21:03 -0700210 return bg_start + colour + block;
211}
212
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400213/*
214 * Allocation for a meta data block
215 */
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700216static ext4_fsblk_t
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400217ext4_ext_new_meta_block(handle_t *handle, struct inode *inode,
Alex Tomasa86c6182006-10-11 01:21:03 -0700218 struct ext4_ext_path *path,
219 struct ext4_extent *ex, int *err)
220{
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700221 ext4_fsblk_t goal, newblock;
Alex Tomasa86c6182006-10-11 01:21:03 -0700222
223 goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500224 newblock = ext4_new_meta_blocks(handle, inode, goal, NULL, err);
Alex Tomasa86c6182006-10-11 01:21:03 -0700225 return newblock;
226}
227
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400228static inline int ext4_ext_space_block(struct inode *inode, int check)
Alex Tomasa86c6182006-10-11 01:21:03 -0700229{
230 int size;
231
232 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
233 / sizeof(struct ext4_extent);
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400234 if (!check) {
Robert P. J. Daybbf2f9f2007-02-17 19:20:16 +0100235#ifdef AGGRESSIVE_TEST
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400236 if (size > 6)
237 size = 6;
Alex Tomasa86c6182006-10-11 01:21:03 -0700238#endif
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400239 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700240 return size;
241}
242
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400243static inline int ext4_ext_space_block_idx(struct inode *inode, int check)
Alex Tomasa86c6182006-10-11 01:21:03 -0700244{
245 int size;
246
247 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
248 / sizeof(struct ext4_extent_idx);
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400249 if (!check) {
Robert P. J. Daybbf2f9f2007-02-17 19:20:16 +0100250#ifdef AGGRESSIVE_TEST
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400251 if (size > 5)
252 size = 5;
Alex Tomasa86c6182006-10-11 01:21:03 -0700253#endif
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400254 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700255 return size;
256}
257
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400258static inline int ext4_ext_space_root(struct inode *inode, int check)
Alex Tomasa86c6182006-10-11 01:21:03 -0700259{
260 int size;
261
262 size = sizeof(EXT4_I(inode)->i_data);
263 size -= sizeof(struct ext4_extent_header);
264 size /= sizeof(struct ext4_extent);
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400265 if (!check) {
Robert P. J. Daybbf2f9f2007-02-17 19:20:16 +0100266#ifdef AGGRESSIVE_TEST
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400267 if (size > 3)
268 size = 3;
Alex Tomasa86c6182006-10-11 01:21:03 -0700269#endif
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400270 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700271 return size;
272}
273
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400274static inline int ext4_ext_space_root_idx(struct inode *inode, int check)
Alex Tomasa86c6182006-10-11 01:21:03 -0700275{
276 int size;
277
278 size = sizeof(EXT4_I(inode)->i_data);
279 size -= sizeof(struct ext4_extent_header);
280 size /= sizeof(struct ext4_extent_idx);
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400281 if (!check) {
Robert P. J. Daybbf2f9f2007-02-17 19:20:16 +0100282#ifdef AGGRESSIVE_TEST
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400283 if (size > 4)
284 size = 4;
Alex Tomasa86c6182006-10-11 01:21:03 -0700285#endif
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400286 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700287 return size;
288}
289
Mingming Caod2a17632008-07-14 17:52:37 -0400290/*
291 * Calculate the number of metadata blocks needed
292 * to allocate @blocks
293 * Worse case is one block per extent
294 */
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500295int ext4_ext_calc_metadata_amount(struct inode *inode, sector_t lblock)
Mingming Caod2a17632008-07-14 17:52:37 -0400296{
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500297 struct ext4_inode_info *ei = EXT4_I(inode);
298 int idxs, num = 0;
Mingming Caod2a17632008-07-14 17:52:37 -0400299
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500300 idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
301 / sizeof(struct ext4_extent_idx));
Mingming Caod2a17632008-07-14 17:52:37 -0400302
303 /*
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500304 * If the new delayed allocation block is contiguous with the
305 * previous da block, it can share index blocks with the
306 * previous block, so we only need to allocate a new index
307 * block every idxs leaf blocks. At ldxs**2 blocks, we need
308 * an additional index block, and at ldxs**3 blocks, yet
309 * another index blocks.
Mingming Caod2a17632008-07-14 17:52:37 -0400310 */
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500311 if (ei->i_da_metadata_calc_len &&
312 ei->i_da_metadata_calc_last_lblock+1 == lblock) {
313 if ((ei->i_da_metadata_calc_len % idxs) == 0)
314 num++;
315 if ((ei->i_da_metadata_calc_len % (idxs*idxs)) == 0)
316 num++;
317 if ((ei->i_da_metadata_calc_len % (idxs*idxs*idxs)) == 0) {
318 num++;
319 ei->i_da_metadata_calc_len = 0;
320 } else
321 ei->i_da_metadata_calc_len++;
322 ei->i_da_metadata_calc_last_lblock++;
323 return num;
324 }
Mingming Caod2a17632008-07-14 17:52:37 -0400325
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500326 /*
327 * In the worst case we need a new set of index blocks at
328 * every level of the inode's extent tree.
329 */
330 ei->i_da_metadata_calc_len = 1;
331 ei->i_da_metadata_calc_last_lblock = lblock;
332 return ext_depth(inode) + 1;
Mingming Caod2a17632008-07-14 17:52:37 -0400333}
334
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400335static int
336ext4_ext_max_entries(struct inode *inode, int depth)
337{
338 int max;
339
340 if (depth == ext_depth(inode)) {
341 if (depth == 0)
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400342 max = ext4_ext_space_root(inode, 1);
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400343 else
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400344 max = ext4_ext_space_root_idx(inode, 1);
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400345 } else {
346 if (depth == 0)
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400347 max = ext4_ext_space_block(inode, 1);
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400348 else
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400349 max = ext4_ext_space_block_idx(inode, 1);
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400350 }
351
352 return max;
353}
354
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -0400355static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
356{
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400357 ext4_fsblk_t block = ext_pblock(ext);
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -0400358 int len = ext4_ext_get_actual_len(ext);
Theodore Ts'oe84a26c2009-04-22 20:52:25 -0400359
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400360 return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -0400361}
362
363static int ext4_valid_extent_idx(struct inode *inode,
364 struct ext4_extent_idx *ext_idx)
365{
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400366 ext4_fsblk_t block = idx_pblock(ext_idx);
Theodore Ts'oe84a26c2009-04-22 20:52:25 -0400367
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400368 return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -0400369}
370
371static int ext4_valid_extent_entries(struct inode *inode,
372 struct ext4_extent_header *eh,
373 int depth)
374{
375 struct ext4_extent *ext;
376 struct ext4_extent_idx *ext_idx;
377 unsigned short entries;
378 if (eh->eh_entries == 0)
379 return 1;
380
381 entries = le16_to_cpu(eh->eh_entries);
382
383 if (depth == 0) {
384 /* leaf entries */
385 ext = EXT_FIRST_EXTENT(eh);
386 while (entries) {
387 if (!ext4_valid_extent(inode, ext))
388 return 0;
389 ext++;
390 entries--;
391 }
392 } else {
393 ext_idx = EXT_FIRST_INDEX(eh);
394 while (entries) {
395 if (!ext4_valid_extent_idx(inode, ext_idx))
396 return 0;
397 ext_idx++;
398 entries--;
399 }
400 }
401 return 1;
402}
403
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400404static int __ext4_ext_check(const char *function, unsigned int line,
405 struct inode *inode, struct ext4_extent_header *eh,
406 int depth)
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400407{
408 const char *error_msg;
409 int max = 0;
410
411 if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) {
412 error_msg = "invalid magic";
413 goto corrupted;
414 }
415 if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {
416 error_msg = "unexpected eh_depth";
417 goto corrupted;
418 }
419 if (unlikely(eh->eh_max == 0)) {
420 error_msg = "invalid eh_max";
421 goto corrupted;
422 }
423 max = ext4_ext_max_entries(inode, depth);
424 if (unlikely(le16_to_cpu(eh->eh_max) > max)) {
425 error_msg = "too large eh_max";
426 goto corrupted;
427 }
428 if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) {
429 error_msg = "invalid eh_entries";
430 goto corrupted;
431 }
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -0400432 if (!ext4_valid_extent_entries(inode, eh, depth)) {
433 error_msg = "invalid extent entries";
434 goto corrupted;
435 }
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400436 return 0;
437
438corrupted:
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400439 ext4_error_inode(inode, function, line, 0,
Theodore Ts'o24676da2010-05-16 21:00:00 -0400440 "bad header/extent: %s - magic %x, "
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400441 "entries %u, max %u(%u), depth %u(%u)",
Theodore Ts'o24676da2010-05-16 21:00:00 -0400442 error_msg, le16_to_cpu(eh->eh_magic),
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400443 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max),
444 max, le16_to_cpu(eh->eh_depth), depth);
445
446 return -EIO;
447}
448
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -0400449#define ext4_ext_check(inode, eh, depth) \
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400450 __ext4_ext_check(__func__, __LINE__, inode, eh, depth)
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400451
Aneesh Kumar K.V7a262f72009-03-27 16:39:58 -0400452int ext4_ext_check_inode(struct inode *inode)
453{
454 return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode));
455}
456
Alex Tomasa86c6182006-10-11 01:21:03 -0700457#ifdef EXT_DEBUG
458static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
459{
460 int k, l = path->p_depth;
461
462 ext_debug("path:");
463 for (k = 0; k <= l; k++, path++) {
464 if (path->p_idx) {
Mingming Cao2ae02102006-10-11 01:21:11 -0700465 ext_debug(" %d->%llu", le32_to_cpu(path->p_idx->ei_block),
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700466 idx_pblock(path->p_idx));
Alex Tomasa86c6182006-10-11 01:21:03 -0700467 } else if (path->p_ext) {
Mingming553f9002009-09-18 13:34:55 -0400468 ext_debug(" %d:[%d]%d:%llu ",
Alex Tomasa86c6182006-10-11 01:21:03 -0700469 le32_to_cpu(path->p_ext->ee_block),
Mingming553f9002009-09-18 13:34:55 -0400470 ext4_ext_is_uninitialized(path->p_ext),
Amit Aroraa2df2a62007-07-17 21:42:41 -0400471 ext4_ext_get_actual_len(path->p_ext),
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700472 ext_pblock(path->p_ext));
Alex Tomasa86c6182006-10-11 01:21:03 -0700473 } else
474 ext_debug(" []");
475 }
476 ext_debug("\n");
477}
478
479static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
480{
481 int depth = ext_depth(inode);
482 struct ext4_extent_header *eh;
483 struct ext4_extent *ex;
484 int i;
485
486 if (!path)
487 return;
488
489 eh = path[depth].p_hdr;
490 ex = EXT_FIRST_EXTENT(eh);
491
Mingming553f9002009-09-18 13:34:55 -0400492 ext_debug("Displaying leaf extents for inode %lu\n", inode->i_ino);
493
Alex Tomasa86c6182006-10-11 01:21:03 -0700494 for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) {
Mingming553f9002009-09-18 13:34:55 -0400495 ext_debug("%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),
496 ext4_ext_is_uninitialized(ex),
Amit Aroraa2df2a62007-07-17 21:42:41 -0400497 ext4_ext_get_actual_len(ex), ext_pblock(ex));
Alex Tomasa86c6182006-10-11 01:21:03 -0700498 }
499 ext_debug("\n");
500}
501#else
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400502#define ext4_ext_show_path(inode, path)
503#define ext4_ext_show_leaf(inode, path)
Alex Tomasa86c6182006-10-11 01:21:03 -0700504#endif
505
Aneesh Kumar K.Vb35905c2008-02-25 16:54:37 -0500506void ext4_ext_drop_refs(struct ext4_ext_path *path)
Alex Tomasa86c6182006-10-11 01:21:03 -0700507{
508 int depth = path->p_depth;
509 int i;
510
511 for (i = 0; i <= depth; i++, path++)
512 if (path->p_bh) {
513 brelse(path->p_bh);
514 path->p_bh = NULL;
515 }
516}
517
518/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700519 * ext4_ext_binsearch_idx:
520 * binary search for the closest index of the given block
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400521 * the header must be checked before calling this
Alex Tomasa86c6182006-10-11 01:21:03 -0700522 */
523static void
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500524ext4_ext_binsearch_idx(struct inode *inode,
525 struct ext4_ext_path *path, ext4_lblk_t block)
Alex Tomasa86c6182006-10-11 01:21:03 -0700526{
527 struct ext4_extent_header *eh = path->p_hdr;
528 struct ext4_extent_idx *r, *l, *m;
529
Alex Tomasa86c6182006-10-11 01:21:03 -0700530
Eric Sandeenbba90742008-01-28 23:58:27 -0500531 ext_debug("binsearch for %u(idx): ", block);
Alex Tomasa86c6182006-10-11 01:21:03 -0700532
533 l = EXT_FIRST_INDEX(eh) + 1;
Dmitry Monakhove9f410b2007-07-18 09:09:15 -0400534 r = EXT_LAST_INDEX(eh);
Alex Tomasa86c6182006-10-11 01:21:03 -0700535 while (l <= r) {
536 m = l + (r - l) / 2;
537 if (block < le32_to_cpu(m->ei_block))
538 r = m - 1;
539 else
540 l = m + 1;
Dmitry Monakhov26d535e2007-07-18 08:33:37 -0400541 ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ei_block),
542 m, le32_to_cpu(m->ei_block),
543 r, le32_to_cpu(r->ei_block));
Alex Tomasa86c6182006-10-11 01:21:03 -0700544 }
545
546 path->p_idx = l - 1;
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700547 ext_debug(" -> %d->%lld ", le32_to_cpu(path->p_idx->ei_block),
Dmitry Monakhov26d535e2007-07-18 08:33:37 -0400548 idx_pblock(path->p_idx));
Alex Tomasa86c6182006-10-11 01:21:03 -0700549
550#ifdef CHECK_BINSEARCH
551 {
552 struct ext4_extent_idx *chix, *ix;
553 int k;
554
555 chix = ix = EXT_FIRST_INDEX(eh);
556 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {
557 if (k != 0 &&
558 le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) {
Theodore Ts'o4776004f2008-09-08 23:00:52 -0400559 printk(KERN_DEBUG "k=%d, ix=0x%p, "
560 "first=0x%p\n", k,
561 ix, EXT_FIRST_INDEX(eh));
562 printk(KERN_DEBUG "%u <= %u\n",
Alex Tomasa86c6182006-10-11 01:21:03 -0700563 le32_to_cpu(ix->ei_block),
564 le32_to_cpu(ix[-1].ei_block));
565 }
566 BUG_ON(k && le32_to_cpu(ix->ei_block)
Dave Kleikamp8c55e202007-05-24 13:04:54 -0400567 <= le32_to_cpu(ix[-1].ei_block));
Alex Tomasa86c6182006-10-11 01:21:03 -0700568 if (block < le32_to_cpu(ix->ei_block))
569 break;
570 chix = ix;
571 }
572 BUG_ON(chix != path->p_idx);
573 }
574#endif
575
576}
577
578/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700579 * ext4_ext_binsearch:
580 * binary search for closest extent of the given block
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400581 * the header must be checked before calling this
Alex Tomasa86c6182006-10-11 01:21:03 -0700582 */
583static void
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500584ext4_ext_binsearch(struct inode *inode,
585 struct ext4_ext_path *path, ext4_lblk_t block)
Alex Tomasa86c6182006-10-11 01:21:03 -0700586{
587 struct ext4_extent_header *eh = path->p_hdr;
588 struct ext4_extent *r, *l, *m;
589
Alex Tomasa86c6182006-10-11 01:21:03 -0700590 if (eh->eh_entries == 0) {
591 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700592 * this leaf is empty:
593 * we get such a leaf in split/add case
Alex Tomasa86c6182006-10-11 01:21:03 -0700594 */
595 return;
596 }
597
Eric Sandeenbba90742008-01-28 23:58:27 -0500598 ext_debug("binsearch for %u: ", block);
Alex Tomasa86c6182006-10-11 01:21:03 -0700599
600 l = EXT_FIRST_EXTENT(eh) + 1;
Dmitry Monakhove9f410b2007-07-18 09:09:15 -0400601 r = EXT_LAST_EXTENT(eh);
Alex Tomasa86c6182006-10-11 01:21:03 -0700602
603 while (l <= r) {
604 m = l + (r - l) / 2;
605 if (block < le32_to_cpu(m->ee_block))
606 r = m - 1;
607 else
608 l = m + 1;
Dmitry Monakhov26d535e2007-07-18 08:33:37 -0400609 ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ee_block),
610 m, le32_to_cpu(m->ee_block),
611 r, le32_to_cpu(r->ee_block));
Alex Tomasa86c6182006-10-11 01:21:03 -0700612 }
613
614 path->p_ext = l - 1;
Mingming553f9002009-09-18 13:34:55 -0400615 ext_debug(" -> %d:%llu:[%d]%d ",
Dave Kleikamp8c55e202007-05-24 13:04:54 -0400616 le32_to_cpu(path->p_ext->ee_block),
617 ext_pblock(path->p_ext),
Mingming553f9002009-09-18 13:34:55 -0400618 ext4_ext_is_uninitialized(path->p_ext),
Amit Aroraa2df2a62007-07-17 21:42:41 -0400619 ext4_ext_get_actual_len(path->p_ext));
Alex Tomasa86c6182006-10-11 01:21:03 -0700620
621#ifdef CHECK_BINSEARCH
622 {
623 struct ext4_extent *chex, *ex;
624 int k;
625
626 chex = ex = EXT_FIRST_EXTENT(eh);
627 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) {
628 BUG_ON(k && le32_to_cpu(ex->ee_block)
Dave Kleikamp8c55e202007-05-24 13:04:54 -0400629 <= le32_to_cpu(ex[-1].ee_block));
Alex Tomasa86c6182006-10-11 01:21:03 -0700630 if (block < le32_to_cpu(ex->ee_block))
631 break;
632 chex = ex;
633 }
634 BUG_ON(chex != path->p_ext);
635 }
636#endif
637
638}
639
640int ext4_ext_tree_init(handle_t *handle, struct inode *inode)
641{
642 struct ext4_extent_header *eh;
643
644 eh = ext_inode_hdr(inode);
645 eh->eh_depth = 0;
646 eh->eh_entries = 0;
647 eh->eh_magic = EXT4_EXT_MAGIC;
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400648 eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -0700649 ext4_mark_inode_dirty(handle, inode);
650 ext4_ext_invalidate_cache(inode);
651 return 0;
652}
653
654struct ext4_ext_path *
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500655ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
656 struct ext4_ext_path *path)
Alex Tomasa86c6182006-10-11 01:21:03 -0700657{
658 struct ext4_extent_header *eh;
659 struct buffer_head *bh;
660 short int depth, i, ppos = 0, alloc = 0;
661
662 eh = ext_inode_hdr(inode);
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400663 depth = ext_depth(inode);
Alex Tomasa86c6182006-10-11 01:21:03 -0700664
665 /* account possible depth increase */
666 if (!path) {
Avantika Mathur5d4958f2006-12-06 20:41:35 -0800667 path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 2),
Alex Tomasa86c6182006-10-11 01:21:03 -0700668 GFP_NOFS);
669 if (!path)
670 return ERR_PTR(-ENOMEM);
671 alloc = 1;
672 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700673 path[0].p_hdr = eh;
Shen Feng1973adc2008-07-11 19:27:31 -0400674 path[0].p_bh = NULL;
Alex Tomasa86c6182006-10-11 01:21:03 -0700675
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400676 i = depth;
Alex Tomasa86c6182006-10-11 01:21:03 -0700677 /* walk through the tree */
678 while (i) {
Aneesh Kumar K.V7a262f72009-03-27 16:39:58 -0400679 int need_to_validate = 0;
680
Alex Tomasa86c6182006-10-11 01:21:03 -0700681 ext_debug("depth %d: num %d, max %d\n",
682 ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
Alex Tomasc29c0ae2007-07-18 09:19:09 -0400683
Alex Tomasa86c6182006-10-11 01:21:03 -0700684 ext4_ext_binsearch_idx(inode, path + ppos, block);
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700685 path[ppos].p_block = idx_pblock(path[ppos].p_idx);
Alex Tomasa86c6182006-10-11 01:21:03 -0700686 path[ppos].p_depth = i;
687 path[ppos].p_ext = NULL;
688
Aneesh Kumar K.V7a262f72009-03-27 16:39:58 -0400689 bh = sb_getblk(inode->i_sb, path[ppos].p_block);
690 if (unlikely(!bh))
Alex Tomasa86c6182006-10-11 01:21:03 -0700691 goto err;
Aneesh Kumar K.V7a262f72009-03-27 16:39:58 -0400692 if (!bh_uptodate_or_lock(bh)) {
693 if (bh_submit_read(bh) < 0) {
694 put_bh(bh);
695 goto err;
696 }
697 /* validate the extent entries */
698 need_to_validate = 1;
699 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700700 eh = ext_block_hdr(bh);
701 ppos++;
Frank Mayhar273df552010-03-02 11:46:09 -0500702 if (unlikely(ppos > depth)) {
703 put_bh(bh);
704 EXT4_ERROR_INODE(inode,
705 "ppos %d > depth %d", ppos, depth);
706 goto err;
707 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700708 path[ppos].p_bh = bh;
709 path[ppos].p_hdr = eh;
710 i--;
711
Aneesh Kumar K.V7a262f72009-03-27 16:39:58 -0400712 if (need_to_validate && ext4_ext_check(inode, eh, i))
Alex Tomasa86c6182006-10-11 01:21:03 -0700713 goto err;
714 }
715
716 path[ppos].p_depth = i;
Alex Tomasa86c6182006-10-11 01:21:03 -0700717 path[ppos].p_ext = NULL;
718 path[ppos].p_idx = NULL;
719
Alex Tomasa86c6182006-10-11 01:21:03 -0700720 /* find extent */
721 ext4_ext_binsearch(inode, path + ppos, block);
Shen Feng1973adc2008-07-11 19:27:31 -0400722 /* if not an empty leaf */
723 if (path[ppos].p_ext)
724 path[ppos].p_block = ext_pblock(path[ppos].p_ext);
Alex Tomasa86c6182006-10-11 01:21:03 -0700725
726 ext4_ext_show_path(inode, path);
727
728 return path;
729
730err:
731 ext4_ext_drop_refs(path);
732 if (alloc)
733 kfree(path);
734 return ERR_PTR(-EIO);
735}
736
737/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700738 * ext4_ext_insert_index:
739 * insert new index [@logical;@ptr] into the block at @curp;
740 * check where to insert: before @curp or after @curp
Alex Tomasa86c6182006-10-11 01:21:03 -0700741 */
Mingming Cao00314622009-09-28 15:49:08 -0400742int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
Alex Tomasa86c6182006-10-11 01:21:03 -0700743 struct ext4_ext_path *curp,
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700744 int logical, ext4_fsblk_t ptr)
Alex Tomasa86c6182006-10-11 01:21:03 -0700745{
746 struct ext4_extent_idx *ix;
747 int len, err;
748
Avantika Mathur7e028972006-12-06 20:41:33 -0800749 err = ext4_ext_get_access(handle, inode, curp);
750 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -0700751 return err;
752
Frank Mayhar273df552010-03-02 11:46:09 -0500753 if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) {
754 EXT4_ERROR_INODE(inode,
755 "logical %d == ei_block %d!",
756 logical, le32_to_cpu(curp->p_idx->ei_block));
757 return -EIO;
758 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700759 len = EXT_MAX_INDEX(curp->p_hdr) - curp->p_idx;
760 if (logical > le32_to_cpu(curp->p_idx->ei_block)) {
761 /* insert after */
762 if (curp->p_idx != EXT_LAST_INDEX(curp->p_hdr)) {
763 len = (len - 1) * sizeof(struct ext4_extent_idx);
764 len = len < 0 ? 0 : len;
Dmitry Monakhov26d535e2007-07-18 08:33:37 -0400765 ext_debug("insert new index %d after: %llu. "
Alex Tomasa86c6182006-10-11 01:21:03 -0700766 "move %d from 0x%p to 0x%p\n",
767 logical, ptr, len,
768 (curp->p_idx + 1), (curp->p_idx + 2));
769 memmove(curp->p_idx + 2, curp->p_idx + 1, len);
770 }
771 ix = curp->p_idx + 1;
772 } else {
773 /* insert before */
774 len = len * sizeof(struct ext4_extent_idx);
775 len = len < 0 ? 0 : len;
Dmitry Monakhov26d535e2007-07-18 08:33:37 -0400776 ext_debug("insert new index %d before: %llu. "
Alex Tomasa86c6182006-10-11 01:21:03 -0700777 "move %d from 0x%p to 0x%p\n",
778 logical, ptr, len,
779 curp->p_idx, (curp->p_idx + 1));
780 memmove(curp->p_idx + 1, curp->p_idx, len);
781 ix = curp->p_idx;
782 }
783
784 ix->ei_block = cpu_to_le32(logical);
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700785 ext4_idx_store_pblock(ix, ptr);
Marcin Slusarze8546d02008-04-17 10:38:59 -0400786 le16_add_cpu(&curp->p_hdr->eh_entries, 1);
Alex Tomasa86c6182006-10-11 01:21:03 -0700787
Frank Mayhar273df552010-03-02 11:46:09 -0500788 if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries)
789 > le16_to_cpu(curp->p_hdr->eh_max))) {
790 EXT4_ERROR_INODE(inode,
791 "logical %d == ei_block %d!",
792 logical, le32_to_cpu(curp->p_idx->ei_block));
793 return -EIO;
794 }
795 if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) {
796 EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
797 return -EIO;
798 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700799
800 err = ext4_ext_dirty(handle, inode, curp);
801 ext4_std_error(inode->i_sb, err);
802
803 return err;
804}
805
806/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700807 * ext4_ext_split:
808 * inserts new subtree into the path, using free index entry
809 * at depth @at:
810 * - allocates all needed blocks (new leaf and all intermediate index blocks)
811 * - makes decision where to split
812 * - moves remaining extents and index entries (right to the split point)
813 * into the newly allocated blocks
814 * - initializes subtree
Alex Tomasa86c6182006-10-11 01:21:03 -0700815 */
816static int ext4_ext_split(handle_t *handle, struct inode *inode,
817 struct ext4_ext_path *path,
818 struct ext4_extent *newext, int at)
819{
820 struct buffer_head *bh = NULL;
821 int depth = ext_depth(inode);
822 struct ext4_extent_header *neh;
823 struct ext4_extent_idx *fidx;
824 struct ext4_extent *ex;
825 int i = at, k, m, a;
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700826 ext4_fsblk_t newblock, oldblock;
Alex Tomasa86c6182006-10-11 01:21:03 -0700827 __le32 border;
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700828 ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
Alex Tomasa86c6182006-10-11 01:21:03 -0700829 int err = 0;
830
831 /* make decision: where to split? */
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700832 /* FIXME: now decision is simplest: at current extent */
Alex Tomasa86c6182006-10-11 01:21:03 -0700833
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700834 /* if current leaf will be split, then we should use
Alex Tomasa86c6182006-10-11 01:21:03 -0700835 * border from split point */
Frank Mayhar273df552010-03-02 11:46:09 -0500836 if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {
837 EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
838 return -EIO;
839 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700840 if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
841 border = path[depth].p_ext[1].ee_block;
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700842 ext_debug("leaf will be split."
Alex Tomasa86c6182006-10-11 01:21:03 -0700843 " next leaf starts at %d\n",
Dave Kleikamp8c55e202007-05-24 13:04:54 -0400844 le32_to_cpu(border));
Alex Tomasa86c6182006-10-11 01:21:03 -0700845 } else {
846 border = newext->ee_block;
847 ext_debug("leaf will be added."
848 " next leaf starts at %d\n",
Dave Kleikamp8c55e202007-05-24 13:04:54 -0400849 le32_to_cpu(border));
Alex Tomasa86c6182006-10-11 01:21:03 -0700850 }
851
852 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700853 * If error occurs, then we break processing
854 * and mark filesystem read-only. index won't
Alex Tomasa86c6182006-10-11 01:21:03 -0700855 * be inserted and tree will be in consistent
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700856 * state. Next mount will repair buffers too.
Alex Tomasa86c6182006-10-11 01:21:03 -0700857 */
858
859 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700860 * Get array to track all allocated blocks.
861 * We need this to handle errors and free blocks
862 * upon them.
Alex Tomasa86c6182006-10-11 01:21:03 -0700863 */
Avantika Mathur5d4958f2006-12-06 20:41:35 -0800864 ablocks = kzalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS);
Alex Tomasa86c6182006-10-11 01:21:03 -0700865 if (!ablocks)
866 return -ENOMEM;
Alex Tomasa86c6182006-10-11 01:21:03 -0700867
868 /* allocate all needed blocks */
869 ext_debug("allocate %d blocks for indexes/leaf\n", depth - at);
870 for (a = 0; a < depth - at; a++) {
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400871 newblock = ext4_ext_new_meta_block(handle, inode, path,
872 newext, &err);
Alex Tomasa86c6182006-10-11 01:21:03 -0700873 if (newblock == 0)
874 goto cleanup;
875 ablocks[a] = newblock;
876 }
877
878 /* initialize new leaf */
879 newblock = ablocks[--a];
Frank Mayhar273df552010-03-02 11:46:09 -0500880 if (unlikely(newblock == 0)) {
881 EXT4_ERROR_INODE(inode, "newblock == 0!");
882 err = -EIO;
883 goto cleanup;
884 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700885 bh = sb_getblk(inode->i_sb, newblock);
886 if (!bh) {
887 err = -EIO;
888 goto cleanup;
889 }
890 lock_buffer(bh);
891
Avantika Mathur7e028972006-12-06 20:41:33 -0800892 err = ext4_journal_get_create_access(handle, bh);
893 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -0700894 goto cleanup;
895
896 neh = ext_block_hdr(bh);
897 neh->eh_entries = 0;
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400898 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -0700899 neh->eh_magic = EXT4_EXT_MAGIC;
900 neh->eh_depth = 0;
901 ex = EXT_FIRST_EXTENT(neh);
902
Randy Dunlapd0d856e2006-10-11 01:21:07 -0700903 /* move remainder of path[depth] to the new leaf */
Frank Mayhar273df552010-03-02 11:46:09 -0500904 if (unlikely(path[depth].p_hdr->eh_entries !=
905 path[depth].p_hdr->eh_max)) {
906 EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
907 path[depth].p_hdr->eh_entries,
908 path[depth].p_hdr->eh_max);
909 err = -EIO;
910 goto cleanup;
911 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700912 /* start copy from next extent */
913 /* TODO: we could do it by single memmove */
914 m = 0;
915 path[depth].p_ext++;
916 while (path[depth].p_ext <=
917 EXT_MAX_EXTENT(path[depth].p_hdr)) {
Mingming553f9002009-09-18 13:34:55 -0400918 ext_debug("move %d:%llu:[%d]%d in new leaf %llu\n",
Dave Kleikamp8c55e202007-05-24 13:04:54 -0400919 le32_to_cpu(path[depth].p_ext->ee_block),
920 ext_pblock(path[depth].p_ext),
Mingming553f9002009-09-18 13:34:55 -0400921 ext4_ext_is_uninitialized(path[depth].p_ext),
Amit Aroraa2df2a62007-07-17 21:42:41 -0400922 ext4_ext_get_actual_len(path[depth].p_ext),
Alex Tomasa86c6182006-10-11 01:21:03 -0700923 newblock);
924 /*memmove(ex++, path[depth].p_ext++,
925 sizeof(struct ext4_extent));
926 neh->eh_entries++;*/
927 path[depth].p_ext++;
928 m++;
929 }
930 if (m) {
931 memmove(ex, path[depth].p_ext-m, sizeof(struct ext4_extent)*m);
Marcin Slusarze8546d02008-04-17 10:38:59 -0400932 le16_add_cpu(&neh->eh_entries, m);
Alex Tomasa86c6182006-10-11 01:21:03 -0700933 }
934
935 set_buffer_uptodate(bh);
936 unlock_buffer(bh);
937
Frank Mayhar03901312009-01-07 00:06:22 -0500938 err = ext4_handle_dirty_metadata(handle, inode, bh);
Avantika Mathur7e028972006-12-06 20:41:33 -0800939 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -0700940 goto cleanup;
941 brelse(bh);
942 bh = NULL;
943
944 /* correct old leaf */
945 if (m) {
Avantika Mathur7e028972006-12-06 20:41:33 -0800946 err = ext4_ext_get_access(handle, inode, path + depth);
947 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -0700948 goto cleanup;
Marcin Slusarze8546d02008-04-17 10:38:59 -0400949 le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);
Avantika Mathur7e028972006-12-06 20:41:33 -0800950 err = ext4_ext_dirty(handle, inode, path + depth);
951 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -0700952 goto cleanup;
953
954 }
955
956 /* create intermediate indexes */
957 k = depth - at - 1;
Frank Mayhar273df552010-03-02 11:46:09 -0500958 if (unlikely(k < 0)) {
959 EXT4_ERROR_INODE(inode, "k %d < 0!", k);
960 err = -EIO;
961 goto cleanup;
962 }
Alex Tomasa86c6182006-10-11 01:21:03 -0700963 if (k)
964 ext_debug("create %d intermediate indices\n", k);
965 /* insert new index into current index block */
966 /* current depth stored in i var */
967 i = depth - 1;
968 while (k--) {
969 oldblock = newblock;
970 newblock = ablocks[--a];
Eric Sandeenbba90742008-01-28 23:58:27 -0500971 bh = sb_getblk(inode->i_sb, newblock);
Alex Tomasa86c6182006-10-11 01:21:03 -0700972 if (!bh) {
973 err = -EIO;
974 goto cleanup;
975 }
976 lock_buffer(bh);
977
Avantika Mathur7e028972006-12-06 20:41:33 -0800978 err = ext4_journal_get_create_access(handle, bh);
979 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -0700980 goto cleanup;
981
982 neh = ext_block_hdr(bh);
983 neh->eh_entries = cpu_to_le16(1);
984 neh->eh_magic = EXT4_EXT_MAGIC;
Theodore Ts'o55ad63b2009-08-28 10:40:33 -0400985 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -0700986 neh->eh_depth = cpu_to_le16(depth - i);
987 fidx = EXT_FIRST_INDEX(neh);
988 fidx->ei_block = border;
Alex Tomasf65e6fb2006-10-11 01:21:05 -0700989 ext4_idx_store_pblock(fidx, oldblock);
Alex Tomasa86c6182006-10-11 01:21:03 -0700990
Eric Sandeenbba90742008-01-28 23:58:27 -0500991 ext_debug("int.index at %d (block %llu): %u -> %llu\n",
992 i, newblock, le32_to_cpu(border), oldblock);
Alex Tomasa86c6182006-10-11 01:21:03 -0700993 /* copy indexes */
994 m = 0;
995 path[i].p_idx++;
996
997 ext_debug("cur 0x%p, last 0x%p\n", path[i].p_idx,
998 EXT_MAX_INDEX(path[i].p_hdr));
Frank Mayhar273df552010-03-02 11:46:09 -0500999 if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) !=
1000 EXT_LAST_INDEX(path[i].p_hdr))) {
1001 EXT4_ERROR_INODE(inode,
1002 "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!",
1003 le32_to_cpu(path[i].p_ext->ee_block));
1004 err = -EIO;
1005 goto cleanup;
1006 }
Alex Tomasa86c6182006-10-11 01:21:03 -07001007 while (path[i].p_idx <= EXT_MAX_INDEX(path[i].p_hdr)) {
Dmitry Monakhov26d535e2007-07-18 08:33:37 -04001008 ext_debug("%d: move %d:%llu in new index %llu\n", i,
Dave Kleikamp8c55e202007-05-24 13:04:54 -04001009 le32_to_cpu(path[i].p_idx->ei_block),
1010 idx_pblock(path[i].p_idx),
1011 newblock);
Alex Tomasa86c6182006-10-11 01:21:03 -07001012 /*memmove(++fidx, path[i].p_idx++,
1013 sizeof(struct ext4_extent_idx));
1014 neh->eh_entries++;
1015 BUG_ON(neh->eh_entries > neh->eh_max);*/
1016 path[i].p_idx++;
1017 m++;
1018 }
1019 if (m) {
1020 memmove(++fidx, path[i].p_idx - m,
1021 sizeof(struct ext4_extent_idx) * m);
Marcin Slusarze8546d02008-04-17 10:38:59 -04001022 le16_add_cpu(&neh->eh_entries, m);
Alex Tomasa86c6182006-10-11 01:21:03 -07001023 }
1024 set_buffer_uptodate(bh);
1025 unlock_buffer(bh);
1026
Frank Mayhar03901312009-01-07 00:06:22 -05001027 err = ext4_handle_dirty_metadata(handle, inode, bh);
Avantika Mathur7e028972006-12-06 20:41:33 -08001028 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001029 goto cleanup;
1030 brelse(bh);
1031 bh = NULL;
1032
1033 /* correct old index */
1034 if (m) {
1035 err = ext4_ext_get_access(handle, inode, path + i);
1036 if (err)
1037 goto cleanup;
Marcin Slusarze8546d02008-04-17 10:38:59 -04001038 le16_add_cpu(&path[i].p_hdr->eh_entries, -m);
Alex Tomasa86c6182006-10-11 01:21:03 -07001039 err = ext4_ext_dirty(handle, inode, path + i);
1040 if (err)
1041 goto cleanup;
1042 }
1043
1044 i--;
1045 }
1046
1047 /* insert new index */
Alex Tomasa86c6182006-10-11 01:21:03 -07001048 err = ext4_ext_insert_index(handle, inode, path + at,
1049 le32_to_cpu(border), newblock);
1050
1051cleanup:
1052 if (bh) {
1053 if (buffer_locked(bh))
1054 unlock_buffer(bh);
1055 brelse(bh);
1056 }
1057
1058 if (err) {
1059 /* free all allocated blocks in error case */
1060 for (i = 0; i < depth; i++) {
1061 if (!ablocks[i])
1062 continue;
Theodore Ts'oe6362602009-11-23 07:17:05 -05001063 ext4_free_blocks(handle, inode, 0, ablocks[i], 1,
1064 EXT4_FREE_BLOCKS_METADATA);
Alex Tomasa86c6182006-10-11 01:21:03 -07001065 }
1066 }
1067 kfree(ablocks);
1068
1069 return err;
1070}
1071
1072/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001073 * ext4_ext_grow_indepth:
1074 * implements tree growing procedure:
1075 * - allocates new block
1076 * - moves top-level data (index block or leaf) into the new block
1077 * - initializes new top-level, creating index that points to the
1078 * just created block
Alex Tomasa86c6182006-10-11 01:21:03 -07001079 */
1080static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
1081 struct ext4_ext_path *path,
1082 struct ext4_extent *newext)
1083{
1084 struct ext4_ext_path *curp = path;
1085 struct ext4_extent_header *neh;
Alex Tomasa86c6182006-10-11 01:21:03 -07001086 struct buffer_head *bh;
Alex Tomasf65e6fb2006-10-11 01:21:05 -07001087 ext4_fsblk_t newblock;
Alex Tomasa86c6182006-10-11 01:21:03 -07001088 int err = 0;
1089
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -04001090 newblock = ext4_ext_new_meta_block(handle, inode, path, newext, &err);
Alex Tomasa86c6182006-10-11 01:21:03 -07001091 if (newblock == 0)
1092 return err;
1093
1094 bh = sb_getblk(inode->i_sb, newblock);
1095 if (!bh) {
1096 err = -EIO;
1097 ext4_std_error(inode->i_sb, err);
1098 return err;
1099 }
1100 lock_buffer(bh);
1101
Avantika Mathur7e028972006-12-06 20:41:33 -08001102 err = ext4_journal_get_create_access(handle, bh);
1103 if (err) {
Alex Tomasa86c6182006-10-11 01:21:03 -07001104 unlock_buffer(bh);
1105 goto out;
1106 }
1107
1108 /* move top-level index/leaf into new block */
1109 memmove(bh->b_data, curp->p_hdr, sizeof(EXT4_I(inode)->i_data));
1110
1111 /* set size of new block */
1112 neh = ext_block_hdr(bh);
1113 /* old root could have indexes or leaves
1114 * so calculate e_max right way */
1115 if (ext_depth(inode))
Theodore Ts'o55ad63b2009-08-28 10:40:33 -04001116 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -07001117 else
Theodore Ts'o55ad63b2009-08-28 10:40:33 -04001118 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -07001119 neh->eh_magic = EXT4_EXT_MAGIC;
1120 set_buffer_uptodate(bh);
1121 unlock_buffer(bh);
1122
Frank Mayhar03901312009-01-07 00:06:22 -05001123 err = ext4_handle_dirty_metadata(handle, inode, bh);
Avantika Mathur7e028972006-12-06 20:41:33 -08001124 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001125 goto out;
1126
1127 /* create index in new top-level index: num,max,pointer */
Avantika Mathur7e028972006-12-06 20:41:33 -08001128 err = ext4_ext_get_access(handle, inode, curp);
1129 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001130 goto out;
1131
1132 curp->p_hdr->eh_magic = EXT4_EXT_MAGIC;
Theodore Ts'o55ad63b2009-08-28 10:40:33 -04001133 curp->p_hdr->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -07001134 curp->p_hdr->eh_entries = cpu_to_le16(1);
1135 curp->p_idx = EXT_FIRST_INDEX(curp->p_hdr);
Dmitry Monakhove9f410b2007-07-18 09:09:15 -04001136
1137 if (path[0].p_hdr->eh_depth)
1138 curp->p_idx->ei_block =
1139 EXT_FIRST_INDEX(path[0].p_hdr)->ei_block;
1140 else
1141 curp->p_idx->ei_block =
1142 EXT_FIRST_EXTENT(path[0].p_hdr)->ee_block;
Alex Tomasf65e6fb2006-10-11 01:21:05 -07001143 ext4_idx_store_pblock(curp->p_idx, newblock);
Alex Tomasa86c6182006-10-11 01:21:03 -07001144
1145 neh = ext_inode_hdr(inode);
Mingming Cao2ae02102006-10-11 01:21:11 -07001146 ext_debug("new root: num %d(%d), lblock %d, ptr %llu\n",
Alex Tomasa86c6182006-10-11 01:21:03 -07001147 le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),
Andi Kleen5a0790c2010-06-14 13:28:03 -04001148 le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block),
1149 idx_pblock(EXT_FIRST_INDEX(neh)));
Alex Tomasa86c6182006-10-11 01:21:03 -07001150
1151 neh->eh_depth = cpu_to_le16(path->p_depth + 1);
1152 err = ext4_ext_dirty(handle, inode, curp);
1153out:
1154 brelse(bh);
1155
1156 return err;
1157}
1158
1159/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001160 * ext4_ext_create_new_leaf:
1161 * finds empty index and adds new leaf.
1162 * if no free index is found, then it requests in-depth growing.
Alex Tomasa86c6182006-10-11 01:21:03 -07001163 */
1164static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode,
1165 struct ext4_ext_path *path,
1166 struct ext4_extent *newext)
1167{
1168 struct ext4_ext_path *curp;
1169 int depth, i, err = 0;
1170
1171repeat:
1172 i = depth = ext_depth(inode);
1173
1174 /* walk up to the tree and look for free index entry */
1175 curp = path + depth;
1176 while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) {
1177 i--;
1178 curp--;
1179 }
1180
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001181 /* we use already allocated block for index block,
1182 * so subsequent data blocks should be contiguous */
Alex Tomasa86c6182006-10-11 01:21:03 -07001183 if (EXT_HAS_FREE_INDEX(curp)) {
1184 /* if we found index with free entry, then use that
1185 * entry: create all needed subtree and add new leaf */
1186 err = ext4_ext_split(handle, inode, path, newext, i);
Shen Feng787e0982008-07-11 19:27:31 -04001187 if (err)
1188 goto out;
Alex Tomasa86c6182006-10-11 01:21:03 -07001189
1190 /* refill path */
1191 ext4_ext_drop_refs(path);
1192 path = ext4_ext_find_extent(inode,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001193 (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1194 path);
Alex Tomasa86c6182006-10-11 01:21:03 -07001195 if (IS_ERR(path))
1196 err = PTR_ERR(path);
1197 } else {
1198 /* tree is full, time to grow in depth */
1199 err = ext4_ext_grow_indepth(handle, inode, path, newext);
1200 if (err)
1201 goto out;
1202
1203 /* refill path */
1204 ext4_ext_drop_refs(path);
1205 path = ext4_ext_find_extent(inode,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001206 (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1207 path);
Alex Tomasa86c6182006-10-11 01:21:03 -07001208 if (IS_ERR(path)) {
1209 err = PTR_ERR(path);
1210 goto out;
1211 }
1212
1213 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001214 * only first (depth 0 -> 1) produces free space;
1215 * in all other cases we have to split the grown tree
Alex Tomasa86c6182006-10-11 01:21:03 -07001216 */
1217 depth = ext_depth(inode);
1218 if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001219 /* now we need to split */
Alex Tomasa86c6182006-10-11 01:21:03 -07001220 goto repeat;
1221 }
1222 }
1223
1224out:
1225 return err;
1226}
1227
1228/*
Alex Tomas1988b512008-01-28 23:58:27 -05001229 * search the closest allocated block to the left for *logical
1230 * and returns it at @logical + it's physical address at @phys
1231 * if *logical is the smallest allocated block, the function
1232 * returns 0 at @phys
1233 * return value contains 0 (success) or error code
1234 */
1235int
1236ext4_ext_search_left(struct inode *inode, struct ext4_ext_path *path,
1237 ext4_lblk_t *logical, ext4_fsblk_t *phys)
1238{
1239 struct ext4_extent_idx *ix;
1240 struct ext4_extent *ex;
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05001241 int depth, ee_len;
Alex Tomas1988b512008-01-28 23:58:27 -05001242
Frank Mayhar273df552010-03-02 11:46:09 -05001243 if (unlikely(path == NULL)) {
1244 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1245 return -EIO;
1246 }
Alex Tomas1988b512008-01-28 23:58:27 -05001247 depth = path->p_depth;
1248 *phys = 0;
1249
1250 if (depth == 0 && path->p_ext == NULL)
1251 return 0;
1252
1253 /* usually extent in the path covers blocks smaller
1254 * then *logical, but it can be that extent is the
1255 * first one in the file */
1256
1257 ex = path[depth].p_ext;
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05001258 ee_len = ext4_ext_get_actual_len(ex);
Alex Tomas1988b512008-01-28 23:58:27 -05001259 if (*logical < le32_to_cpu(ex->ee_block)) {
Frank Mayhar273df552010-03-02 11:46:09 -05001260 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1261 EXT4_ERROR_INODE(inode,
1262 "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!",
1263 *logical, le32_to_cpu(ex->ee_block));
1264 return -EIO;
1265 }
Alex Tomas1988b512008-01-28 23:58:27 -05001266 while (--depth >= 0) {
1267 ix = path[depth].p_idx;
Frank Mayhar273df552010-03-02 11:46:09 -05001268 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1269 EXT4_ERROR_INODE(inode,
1270 "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!",
1271 ix != NULL ? ix->ei_block : 0,
1272 EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?
1273 EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block : 0,
1274 depth);
1275 return -EIO;
1276 }
Alex Tomas1988b512008-01-28 23:58:27 -05001277 }
1278 return 0;
1279 }
1280
Frank Mayhar273df552010-03-02 11:46:09 -05001281 if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1282 EXT4_ERROR_INODE(inode,
1283 "logical %d < ee_block %d + ee_len %d!",
1284 *logical, le32_to_cpu(ex->ee_block), ee_len);
1285 return -EIO;
1286 }
Alex Tomas1988b512008-01-28 23:58:27 -05001287
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05001288 *logical = le32_to_cpu(ex->ee_block) + ee_len - 1;
1289 *phys = ext_pblock(ex) + ee_len - 1;
Alex Tomas1988b512008-01-28 23:58:27 -05001290 return 0;
1291}
1292
1293/*
1294 * search the closest allocated block to the right for *logical
1295 * and returns it at @logical + it's physical address at @phys
1296 * if *logical is the smallest allocated block, the function
1297 * returns 0 at @phys
1298 * return value contains 0 (success) or error code
1299 */
1300int
1301ext4_ext_search_right(struct inode *inode, struct ext4_ext_path *path,
1302 ext4_lblk_t *logical, ext4_fsblk_t *phys)
1303{
1304 struct buffer_head *bh = NULL;
1305 struct ext4_extent_header *eh;
1306 struct ext4_extent_idx *ix;
1307 struct ext4_extent *ex;
1308 ext4_fsblk_t block;
Eric Sandeen395a87b2009-03-10 18:18:47 -04001309 int depth; /* Note, NOT eh_depth; depth from top of tree */
1310 int ee_len;
Alex Tomas1988b512008-01-28 23:58:27 -05001311
Frank Mayhar273df552010-03-02 11:46:09 -05001312 if (unlikely(path == NULL)) {
1313 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1314 return -EIO;
1315 }
Alex Tomas1988b512008-01-28 23:58:27 -05001316 depth = path->p_depth;
1317 *phys = 0;
1318
1319 if (depth == 0 && path->p_ext == NULL)
1320 return 0;
1321
1322 /* usually extent in the path covers blocks smaller
1323 * then *logical, but it can be that extent is the
1324 * first one in the file */
1325
1326 ex = path[depth].p_ext;
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05001327 ee_len = ext4_ext_get_actual_len(ex);
Alex Tomas1988b512008-01-28 23:58:27 -05001328 if (*logical < le32_to_cpu(ex->ee_block)) {
Frank Mayhar273df552010-03-02 11:46:09 -05001329 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1330 EXT4_ERROR_INODE(inode,
1331 "first_extent(path[%d].p_hdr) != ex",
1332 depth);
1333 return -EIO;
1334 }
Alex Tomas1988b512008-01-28 23:58:27 -05001335 while (--depth >= 0) {
1336 ix = path[depth].p_idx;
Frank Mayhar273df552010-03-02 11:46:09 -05001337 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1338 EXT4_ERROR_INODE(inode,
1339 "ix != EXT_FIRST_INDEX *logical %d!",
1340 *logical);
1341 return -EIO;
1342 }
Alex Tomas1988b512008-01-28 23:58:27 -05001343 }
1344 *logical = le32_to_cpu(ex->ee_block);
1345 *phys = ext_pblock(ex);
1346 return 0;
1347 }
1348
Frank Mayhar273df552010-03-02 11:46:09 -05001349 if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1350 EXT4_ERROR_INODE(inode,
1351 "logical %d < ee_block %d + ee_len %d!",
1352 *logical, le32_to_cpu(ex->ee_block), ee_len);
1353 return -EIO;
1354 }
Alex Tomas1988b512008-01-28 23:58:27 -05001355
1356 if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
1357 /* next allocated block in this leaf */
1358 ex++;
1359 *logical = le32_to_cpu(ex->ee_block);
1360 *phys = ext_pblock(ex);
1361 return 0;
1362 }
1363
1364 /* go up and search for index to the right */
1365 while (--depth >= 0) {
1366 ix = path[depth].p_idx;
1367 if (ix != EXT_LAST_INDEX(path[depth].p_hdr))
Wu Fengguang25f1ee32008-11-25 17:24:23 -05001368 goto got_index;
Alex Tomas1988b512008-01-28 23:58:27 -05001369 }
1370
Wu Fengguang25f1ee32008-11-25 17:24:23 -05001371 /* we've gone up to the root and found no index to the right */
1372 return 0;
Alex Tomas1988b512008-01-28 23:58:27 -05001373
Wu Fengguang25f1ee32008-11-25 17:24:23 -05001374got_index:
Alex Tomas1988b512008-01-28 23:58:27 -05001375 /* we've found index to the right, let's
1376 * follow it and find the closest allocated
1377 * block to the right */
1378 ix++;
1379 block = idx_pblock(ix);
1380 while (++depth < path->p_depth) {
1381 bh = sb_bread(inode->i_sb, block);
1382 if (bh == NULL)
1383 return -EIO;
1384 eh = ext_block_hdr(bh);
Eric Sandeen395a87b2009-03-10 18:18:47 -04001385 /* subtract from p_depth to get proper eh_depth */
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -04001386 if (ext4_ext_check(inode, eh, path->p_depth - depth)) {
Alex Tomas1988b512008-01-28 23:58:27 -05001387 put_bh(bh);
1388 return -EIO;
1389 }
1390 ix = EXT_FIRST_INDEX(eh);
1391 block = idx_pblock(ix);
1392 put_bh(bh);
1393 }
1394
1395 bh = sb_bread(inode->i_sb, block);
1396 if (bh == NULL)
1397 return -EIO;
1398 eh = ext_block_hdr(bh);
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -04001399 if (ext4_ext_check(inode, eh, path->p_depth - depth)) {
Alex Tomas1988b512008-01-28 23:58:27 -05001400 put_bh(bh);
1401 return -EIO;
1402 }
1403 ex = EXT_FIRST_EXTENT(eh);
1404 *logical = le32_to_cpu(ex->ee_block);
1405 *phys = ext_pblock(ex);
1406 put_bh(bh);
1407 return 0;
Alex Tomas1988b512008-01-28 23:58:27 -05001408}
1409
1410/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001411 * ext4_ext_next_allocated_block:
1412 * returns allocated block in subsequent extent or EXT_MAX_BLOCK.
1413 * NOTE: it considers block number from index entry as
1414 * allocated block. Thus, index entries have to be consistent
1415 * with leaves.
Alex Tomasa86c6182006-10-11 01:21:03 -07001416 */
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001417static ext4_lblk_t
Alex Tomasa86c6182006-10-11 01:21:03 -07001418ext4_ext_next_allocated_block(struct ext4_ext_path *path)
1419{
1420 int depth;
1421
1422 BUG_ON(path == NULL);
1423 depth = path->p_depth;
1424
1425 if (depth == 0 && path->p_ext == NULL)
1426 return EXT_MAX_BLOCK;
1427
1428 while (depth >= 0) {
1429 if (depth == path->p_depth) {
1430 /* leaf */
1431 if (path[depth].p_ext !=
1432 EXT_LAST_EXTENT(path[depth].p_hdr))
1433 return le32_to_cpu(path[depth].p_ext[1].ee_block);
1434 } else {
1435 /* index */
1436 if (path[depth].p_idx !=
1437 EXT_LAST_INDEX(path[depth].p_hdr))
1438 return le32_to_cpu(path[depth].p_idx[1].ei_block);
1439 }
1440 depth--;
1441 }
1442
1443 return EXT_MAX_BLOCK;
1444}
1445
1446/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001447 * ext4_ext_next_leaf_block:
Alex Tomasa86c6182006-10-11 01:21:03 -07001448 * returns first allocated block from next leaf or EXT_MAX_BLOCK
1449 */
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001450static ext4_lblk_t ext4_ext_next_leaf_block(struct inode *inode,
Andrew Morton63f57932006-10-11 01:21:24 -07001451 struct ext4_ext_path *path)
Alex Tomasa86c6182006-10-11 01:21:03 -07001452{
1453 int depth;
1454
1455 BUG_ON(path == NULL);
1456 depth = path->p_depth;
1457
1458 /* zero-tree has no leaf blocks at all */
1459 if (depth == 0)
1460 return EXT_MAX_BLOCK;
1461
1462 /* go to index block */
1463 depth--;
1464
1465 while (depth >= 0) {
1466 if (path[depth].p_idx !=
1467 EXT_LAST_INDEX(path[depth].p_hdr))
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001468 return (ext4_lblk_t)
1469 le32_to_cpu(path[depth].p_idx[1].ei_block);
Alex Tomasa86c6182006-10-11 01:21:03 -07001470 depth--;
1471 }
1472
1473 return EXT_MAX_BLOCK;
1474}
1475
1476/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001477 * ext4_ext_correct_indexes:
1478 * if leaf gets modified and modified extent is first in the leaf,
1479 * then we have to correct all indexes above.
Alex Tomasa86c6182006-10-11 01:21:03 -07001480 * TODO: do we need to correct tree in all cases?
1481 */
Aneesh Kumar K.V1d03ec92008-01-28 23:58:27 -05001482static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
Alex Tomasa86c6182006-10-11 01:21:03 -07001483 struct ext4_ext_path *path)
1484{
1485 struct ext4_extent_header *eh;
1486 int depth = ext_depth(inode);
1487 struct ext4_extent *ex;
1488 __le32 border;
1489 int k, err = 0;
1490
1491 eh = path[depth].p_hdr;
1492 ex = path[depth].p_ext;
Frank Mayhar273df552010-03-02 11:46:09 -05001493
1494 if (unlikely(ex == NULL || eh == NULL)) {
1495 EXT4_ERROR_INODE(inode,
1496 "ex %p == NULL or eh %p == NULL", ex, eh);
1497 return -EIO;
1498 }
Alex Tomasa86c6182006-10-11 01:21:03 -07001499
1500 if (depth == 0) {
1501 /* there is no tree at all */
1502 return 0;
1503 }
1504
1505 if (ex != EXT_FIRST_EXTENT(eh)) {
1506 /* we correct tree if first leaf got modified only */
1507 return 0;
1508 }
1509
1510 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001511 * TODO: we need correction if border is smaller than current one
Alex Tomasa86c6182006-10-11 01:21:03 -07001512 */
1513 k = depth - 1;
1514 border = path[depth].p_ext->ee_block;
Avantika Mathur7e028972006-12-06 20:41:33 -08001515 err = ext4_ext_get_access(handle, inode, path + k);
1516 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001517 return err;
1518 path[k].p_idx->ei_block = border;
Avantika Mathur7e028972006-12-06 20:41:33 -08001519 err = ext4_ext_dirty(handle, inode, path + k);
1520 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001521 return err;
1522
1523 while (k--) {
1524 /* change all left-side indexes */
1525 if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr))
1526 break;
Avantika Mathur7e028972006-12-06 20:41:33 -08001527 err = ext4_ext_get_access(handle, inode, path + k);
1528 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001529 break;
1530 path[k].p_idx->ei_block = border;
Avantika Mathur7e028972006-12-06 20:41:33 -08001531 err = ext4_ext_dirty(handle, inode, path + k);
1532 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001533 break;
1534 }
1535
1536 return err;
1537}
1538
Akira Fujita748de672009-06-17 19:24:03 -04001539int
Alex Tomasa86c6182006-10-11 01:21:03 -07001540ext4_can_extents_be_merged(struct inode *inode, struct ext4_extent *ex1,
1541 struct ext4_extent *ex2)
1542{
Amit Arora749269f2007-07-18 09:02:56 -04001543 unsigned short ext1_ee_len, ext2_ee_len, max_len;
Amit Aroraa2df2a62007-07-17 21:42:41 -04001544
1545 /*
1546 * Make sure that either both extents are uninitialized, or
1547 * both are _not_.
1548 */
1549 if (ext4_ext_is_uninitialized(ex1) ^ ext4_ext_is_uninitialized(ex2))
1550 return 0;
1551
Amit Arora749269f2007-07-18 09:02:56 -04001552 if (ext4_ext_is_uninitialized(ex1))
1553 max_len = EXT_UNINIT_MAX_LEN;
1554 else
1555 max_len = EXT_INIT_MAX_LEN;
1556
Amit Aroraa2df2a62007-07-17 21:42:41 -04001557 ext1_ee_len = ext4_ext_get_actual_len(ex1);
1558 ext2_ee_len = ext4_ext_get_actual_len(ex2);
1559
1560 if (le32_to_cpu(ex1->ee_block) + ext1_ee_len !=
Andrew Morton63f57932006-10-11 01:21:24 -07001561 le32_to_cpu(ex2->ee_block))
Alex Tomasa86c6182006-10-11 01:21:03 -07001562 return 0;
1563
Suparna Bhattacharya471d4012006-10-11 01:21:06 -07001564 /*
1565 * To allow future support for preallocated extents to be added
1566 * as an RO_COMPAT feature, refuse to merge to extents if
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001567 * this can result in the top bit of ee_len being set.
Suparna Bhattacharya471d4012006-10-11 01:21:06 -07001568 */
Amit Arora749269f2007-07-18 09:02:56 -04001569 if (ext1_ee_len + ext2_ee_len > max_len)
Suparna Bhattacharya471d4012006-10-11 01:21:06 -07001570 return 0;
Robert P. J. Daybbf2f9f2007-02-17 19:20:16 +01001571#ifdef AGGRESSIVE_TEST
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05001572 if (ext1_ee_len >= 4)
Alex Tomasa86c6182006-10-11 01:21:03 -07001573 return 0;
1574#endif
1575
Amit Aroraa2df2a62007-07-17 21:42:41 -04001576 if (ext_pblock(ex1) + ext1_ee_len == ext_pblock(ex2))
Alex Tomasa86c6182006-10-11 01:21:03 -07001577 return 1;
1578 return 0;
1579}
1580
1581/*
Amit Arora56055d32007-07-17 21:42:38 -04001582 * This function tries to merge the "ex" extent to the next extent in the tree.
1583 * It always tries to merge towards right. If you want to merge towards
1584 * left, pass "ex - 1" as argument instead of "ex".
1585 * Returns 0 if the extents (ex and ex+1) were _not_ merged and returns
1586 * 1 if they got merged.
1587 */
1588int ext4_ext_try_to_merge(struct inode *inode,
1589 struct ext4_ext_path *path,
1590 struct ext4_extent *ex)
1591{
1592 struct ext4_extent_header *eh;
1593 unsigned int depth, len;
1594 int merge_done = 0;
1595 int uninitialized = 0;
1596
1597 depth = ext_depth(inode);
1598 BUG_ON(path[depth].p_hdr == NULL);
1599 eh = path[depth].p_hdr;
1600
1601 while (ex < EXT_LAST_EXTENT(eh)) {
1602 if (!ext4_can_extents_be_merged(inode, ex, ex + 1))
1603 break;
1604 /* merge with next extent! */
1605 if (ext4_ext_is_uninitialized(ex))
1606 uninitialized = 1;
1607 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
1608 + ext4_ext_get_actual_len(ex + 1));
1609 if (uninitialized)
1610 ext4_ext_mark_uninitialized(ex);
1611
1612 if (ex + 1 < EXT_LAST_EXTENT(eh)) {
1613 len = (EXT_LAST_EXTENT(eh) - ex - 1)
1614 * sizeof(struct ext4_extent);
1615 memmove(ex + 1, ex + 2, len);
1616 }
Marcin Slusarze8546d02008-04-17 10:38:59 -04001617 le16_add_cpu(&eh->eh_entries, -1);
Amit Arora56055d32007-07-17 21:42:38 -04001618 merge_done = 1;
1619 WARN_ON(eh->eh_entries == 0);
1620 if (!eh->eh_entries)
Theodore Ts'o24676da2010-05-16 21:00:00 -04001621 EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!");
Amit Arora56055d32007-07-17 21:42:38 -04001622 }
1623
1624 return merge_done;
1625}
1626
1627/*
Amit Arora25d14f92007-05-24 13:04:13 -04001628 * check if a portion of the "newext" extent overlaps with an
1629 * existing extent.
1630 *
1631 * If there is an overlap discovered, it updates the length of the newext
1632 * such that there will be no overlap, and then returns 1.
1633 * If there is no overlap found, it returns 0.
1634 */
1635unsigned int ext4_ext_check_overlap(struct inode *inode,
1636 struct ext4_extent *newext,
1637 struct ext4_ext_path *path)
1638{
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001639 ext4_lblk_t b1, b2;
Amit Arora25d14f92007-05-24 13:04:13 -04001640 unsigned int depth, len1;
1641 unsigned int ret = 0;
1642
1643 b1 = le32_to_cpu(newext->ee_block);
Amit Aroraa2df2a62007-07-17 21:42:41 -04001644 len1 = ext4_ext_get_actual_len(newext);
Amit Arora25d14f92007-05-24 13:04:13 -04001645 depth = ext_depth(inode);
1646 if (!path[depth].p_ext)
1647 goto out;
1648 b2 = le32_to_cpu(path[depth].p_ext->ee_block);
1649
1650 /*
1651 * get the next allocated block if the extent in the path
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001652 * is before the requested block(s)
Amit Arora25d14f92007-05-24 13:04:13 -04001653 */
1654 if (b2 < b1) {
1655 b2 = ext4_ext_next_allocated_block(path);
1656 if (b2 == EXT_MAX_BLOCK)
1657 goto out;
1658 }
1659
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001660 /* check for wrap through zero on extent logical start block*/
Amit Arora25d14f92007-05-24 13:04:13 -04001661 if (b1 + len1 < b1) {
1662 len1 = EXT_MAX_BLOCK - b1;
1663 newext->ee_len = cpu_to_le16(len1);
1664 ret = 1;
1665 }
1666
1667 /* check for overlap */
1668 if (b1 + len1 > b2) {
1669 newext->ee_len = cpu_to_le16(b2 - b1);
1670 ret = 1;
1671 }
1672out:
1673 return ret;
1674}
1675
1676/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001677 * ext4_ext_insert_extent:
1678 * tries to merge requsted extent into the existing extent or
1679 * inserts requested extent as new one into the tree,
1680 * creating new leaf in the no-space case.
Alex Tomasa86c6182006-10-11 01:21:03 -07001681 */
1682int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1683 struct ext4_ext_path *path,
Mingming Cao00314622009-09-28 15:49:08 -04001684 struct ext4_extent *newext, int flag)
Alex Tomasa86c6182006-10-11 01:21:03 -07001685{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001686 struct ext4_extent_header *eh;
Alex Tomasa86c6182006-10-11 01:21:03 -07001687 struct ext4_extent *ex, *fex;
1688 struct ext4_extent *nearex; /* nearest extent */
1689 struct ext4_ext_path *npath = NULL;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001690 int depth, len, err;
1691 ext4_lblk_t next;
Amit Aroraa2df2a62007-07-17 21:42:41 -04001692 unsigned uninitialized = 0;
Alex Tomasa86c6182006-10-11 01:21:03 -07001693
Frank Mayhar273df552010-03-02 11:46:09 -05001694 if (unlikely(ext4_ext_get_actual_len(newext) == 0)) {
1695 EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
1696 return -EIO;
1697 }
Alex Tomasa86c6182006-10-11 01:21:03 -07001698 depth = ext_depth(inode);
1699 ex = path[depth].p_ext;
Frank Mayhar273df552010-03-02 11:46:09 -05001700 if (unlikely(path[depth].p_hdr == NULL)) {
1701 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
1702 return -EIO;
1703 }
Alex Tomasa86c6182006-10-11 01:21:03 -07001704
1705 /* try to insert block into found extent and return */
Jiaying Zhang744692d2010-03-04 16:14:02 -05001706 if (ex && !(flag & EXT4_GET_BLOCKS_PRE_IO)
Mingming Cao00314622009-09-28 15:49:08 -04001707 && ext4_can_extents_be_merged(inode, ex, newext)) {
Mingming553f9002009-09-18 13:34:55 -04001708 ext_debug("append [%d]%d block to %d:[%d]%d (from %llu)\n",
1709 ext4_ext_is_uninitialized(newext),
Amit Aroraa2df2a62007-07-17 21:42:41 -04001710 ext4_ext_get_actual_len(newext),
Alex Tomasa86c6182006-10-11 01:21:03 -07001711 le32_to_cpu(ex->ee_block),
Mingming553f9002009-09-18 13:34:55 -04001712 ext4_ext_is_uninitialized(ex),
Amit Aroraa2df2a62007-07-17 21:42:41 -04001713 ext4_ext_get_actual_len(ex), ext_pblock(ex));
Avantika Mathur7e028972006-12-06 20:41:33 -08001714 err = ext4_ext_get_access(handle, inode, path + depth);
1715 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001716 return err;
Amit Aroraa2df2a62007-07-17 21:42:41 -04001717
1718 /*
1719 * ext4_can_extents_be_merged should have checked that either
1720 * both extents are uninitialized, or both aren't. Thus we
1721 * need to check only one of them here.
1722 */
1723 if (ext4_ext_is_uninitialized(ex))
1724 uninitialized = 1;
1725 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
1726 + ext4_ext_get_actual_len(newext));
1727 if (uninitialized)
1728 ext4_ext_mark_uninitialized(ex);
Alex Tomasa86c6182006-10-11 01:21:03 -07001729 eh = path[depth].p_hdr;
1730 nearex = ex;
1731 goto merge;
1732 }
1733
1734repeat:
1735 depth = ext_depth(inode);
1736 eh = path[depth].p_hdr;
1737 if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max))
1738 goto has_space;
1739
1740 /* probably next leaf has space for us? */
1741 fex = EXT_LAST_EXTENT(eh);
1742 next = ext4_ext_next_leaf_block(inode, path);
1743 if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)
1744 && next != EXT_MAX_BLOCK) {
1745 ext_debug("next leaf block - %d\n", next);
1746 BUG_ON(npath != NULL);
1747 npath = ext4_ext_find_extent(inode, next, NULL);
1748 if (IS_ERR(npath))
1749 return PTR_ERR(npath);
1750 BUG_ON(npath->p_depth != path->p_depth);
1751 eh = npath[depth].p_hdr;
1752 if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) {
1753 ext_debug("next leaf isnt full(%d)\n",
1754 le16_to_cpu(eh->eh_entries));
1755 path = npath;
1756 goto repeat;
1757 }
1758 ext_debug("next leaf has no free space(%d,%d)\n",
1759 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
1760 }
1761
1762 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001763 * There is no free space in the found leaf.
1764 * We're gonna add a new leaf in the tree.
Alex Tomasa86c6182006-10-11 01:21:03 -07001765 */
1766 err = ext4_ext_create_new_leaf(handle, inode, path, newext);
1767 if (err)
1768 goto cleanup;
1769 depth = ext_depth(inode);
1770 eh = path[depth].p_hdr;
1771
1772has_space:
1773 nearex = path[depth].p_ext;
1774
Avantika Mathur7e028972006-12-06 20:41:33 -08001775 err = ext4_ext_get_access(handle, inode, path + depth);
1776 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07001777 goto cleanup;
1778
1779 if (!nearex) {
1780 /* there is no extent in this leaf, create first one */
Mingming553f9002009-09-18 13:34:55 -04001781 ext_debug("first extent in the leaf: %d:%llu:[%d]%d\n",
Dave Kleikamp8c55e202007-05-24 13:04:54 -04001782 le32_to_cpu(newext->ee_block),
1783 ext_pblock(newext),
Mingming553f9002009-09-18 13:34:55 -04001784 ext4_ext_is_uninitialized(newext),
Amit Aroraa2df2a62007-07-17 21:42:41 -04001785 ext4_ext_get_actual_len(newext));
Alex Tomasa86c6182006-10-11 01:21:03 -07001786 path[depth].p_ext = EXT_FIRST_EXTENT(eh);
1787 } else if (le32_to_cpu(newext->ee_block)
Dave Kleikamp8c55e202007-05-24 13:04:54 -04001788 > le32_to_cpu(nearex->ee_block)) {
Alex Tomasa86c6182006-10-11 01:21:03 -07001789/* BUG_ON(newext->ee_block == nearex->ee_block); */
1790 if (nearex != EXT_LAST_EXTENT(eh)) {
1791 len = EXT_MAX_EXTENT(eh) - nearex;
1792 len = (len - 1) * sizeof(struct ext4_extent);
1793 len = len < 0 ? 0 : len;
Mingming553f9002009-09-18 13:34:55 -04001794 ext_debug("insert %d:%llu:[%d]%d after: nearest 0x%p, "
Alex Tomasa86c6182006-10-11 01:21:03 -07001795 "move %d from 0x%p to 0x%p\n",
Dave Kleikamp8c55e202007-05-24 13:04:54 -04001796 le32_to_cpu(newext->ee_block),
1797 ext_pblock(newext),
Mingming553f9002009-09-18 13:34:55 -04001798 ext4_ext_is_uninitialized(newext),
Amit Aroraa2df2a62007-07-17 21:42:41 -04001799 ext4_ext_get_actual_len(newext),
Alex Tomasa86c6182006-10-11 01:21:03 -07001800 nearex, len, nearex + 1, nearex + 2);
1801 memmove(nearex + 2, nearex + 1, len);
1802 }
1803 path[depth].p_ext = nearex + 1;
1804 } else {
1805 BUG_ON(newext->ee_block == nearex->ee_block);
1806 len = (EXT_MAX_EXTENT(eh) - nearex) * sizeof(struct ext4_extent);
1807 len = len < 0 ? 0 : len;
Mingming553f9002009-09-18 13:34:55 -04001808 ext_debug("insert %d:%llu:[%d]%d before: nearest 0x%p, "
Alex Tomasa86c6182006-10-11 01:21:03 -07001809 "move %d from 0x%p to 0x%p\n",
1810 le32_to_cpu(newext->ee_block),
Alex Tomasf65e6fb2006-10-11 01:21:05 -07001811 ext_pblock(newext),
Mingming553f9002009-09-18 13:34:55 -04001812 ext4_ext_is_uninitialized(newext),
Amit Aroraa2df2a62007-07-17 21:42:41 -04001813 ext4_ext_get_actual_len(newext),
Alex Tomasa86c6182006-10-11 01:21:03 -07001814 nearex, len, nearex + 1, nearex + 2);
1815 memmove(nearex + 1, nearex, len);
1816 path[depth].p_ext = nearex;
1817 }
1818
Marcin Slusarze8546d02008-04-17 10:38:59 -04001819 le16_add_cpu(&eh->eh_entries, 1);
Alex Tomasa86c6182006-10-11 01:21:03 -07001820 nearex = path[depth].p_ext;
1821 nearex->ee_block = newext->ee_block;
Aneesh Kumar K.Vb3776112007-10-16 18:38:25 -04001822 ext4_ext_store_pblock(nearex, ext_pblock(newext));
Alex Tomasa86c6182006-10-11 01:21:03 -07001823 nearex->ee_len = newext->ee_len;
Alex Tomasa86c6182006-10-11 01:21:03 -07001824
1825merge:
1826 /* try to merge extents to the right */
Jiaying Zhang744692d2010-03-04 16:14:02 -05001827 if (!(flag & EXT4_GET_BLOCKS_PRE_IO))
Mingming Cao00314622009-09-28 15:49:08 -04001828 ext4_ext_try_to_merge(inode, path, nearex);
Alex Tomasa86c6182006-10-11 01:21:03 -07001829
1830 /* try to merge extents to the left */
1831
1832 /* time to correct all indexes above */
1833 err = ext4_ext_correct_indexes(handle, inode, path);
1834 if (err)
1835 goto cleanup;
1836
1837 err = ext4_ext_dirty(handle, inode, path + depth);
1838
1839cleanup:
1840 if (npath) {
1841 ext4_ext_drop_refs(npath);
1842 kfree(npath);
1843 }
Alex Tomasa86c6182006-10-11 01:21:03 -07001844 ext4_ext_invalidate_cache(inode);
1845 return err;
1846}
1847
Eric Sandeen6873fa02008-10-07 00:46:36 -04001848int ext4_ext_walk_space(struct inode *inode, ext4_lblk_t block,
1849 ext4_lblk_t num, ext_prepare_callback func,
1850 void *cbdata)
1851{
1852 struct ext4_ext_path *path = NULL;
1853 struct ext4_ext_cache cbex;
1854 struct ext4_extent *ex;
1855 ext4_lblk_t next, start = 0, end = 0;
1856 ext4_lblk_t last = block + num;
1857 int depth, exists, err = 0;
1858
1859 BUG_ON(func == NULL);
1860 BUG_ON(inode == NULL);
1861
1862 while (block < last && block != EXT_MAX_BLOCK) {
1863 num = last - block;
1864 /* find extent for this block */
Theodore Ts'ofab3a542009-12-09 21:30:02 -05001865 down_read(&EXT4_I(inode)->i_data_sem);
Eric Sandeen6873fa02008-10-07 00:46:36 -04001866 path = ext4_ext_find_extent(inode, block, path);
Theodore Ts'ofab3a542009-12-09 21:30:02 -05001867 up_read(&EXT4_I(inode)->i_data_sem);
Eric Sandeen6873fa02008-10-07 00:46:36 -04001868 if (IS_ERR(path)) {
1869 err = PTR_ERR(path);
1870 path = NULL;
1871 break;
1872 }
1873
1874 depth = ext_depth(inode);
Frank Mayhar273df552010-03-02 11:46:09 -05001875 if (unlikely(path[depth].p_hdr == NULL)) {
1876 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
1877 err = -EIO;
1878 break;
1879 }
Eric Sandeen6873fa02008-10-07 00:46:36 -04001880 ex = path[depth].p_ext;
1881 next = ext4_ext_next_allocated_block(path);
1882
1883 exists = 0;
1884 if (!ex) {
1885 /* there is no extent yet, so try to allocate
1886 * all requested space */
1887 start = block;
1888 end = block + num;
1889 } else if (le32_to_cpu(ex->ee_block) > block) {
1890 /* need to allocate space before found extent */
1891 start = block;
1892 end = le32_to_cpu(ex->ee_block);
1893 if (block + num < end)
1894 end = block + num;
1895 } else if (block >= le32_to_cpu(ex->ee_block)
1896 + ext4_ext_get_actual_len(ex)) {
1897 /* need to allocate space after found extent */
1898 start = block;
1899 end = block + num;
1900 if (end >= next)
1901 end = next;
1902 } else if (block >= le32_to_cpu(ex->ee_block)) {
1903 /*
1904 * some part of requested space is covered
1905 * by found extent
1906 */
1907 start = block;
1908 end = le32_to_cpu(ex->ee_block)
1909 + ext4_ext_get_actual_len(ex);
1910 if (block + num < end)
1911 end = block + num;
1912 exists = 1;
1913 } else {
1914 BUG();
1915 }
1916 BUG_ON(end <= start);
1917
1918 if (!exists) {
1919 cbex.ec_block = start;
1920 cbex.ec_len = end - start;
1921 cbex.ec_start = 0;
1922 cbex.ec_type = EXT4_EXT_CACHE_GAP;
1923 } else {
1924 cbex.ec_block = le32_to_cpu(ex->ee_block);
1925 cbex.ec_len = ext4_ext_get_actual_len(ex);
1926 cbex.ec_start = ext_pblock(ex);
1927 cbex.ec_type = EXT4_EXT_CACHE_EXTENT;
1928 }
1929
Frank Mayhar273df552010-03-02 11:46:09 -05001930 if (unlikely(cbex.ec_len == 0)) {
1931 EXT4_ERROR_INODE(inode, "cbex.ec_len == 0");
1932 err = -EIO;
1933 break;
1934 }
Eric Sandeen6873fa02008-10-07 00:46:36 -04001935 err = func(inode, path, &cbex, ex, cbdata);
1936 ext4_ext_drop_refs(path);
1937
1938 if (err < 0)
1939 break;
1940
1941 if (err == EXT_REPEAT)
1942 continue;
1943 else if (err == EXT_BREAK) {
1944 err = 0;
1945 break;
1946 }
1947
1948 if (ext_depth(inode) != depth) {
1949 /* depth was changed. we have to realloc path */
1950 kfree(path);
1951 path = NULL;
1952 }
1953
1954 block = cbex.ec_block + cbex.ec_len;
1955 }
1956
1957 if (path) {
1958 ext4_ext_drop_refs(path);
1959 kfree(path);
1960 }
1961
1962 return err;
1963}
1964
Avantika Mathur09b88252006-12-06 20:41:36 -08001965static void
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001966ext4_ext_put_in_cache(struct inode *inode, ext4_lblk_t block,
Mingming Caodd545672007-07-31 00:37:46 -07001967 __u32 len, ext4_fsblk_t start, int type)
Alex Tomasa86c6182006-10-11 01:21:03 -07001968{
1969 struct ext4_ext_cache *cex;
1970 BUG_ON(len == 0);
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04001971 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
Alex Tomasa86c6182006-10-11 01:21:03 -07001972 cex = &EXT4_I(inode)->i_cached_extent;
1973 cex->ec_type = type;
1974 cex->ec_block = block;
1975 cex->ec_len = len;
1976 cex->ec_start = start;
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04001977 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
Alex Tomasa86c6182006-10-11 01:21:03 -07001978}
1979
1980/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07001981 * ext4_ext_put_gap_in_cache:
1982 * calculate boundaries of the gap that the requested block fits into
Alex Tomasa86c6182006-10-11 01:21:03 -07001983 * and cache this gap
1984 */
Avantika Mathur09b88252006-12-06 20:41:36 -08001985static void
Alex Tomasa86c6182006-10-11 01:21:03 -07001986ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001987 ext4_lblk_t block)
Alex Tomasa86c6182006-10-11 01:21:03 -07001988{
1989 int depth = ext_depth(inode);
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001990 unsigned long len;
1991 ext4_lblk_t lblock;
Alex Tomasa86c6182006-10-11 01:21:03 -07001992 struct ext4_extent *ex;
1993
1994 ex = path[depth].p_ext;
1995 if (ex == NULL) {
1996 /* there is no extent yet, so gap is [0;-] */
1997 lblock = 0;
1998 len = EXT_MAX_BLOCK;
1999 ext_debug("cache gap(whole file):");
2000 } else if (block < le32_to_cpu(ex->ee_block)) {
2001 lblock = block;
2002 len = le32_to_cpu(ex->ee_block) - block;
Eric Sandeenbba90742008-01-28 23:58:27 -05002003 ext_debug("cache gap(before): %u [%u:%u]",
2004 block,
2005 le32_to_cpu(ex->ee_block),
2006 ext4_ext_get_actual_len(ex));
Alex Tomasa86c6182006-10-11 01:21:03 -07002007 } else if (block >= le32_to_cpu(ex->ee_block)
Amit Aroraa2df2a62007-07-17 21:42:41 -04002008 + ext4_ext_get_actual_len(ex)) {
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002009 ext4_lblk_t next;
Dave Kleikamp8c55e202007-05-24 13:04:54 -04002010 lblock = le32_to_cpu(ex->ee_block)
Amit Aroraa2df2a62007-07-17 21:42:41 -04002011 + ext4_ext_get_actual_len(ex);
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002012
2013 next = ext4_ext_next_allocated_block(path);
Eric Sandeenbba90742008-01-28 23:58:27 -05002014 ext_debug("cache gap(after): [%u:%u] %u",
2015 le32_to_cpu(ex->ee_block),
2016 ext4_ext_get_actual_len(ex),
2017 block);
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002018 BUG_ON(next == lblock);
2019 len = next - lblock;
Alex Tomasa86c6182006-10-11 01:21:03 -07002020 } else {
2021 lblock = len = 0;
2022 BUG();
2023 }
2024
Eric Sandeenbba90742008-01-28 23:58:27 -05002025 ext_debug(" -> %u:%lu\n", lblock, len);
Alex Tomasa86c6182006-10-11 01:21:03 -07002026 ext4_ext_put_in_cache(inode, lblock, len, 0, EXT4_EXT_CACHE_GAP);
2027}
2028
Avantika Mathur09b88252006-12-06 20:41:36 -08002029static int
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002030ext4_ext_in_cache(struct inode *inode, ext4_lblk_t block,
Alex Tomasa86c6182006-10-11 01:21:03 -07002031 struct ext4_extent *ex)
2032{
2033 struct ext4_ext_cache *cex;
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04002034 int ret = EXT4_EXT_CACHE_NO;
Alex Tomasa86c6182006-10-11 01:21:03 -07002035
Theodore Ts'o60e66792010-05-17 07:00:00 -04002036 /*
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04002037 * We borrow i_block_reservation_lock to protect i_cached_extent
2038 */
2039 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
Alex Tomasa86c6182006-10-11 01:21:03 -07002040 cex = &EXT4_I(inode)->i_cached_extent;
2041
2042 /* has cache valid data? */
2043 if (cex->ec_type == EXT4_EXT_CACHE_NO)
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04002044 goto errout;
Alex Tomasa86c6182006-10-11 01:21:03 -07002045
2046 BUG_ON(cex->ec_type != EXT4_EXT_CACHE_GAP &&
2047 cex->ec_type != EXT4_EXT_CACHE_EXTENT);
Akinobu Mita731eb1a2010-03-03 23:55:01 -05002048 if (in_range(block, cex->ec_block, cex->ec_len)) {
Dave Kleikamp8c55e202007-05-24 13:04:54 -04002049 ex->ee_block = cpu_to_le32(cex->ec_block);
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002050 ext4_ext_store_pblock(ex, cex->ec_start);
Dave Kleikamp8c55e202007-05-24 13:04:54 -04002051 ex->ee_len = cpu_to_le16(cex->ec_len);
Eric Sandeenbba90742008-01-28 23:58:27 -05002052 ext_debug("%u cached by %u:%u:%llu\n",
2053 block,
2054 cex->ec_block, cex->ec_len, cex->ec_start);
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04002055 ret = cex->ec_type;
Alex Tomasa86c6182006-10-11 01:21:03 -07002056 }
Theodore Ts'o2ec0ae32009-05-15 09:07:28 -04002057errout:
2058 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
2059 return ret;
Alex Tomasa86c6182006-10-11 01:21:03 -07002060}
2061
2062/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002063 * ext4_ext_rm_idx:
2064 * removes index from the index block.
2065 * It's used in truncate case only, thus all requests are for
2066 * last index in the block only.
Alex Tomasa86c6182006-10-11 01:21:03 -07002067 */
Aneesh Kumar K.V1d03ec92008-01-28 23:58:27 -05002068static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
Alex Tomasa86c6182006-10-11 01:21:03 -07002069 struct ext4_ext_path *path)
2070{
Alex Tomasa86c6182006-10-11 01:21:03 -07002071 int err;
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002072 ext4_fsblk_t leaf;
Alex Tomasa86c6182006-10-11 01:21:03 -07002073
2074 /* free index block */
2075 path--;
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002076 leaf = idx_pblock(path->p_idx);
Frank Mayhar273df552010-03-02 11:46:09 -05002077 if (unlikely(path->p_hdr->eh_entries == 0)) {
2078 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
2079 return -EIO;
2080 }
Avantika Mathur7e028972006-12-06 20:41:33 -08002081 err = ext4_ext_get_access(handle, inode, path);
2082 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07002083 return err;
Marcin Slusarze8546d02008-04-17 10:38:59 -04002084 le16_add_cpu(&path->p_hdr->eh_entries, -1);
Avantika Mathur7e028972006-12-06 20:41:33 -08002085 err = ext4_ext_dirty(handle, inode, path);
2086 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07002087 return err;
Mingming Cao2ae02102006-10-11 01:21:11 -07002088 ext_debug("index is empty, remove it, free block %llu\n", leaf);
Theodore Ts'oe6362602009-11-23 07:17:05 -05002089 ext4_free_blocks(handle, inode, 0, leaf, 1,
2090 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
Alex Tomasa86c6182006-10-11 01:21:03 -07002091 return err;
2092}
2093
2094/*
Mingming Caoee12b632008-08-19 22:16:05 -04002095 * ext4_ext_calc_credits_for_single_extent:
2096 * This routine returns max. credits that needed to insert an extent
2097 * to the extent tree.
2098 * When pass the actual path, the caller should calculate credits
2099 * under i_data_sem.
Alex Tomasa86c6182006-10-11 01:21:03 -07002100 */
Mingming Cao525f4ed2008-08-19 22:15:58 -04002101int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks,
Alex Tomasa86c6182006-10-11 01:21:03 -07002102 struct ext4_ext_path *path)
2103{
Alex Tomasa86c6182006-10-11 01:21:03 -07002104 if (path) {
Mingming Caoee12b632008-08-19 22:16:05 -04002105 int depth = ext_depth(inode);
Mingming Caof3bd1f32008-08-19 22:16:03 -04002106 int ret = 0;
Mingming Caoee12b632008-08-19 22:16:05 -04002107
Alex Tomasa86c6182006-10-11 01:21:03 -07002108 /* probably there is space in leaf? */
Alex Tomasa86c6182006-10-11 01:21:03 -07002109 if (le16_to_cpu(path[depth].p_hdr->eh_entries)
Mingming Caoee12b632008-08-19 22:16:05 -04002110 < le16_to_cpu(path[depth].p_hdr->eh_max)) {
2111
2112 /*
2113 * There are some space in the leaf tree, no
2114 * need to account for leaf block credit
2115 *
2116 * bitmaps and block group descriptor blocks
2117 * and other metadat blocks still need to be
2118 * accounted.
2119 */
Mingming Cao525f4ed2008-08-19 22:15:58 -04002120 /* 1 bitmap, 1 block group descriptor */
Mingming Caoee12b632008-08-19 22:16:05 -04002121 ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);
Aneesh Kumar K.V5887e982009-07-05 23:12:04 -04002122 return ret;
Mingming Caoee12b632008-08-19 22:16:05 -04002123 }
Alex Tomasa86c6182006-10-11 01:21:03 -07002124 }
2125
Mingming Cao525f4ed2008-08-19 22:15:58 -04002126 return ext4_chunk_trans_blocks(inode, nrblocks);
Mingming Caoee12b632008-08-19 22:16:05 -04002127}
Alex Tomasa86c6182006-10-11 01:21:03 -07002128
Mingming Caoee12b632008-08-19 22:16:05 -04002129/*
2130 * How many index/leaf blocks need to change/allocate to modify nrblocks?
2131 *
2132 * if nrblocks are fit in a single extent (chunk flag is 1), then
2133 * in the worse case, each tree level index/leaf need to be changed
2134 * if the tree split due to insert a new extent, then the old tree
2135 * index/leaf need to be updated too
2136 *
2137 * If the nrblocks are discontiguous, they could cause
2138 * the whole tree split more than once, but this is really rare.
2139 */
Mingming Cao525f4ed2008-08-19 22:15:58 -04002140int ext4_ext_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
Mingming Caoee12b632008-08-19 22:16:05 -04002141{
2142 int index;
2143 int depth = ext_depth(inode);
Alex Tomasa86c6182006-10-11 01:21:03 -07002144
Mingming Caoee12b632008-08-19 22:16:05 -04002145 if (chunk)
2146 index = depth * 2;
2147 else
2148 index = depth * 3;
Alex Tomasa86c6182006-10-11 01:21:03 -07002149
Mingming Caoee12b632008-08-19 22:16:05 -04002150 return index;
Alex Tomasa86c6182006-10-11 01:21:03 -07002151}
2152
2153static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
2154 struct ext4_extent *ex,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002155 ext4_lblk_t from, ext4_lblk_t to)
Alex Tomasa86c6182006-10-11 01:21:03 -07002156{
Amit Aroraa2df2a62007-07-17 21:42:41 -04002157 unsigned short ee_len = ext4_ext_get_actual_len(ex);
Theodore Ts'oe6362602009-11-23 07:17:05 -05002158 int flags = EXT4_FREE_BLOCKS_FORGET;
Alex Tomasa86c6182006-10-11 01:21:03 -07002159
Alex Tomasc9de5602008-01-29 00:19:52 -05002160 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
Theodore Ts'oe6362602009-11-23 07:17:05 -05002161 flags |= EXT4_FREE_BLOCKS_METADATA;
Alex Tomasa86c6182006-10-11 01:21:03 -07002162#ifdef EXTENTS_STATS
2163 {
2164 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Alex Tomasa86c6182006-10-11 01:21:03 -07002165 spin_lock(&sbi->s_ext_stats_lock);
2166 sbi->s_ext_blocks += ee_len;
2167 sbi->s_ext_extents++;
2168 if (ee_len < sbi->s_ext_min)
2169 sbi->s_ext_min = ee_len;
2170 if (ee_len > sbi->s_ext_max)
2171 sbi->s_ext_max = ee_len;
2172 if (ext_depth(inode) > sbi->s_depth_max)
2173 sbi->s_depth_max = ext_depth(inode);
2174 spin_unlock(&sbi->s_ext_stats_lock);
2175 }
2176#endif
2177 if (from >= le32_to_cpu(ex->ee_block)
Amit Aroraa2df2a62007-07-17 21:42:41 -04002178 && to == le32_to_cpu(ex->ee_block) + ee_len - 1) {
Alex Tomasa86c6182006-10-11 01:21:03 -07002179 /* tail removal */
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002180 ext4_lblk_t num;
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002181 ext4_fsblk_t start;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002182
Amit Aroraa2df2a62007-07-17 21:42:41 -04002183 num = le32_to_cpu(ex->ee_block) + ee_len - from;
2184 start = ext_pblock(ex) + ee_len - num;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002185 ext_debug("free last %u blocks starting %llu\n", num, start);
Theodore Ts'oe6362602009-11-23 07:17:05 -05002186 ext4_free_blocks(handle, inode, 0, start, num, flags);
Alex Tomasa86c6182006-10-11 01:21:03 -07002187 } else if (from == le32_to_cpu(ex->ee_block)
Amit Aroraa2df2a62007-07-17 21:42:41 -04002188 && to <= le32_to_cpu(ex->ee_block) + ee_len - 1) {
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002189 printk(KERN_INFO "strange request: removal %u-%u from %u:%u\n",
Amit Aroraa2df2a62007-07-17 21:42:41 -04002190 from, to, le32_to_cpu(ex->ee_block), ee_len);
Alex Tomasa86c6182006-10-11 01:21:03 -07002191 } else {
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002192 printk(KERN_INFO "strange request: removal(2) "
2193 "%u-%u from %u:%u\n",
2194 from, to, le32_to_cpu(ex->ee_block), ee_len);
Alex Tomasa86c6182006-10-11 01:21:03 -07002195 }
2196 return 0;
2197}
2198
2199static int
2200ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002201 struct ext4_ext_path *path, ext4_lblk_t start)
Alex Tomasa86c6182006-10-11 01:21:03 -07002202{
2203 int err = 0, correct_index = 0;
2204 int depth = ext_depth(inode), credits;
2205 struct ext4_extent_header *eh;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002206 ext4_lblk_t a, b, block;
2207 unsigned num;
2208 ext4_lblk_t ex_ee_block;
Alex Tomasa86c6182006-10-11 01:21:03 -07002209 unsigned short ex_ee_len;
Amit Aroraa2df2a62007-07-17 21:42:41 -04002210 unsigned uninitialized = 0;
Alex Tomasa86c6182006-10-11 01:21:03 -07002211 struct ext4_extent *ex;
2212
Alex Tomasc29c0ae2007-07-18 09:19:09 -04002213 /* the header must be checked already in ext4_ext_remove_space() */
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002214 ext_debug("truncate since %u in leaf\n", start);
Alex Tomasa86c6182006-10-11 01:21:03 -07002215 if (!path[depth].p_hdr)
2216 path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);
2217 eh = path[depth].p_hdr;
Frank Mayhar273df552010-03-02 11:46:09 -05002218 if (unlikely(path[depth].p_hdr == NULL)) {
2219 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2220 return -EIO;
2221 }
Alex Tomasa86c6182006-10-11 01:21:03 -07002222 /* find where to start removing */
2223 ex = EXT_LAST_EXTENT(eh);
2224
2225 ex_ee_block = le32_to_cpu(ex->ee_block);
Amit Aroraa2df2a62007-07-17 21:42:41 -04002226 ex_ee_len = ext4_ext_get_actual_len(ex);
Alex Tomasa86c6182006-10-11 01:21:03 -07002227
2228 while (ex >= EXT_FIRST_EXTENT(eh) &&
2229 ex_ee_block + ex_ee_len > start) {
Aneesh Kumar K.Va41f2072009-06-10 14:22:55 -04002230
2231 if (ext4_ext_is_uninitialized(ex))
2232 uninitialized = 1;
2233 else
2234 uninitialized = 0;
2235
Mingming553f9002009-09-18 13:34:55 -04002236 ext_debug("remove ext %u:[%d]%d\n", ex_ee_block,
2237 uninitialized, ex_ee_len);
Alex Tomasa86c6182006-10-11 01:21:03 -07002238 path[depth].p_ext = ex;
2239
2240 a = ex_ee_block > start ? ex_ee_block : start;
2241 b = ex_ee_block + ex_ee_len - 1 < EXT_MAX_BLOCK ?
2242 ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCK;
2243
2244 ext_debug(" border %u:%u\n", a, b);
2245
2246 if (a != ex_ee_block && b != ex_ee_block + ex_ee_len - 1) {
2247 block = 0;
2248 num = 0;
2249 BUG();
2250 } else if (a != ex_ee_block) {
2251 /* remove tail of the extent */
2252 block = ex_ee_block;
2253 num = a - block;
2254 } else if (b != ex_ee_block + ex_ee_len - 1) {
2255 /* remove head of the extent */
2256 block = a;
2257 num = b - a;
2258 /* there is no "make a hole" API yet */
2259 BUG();
2260 } else {
2261 /* remove whole extent: excellent! */
2262 block = ex_ee_block;
2263 num = 0;
2264 BUG_ON(a != ex_ee_block);
2265 BUG_ON(b != ex_ee_block + ex_ee_len - 1);
2266 }
2267
Theodore Ts'o34071da2008-08-01 21:59:19 -04002268 /*
2269 * 3 for leaf, sb, and inode plus 2 (bmap and group
2270 * descriptor) for each block group; assume two block
2271 * groups plus ex_ee_len/blocks_per_block_group for
2272 * the worst case
2273 */
2274 credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
Alex Tomasa86c6182006-10-11 01:21:03 -07002275 if (ex == EXT_FIRST_EXTENT(eh)) {
2276 correct_index = 1;
2277 credits += (ext_depth(inode)) + 1;
2278 }
Dmitry Monakhov5aca07e2009-12-08 22:42:15 -05002279 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
Alex Tomasa86c6182006-10-11 01:21:03 -07002280
Jan Kara487caee2009-08-17 22:17:20 -04002281 err = ext4_ext_truncate_extend_restart(handle, inode, credits);
Shen Feng9102e4f2008-07-11 19:27:31 -04002282 if (err)
Alex Tomasa86c6182006-10-11 01:21:03 -07002283 goto out;
Alex Tomasa86c6182006-10-11 01:21:03 -07002284
2285 err = ext4_ext_get_access(handle, inode, path + depth);
2286 if (err)
2287 goto out;
2288
2289 err = ext4_remove_blocks(handle, inode, ex, a, b);
2290 if (err)
2291 goto out;
2292
2293 if (num == 0) {
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002294 /* this extent is removed; mark slot entirely unused */
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002295 ext4_ext_store_pblock(ex, 0);
Marcin Slusarze8546d02008-04-17 10:38:59 -04002296 le16_add_cpu(&eh->eh_entries, -1);
Alex Tomasa86c6182006-10-11 01:21:03 -07002297 }
2298
2299 ex->ee_block = cpu_to_le32(block);
2300 ex->ee_len = cpu_to_le16(num);
Amit Arora749269f2007-07-18 09:02:56 -04002301 /*
2302 * Do not mark uninitialized if all the blocks in the
2303 * extent have been removed.
2304 */
2305 if (uninitialized && num)
Amit Aroraa2df2a62007-07-17 21:42:41 -04002306 ext4_ext_mark_uninitialized(ex);
Alex Tomasa86c6182006-10-11 01:21:03 -07002307
2308 err = ext4_ext_dirty(handle, inode, path + depth);
2309 if (err)
2310 goto out;
2311
Mingming Cao2ae02102006-10-11 01:21:11 -07002312 ext_debug("new extent: %u:%u:%llu\n", block, num,
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002313 ext_pblock(ex));
Alex Tomasa86c6182006-10-11 01:21:03 -07002314 ex--;
2315 ex_ee_block = le32_to_cpu(ex->ee_block);
Amit Aroraa2df2a62007-07-17 21:42:41 -04002316 ex_ee_len = ext4_ext_get_actual_len(ex);
Alex Tomasa86c6182006-10-11 01:21:03 -07002317 }
2318
2319 if (correct_index && eh->eh_entries)
2320 err = ext4_ext_correct_indexes(handle, inode, path);
2321
2322 /* if this leaf is free, then we should
2323 * remove it from index block above */
2324 if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
2325 err = ext4_ext_rm_idx(handle, inode, path + depth);
2326
2327out:
2328 return err;
2329}
2330
2331/*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002332 * ext4_ext_more_to_rm:
2333 * returns 1 if current index has to be freed (even partial)
Alex Tomasa86c6182006-10-11 01:21:03 -07002334 */
Avantika Mathur09b88252006-12-06 20:41:36 -08002335static int
Alex Tomasa86c6182006-10-11 01:21:03 -07002336ext4_ext_more_to_rm(struct ext4_ext_path *path)
2337{
2338 BUG_ON(path->p_idx == NULL);
2339
2340 if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr))
2341 return 0;
2342
2343 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002344 * if truncate on deeper level happened, it wasn't partial,
Alex Tomasa86c6182006-10-11 01:21:03 -07002345 * so we have to consider current index for truncation
2346 */
2347 if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)
2348 return 0;
2349 return 1;
2350}
2351
Aneesh Kumar K.V1d03ec92008-01-28 23:58:27 -05002352static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start)
Alex Tomasa86c6182006-10-11 01:21:03 -07002353{
2354 struct super_block *sb = inode->i_sb;
2355 int depth = ext_depth(inode);
2356 struct ext4_ext_path *path;
2357 handle_t *handle;
Dmitry Monakhov0617b832010-05-17 01:00:00 -04002358 int i, err;
Alex Tomasa86c6182006-10-11 01:21:03 -07002359
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002360 ext_debug("truncate since %u\n", start);
Alex Tomasa86c6182006-10-11 01:21:03 -07002361
2362 /* probably first extent we're gonna free will be last in block */
2363 handle = ext4_journal_start(inode, depth + 1);
2364 if (IS_ERR(handle))
2365 return PTR_ERR(handle);
2366
Dmitry Monakhov0617b832010-05-17 01:00:00 -04002367again:
Alex Tomasa86c6182006-10-11 01:21:03 -07002368 ext4_ext_invalidate_cache(inode);
2369
2370 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002371 * We start scanning from right side, freeing all the blocks
2372 * after i_size and walking into the tree depth-wise.
Alex Tomasa86c6182006-10-11 01:21:03 -07002373 */
Dmitry Monakhov0617b832010-05-17 01:00:00 -04002374 depth = ext_depth(inode);
Josef Bacik216553c2008-04-29 22:02:02 -04002375 path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS);
Alex Tomasa86c6182006-10-11 01:21:03 -07002376 if (path == NULL) {
2377 ext4_journal_stop(handle);
2378 return -ENOMEM;
2379 }
Dmitry Monakhov0617b832010-05-17 01:00:00 -04002380 path[0].p_depth = depth;
Alex Tomasa86c6182006-10-11 01:21:03 -07002381 path[0].p_hdr = ext_inode_hdr(inode);
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -04002382 if (ext4_ext_check(inode, path[0].p_hdr, depth)) {
Alex Tomasa86c6182006-10-11 01:21:03 -07002383 err = -EIO;
2384 goto out;
2385 }
Dmitry Monakhov0617b832010-05-17 01:00:00 -04002386 i = err = 0;
Alex Tomasa86c6182006-10-11 01:21:03 -07002387
2388 while (i >= 0 && err == 0) {
2389 if (i == depth) {
2390 /* this is leaf block */
2391 err = ext4_ext_rm_leaf(handle, inode, path, start);
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002392 /* root level has p_bh == NULL, brelse() eats this */
Alex Tomasa86c6182006-10-11 01:21:03 -07002393 brelse(path[i].p_bh);
2394 path[i].p_bh = NULL;
2395 i--;
2396 continue;
2397 }
2398
2399 /* this is index block */
2400 if (!path[i].p_hdr) {
2401 ext_debug("initialize header\n");
2402 path[i].p_hdr = ext_block_hdr(path[i].p_bh);
Alex Tomasa86c6182006-10-11 01:21:03 -07002403 }
2404
Alex Tomasa86c6182006-10-11 01:21:03 -07002405 if (!path[i].p_idx) {
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002406 /* this level hasn't been touched yet */
Alex Tomasa86c6182006-10-11 01:21:03 -07002407 path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
2408 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
2409 ext_debug("init index ptr: hdr 0x%p, num %d\n",
2410 path[i].p_hdr,
2411 le16_to_cpu(path[i].p_hdr->eh_entries));
2412 } else {
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002413 /* we were already here, see at next index */
Alex Tomasa86c6182006-10-11 01:21:03 -07002414 path[i].p_idx--;
2415 }
2416
2417 ext_debug("level %d - index, first 0x%p, cur 0x%p\n",
2418 i, EXT_FIRST_INDEX(path[i].p_hdr),
2419 path[i].p_idx);
2420 if (ext4_ext_more_to_rm(path + i)) {
Alex Tomasc29c0ae2007-07-18 09:19:09 -04002421 struct buffer_head *bh;
Alex Tomasa86c6182006-10-11 01:21:03 -07002422 /* go to the next level */
Mingming Cao2ae02102006-10-11 01:21:11 -07002423 ext_debug("move to level %d (block %llu)\n",
Alex Tomasf65e6fb2006-10-11 01:21:05 -07002424 i + 1, idx_pblock(path[i].p_idx));
Alex Tomasa86c6182006-10-11 01:21:03 -07002425 memset(path + i + 1, 0, sizeof(*path));
Alex Tomasc29c0ae2007-07-18 09:19:09 -04002426 bh = sb_bread(sb, idx_pblock(path[i].p_idx));
2427 if (!bh) {
Alex Tomasa86c6182006-10-11 01:21:03 -07002428 /* should we reset i_size? */
2429 err = -EIO;
2430 break;
2431 }
Alex Tomasc29c0ae2007-07-18 09:19:09 -04002432 if (WARN_ON(i + 1 > depth)) {
2433 err = -EIO;
2434 break;
2435 }
Aneesh Kumar K.V56b19862009-03-12 09:51:20 -04002436 if (ext4_ext_check(inode, ext_block_hdr(bh),
Alex Tomasc29c0ae2007-07-18 09:19:09 -04002437 depth - i - 1)) {
2438 err = -EIO;
2439 break;
2440 }
2441 path[i + 1].p_bh = bh;
Alex Tomasa86c6182006-10-11 01:21:03 -07002442
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002443 /* save actual number of indexes since this
2444 * number is changed at the next iteration */
Alex Tomasa86c6182006-10-11 01:21:03 -07002445 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
2446 i++;
2447 } else {
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002448 /* we finished processing this index, go up */
Alex Tomasa86c6182006-10-11 01:21:03 -07002449 if (path[i].p_hdr->eh_entries == 0 && i > 0) {
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002450 /* index is empty, remove it;
Alex Tomasa86c6182006-10-11 01:21:03 -07002451 * handle must be already prepared by the
2452 * truncatei_leaf() */
2453 err = ext4_ext_rm_idx(handle, inode, path + i);
2454 }
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002455 /* root level has p_bh == NULL, brelse() eats this */
Alex Tomasa86c6182006-10-11 01:21:03 -07002456 brelse(path[i].p_bh);
2457 path[i].p_bh = NULL;
2458 i--;
2459 ext_debug("return to level %d\n", i);
2460 }
2461 }
2462
2463 /* TODO: flexible tree reduction should be here */
2464 if (path->p_hdr->eh_entries == 0) {
2465 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07002466 * truncate to zero freed all the tree,
2467 * so we need to correct eh_depth
Alex Tomasa86c6182006-10-11 01:21:03 -07002468 */
2469 err = ext4_ext_get_access(handle, inode, path);
2470 if (err == 0) {
2471 ext_inode_hdr(inode)->eh_depth = 0;
2472 ext_inode_hdr(inode)->eh_max =
Theodore Ts'o55ad63b2009-08-28 10:40:33 -04002473 cpu_to_le16(ext4_ext_space_root(inode, 0));
Alex Tomasa86c6182006-10-11 01:21:03 -07002474 err = ext4_ext_dirty(handle, inode, path);
2475 }
2476 }
2477out:
Alex Tomasa86c6182006-10-11 01:21:03 -07002478 ext4_ext_drop_refs(path);
2479 kfree(path);
Dmitry Monakhov0617b832010-05-17 01:00:00 -04002480 if (err == -EAGAIN)
2481 goto again;
Alex Tomasa86c6182006-10-11 01:21:03 -07002482 ext4_journal_stop(handle);
2483
2484 return err;
2485}
2486
2487/*
2488 * called at mount time
2489 */
2490void ext4_ext_init(struct super_block *sb)
2491{
2492 /*
2493 * possible initialization would be here
2494 */
2495
Theodore Ts'o83982b62009-01-06 14:53:16 -05002496 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
Theodore Ts'o90576c02009-09-29 15:51:30 -04002497#if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS)
Theodore Ts'o4776004f2008-09-08 23:00:52 -04002498 printk(KERN_INFO "EXT4-fs: file extents enabled");
Robert P. J. Daybbf2f9f2007-02-17 19:20:16 +01002499#ifdef AGGRESSIVE_TEST
2500 printk(", aggressive tests");
Alex Tomasa86c6182006-10-11 01:21:03 -07002501#endif
2502#ifdef CHECK_BINSEARCH
2503 printk(", check binsearch");
2504#endif
2505#ifdef EXTENTS_STATS
2506 printk(", stats");
2507#endif
2508 printk("\n");
Theodore Ts'o90576c02009-09-29 15:51:30 -04002509#endif
Alex Tomasa86c6182006-10-11 01:21:03 -07002510#ifdef EXTENTS_STATS
2511 spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock);
2512 EXT4_SB(sb)->s_ext_min = 1 << 30;
2513 EXT4_SB(sb)->s_ext_max = 0;
2514#endif
2515 }
2516}
2517
2518/*
2519 * called at umount time
2520 */
2521void ext4_ext_release(struct super_block *sb)
2522{
Theodore Ts'o83982b62009-01-06 14:53:16 -05002523 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS))
Alex Tomasa86c6182006-10-11 01:21:03 -07002524 return;
2525
2526#ifdef EXTENTS_STATS
2527 if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) {
2528 struct ext4_sb_info *sbi = EXT4_SB(sb);
2529 printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n",
2530 sbi->s_ext_blocks, sbi->s_ext_extents,
2531 sbi->s_ext_blocks / sbi->s_ext_extents);
2532 printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n",
2533 sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max);
2534 }
2535#endif
2536}
2537
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002538static void bi_complete(struct bio *bio, int error)
2539{
2540 complete((struct completion *)bio->bi_private);
2541}
2542
2543/* FIXME!! we need to try to merge to left or right after zero-out */
2544static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
2545{
Jing Zhangb7203032010-05-12 00:00:00 -04002546 int ret;
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002547 struct bio *bio;
2548 int blkbits, blocksize;
2549 sector_t ee_pblock;
2550 struct completion event;
2551 unsigned int ee_len, len, done, offset;
2552
2553
2554 blkbits = inode->i_blkbits;
2555 blocksize = inode->i_sb->s_blocksize;
2556 ee_len = ext4_ext_get_actual_len(ex);
2557 ee_pblock = ext_pblock(ex);
2558
2559 /* convert ee_pblock to 512 byte sectors */
2560 ee_pblock = ee_pblock << (blkbits - 9);
2561
2562 while (ee_len > 0) {
2563
2564 if (ee_len > BIO_MAX_PAGES)
2565 len = BIO_MAX_PAGES;
2566 else
2567 len = ee_len;
2568
2569 bio = bio_alloc(GFP_NOIO, len);
Jing Zhangb7203032010-05-12 00:00:00 -04002570 if (!bio)
2571 return -ENOMEM;
2572
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002573 bio->bi_sector = ee_pblock;
2574 bio->bi_bdev = inode->i_sb->s_bdev;
2575
2576 done = 0;
2577 offset = 0;
2578 while (done < len) {
2579 ret = bio_add_page(bio, ZERO_PAGE(0),
2580 blocksize, offset);
2581 if (ret != blocksize) {
2582 /*
2583 * We can't add any more pages because of
2584 * hardware limitations. Start a new bio.
2585 */
2586 break;
2587 }
2588 done++;
2589 offset += blocksize;
2590 if (offset >= PAGE_CACHE_SIZE)
2591 offset = 0;
2592 }
2593
2594 init_completion(&event);
2595 bio->bi_private = &event;
2596 bio->bi_end_io = bi_complete;
2597 submit_bio(WRITE, bio);
2598 wait_for_completion(&event);
2599
Jing Zhangb7203032010-05-12 00:00:00 -04002600 if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
2601 bio_put(bio);
2602 return -EIO;
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002603 }
2604 bio_put(bio);
2605 ee_len -= done;
2606 ee_pblock += done << (blkbits - 9);
2607 }
Jing Zhangb7203032010-05-12 00:00:00 -04002608 return 0;
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002609}
2610
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002611#define EXT4_EXT_ZERO_LEN 7
Amit Arora56055d32007-07-17 21:42:38 -04002612/*
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002613 * This function is called by ext4_ext_map_blocks() if someone tries to write
Amit Arora56055d32007-07-17 21:42:38 -04002614 * to an uninitialized extent. It may result in splitting the uninitialized
2615 * extent into multiple extents (upto three - one initialized and two
2616 * uninitialized).
2617 * There are three possibilities:
2618 * a> There is no split required: Entire extent should be initialized
2619 * b> Splits in two extents: Write is happening at either end of the extent
2620 * c> Splits in three extents: Somone is writing in middle of the extent
2621 */
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002622static int ext4_ext_convert_to_initialized(handle_t *handle,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002623 struct inode *inode,
2624 struct ext4_map_blocks *map,
2625 struct ext4_ext_path *path)
Amit Arora56055d32007-07-17 21:42:38 -04002626{
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002627 struct ext4_extent *ex, newex, orig_ex;
Amit Arora56055d32007-07-17 21:42:38 -04002628 struct ext4_extent *ex1 = NULL;
2629 struct ext4_extent *ex2 = NULL;
2630 struct ext4_extent *ex3 = NULL;
2631 struct ext4_extent_header *eh;
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002632 ext4_lblk_t ee_block, eof_block;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002633 unsigned int allocated, ee_len, depth;
Amit Arora56055d32007-07-17 21:42:38 -04002634 ext4_fsblk_t newblock;
2635 int err = 0;
2636 int ret = 0;
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002637 int may_zeroout;
2638
2639 ext_debug("ext4_ext_convert_to_initialized: inode %lu, logical"
2640 "block %llu, max_blocks %u\n", inode->i_ino,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002641 (unsigned long long)map->m_lblk, map->m_len);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002642
2643 eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >>
2644 inode->i_sb->s_blocksize_bits;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002645 if (eof_block < map->m_lblk + map->m_len)
2646 eof_block = map->m_lblk + map->m_len;
Amit Arora56055d32007-07-17 21:42:38 -04002647
2648 depth = ext_depth(inode);
2649 eh = path[depth].p_hdr;
2650 ex = path[depth].p_ext;
2651 ee_block = le32_to_cpu(ex->ee_block);
2652 ee_len = ext4_ext_get_actual_len(ex);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002653 allocated = ee_len - (map->m_lblk - ee_block);
2654 newblock = map->m_lblk - ee_block + ext_pblock(ex);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002655
Amit Arora56055d32007-07-17 21:42:38 -04002656 ex2 = ex;
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002657 orig_ex.ee_block = ex->ee_block;
2658 orig_ex.ee_len = cpu_to_le16(ee_len);
2659 ext4_ext_store_pblock(&orig_ex, ext_pblock(ex));
Amit Arora56055d32007-07-17 21:42:38 -04002660
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002661 /*
2662 * It is safe to convert extent to initialized via explicit
2663 * zeroout only if extent is fully insde i_size or new_size.
2664 */
2665 may_zeroout = ee_block + ee_len <= eof_block;
2666
Aneesh Kumar K.V9df56432008-02-22 06:17:31 -05002667 err = ext4_ext_get_access(handle, inode, path + depth);
2668 if (err)
2669 goto out;
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002670 /* If extent has less than 2*EXT4_EXT_ZERO_LEN zerout directly */
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002671 if (ee_len <= 2*EXT4_EXT_ZERO_LEN && may_zeroout) {
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002672 err = ext4_ext_zeroout(inode, &orig_ex);
2673 if (err)
2674 goto fix_extent_len;
2675 /* update the extent length and mark as initialized */
2676 ex->ee_block = orig_ex.ee_block;
2677 ex->ee_len = orig_ex.ee_len;
2678 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
2679 ext4_ext_dirty(handle, inode, path + depth);
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002680 /* zeroed the full extent */
2681 return allocated;
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002682 }
Aneesh Kumar K.V9df56432008-02-22 06:17:31 -05002683
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002684 /* ex1: ee_block to map->m_lblk - 1 : uninitialized */
2685 if (map->m_lblk > ee_block) {
Amit Arora56055d32007-07-17 21:42:38 -04002686 ex1 = ex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002687 ex1->ee_len = cpu_to_le16(map->m_lblk - ee_block);
Amit Arora56055d32007-07-17 21:42:38 -04002688 ext4_ext_mark_uninitialized(ex1);
2689 ex2 = &newex;
2690 }
2691 /*
2692 * for sanity, update the length of the ex2 extent before
2693 * we insert ex3, if ex1 is NULL. This is to avoid temporary
2694 * overlap of blocks.
2695 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002696 if (!ex1 && allocated > map->m_len)
2697 ex2->ee_len = cpu_to_le16(map->m_len);
Amit Arora56055d32007-07-17 21:42:38 -04002698 /* ex3: to ee_block + ee_len : uninitialised */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002699 if (allocated > map->m_len) {
Amit Arora56055d32007-07-17 21:42:38 -04002700 unsigned int newdepth;
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002701 /* If extent has less than EXT4_EXT_ZERO_LEN zerout directly */
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002702 if (allocated <= EXT4_EXT_ZERO_LEN && may_zeroout) {
Aneesh Kumar K.Vd03856b2008-08-02 18:51:32 -04002703 /*
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002704 * map->m_lblk == ee_block is handled by the zerouout
Aneesh Kumar K.Vd03856b2008-08-02 18:51:32 -04002705 * at the beginning.
2706 * Mark first half uninitialized.
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002707 * Mark second half initialized and zero out the
2708 * initialized extent
2709 */
2710 ex->ee_block = orig_ex.ee_block;
2711 ex->ee_len = cpu_to_le16(ee_len - allocated);
2712 ext4_ext_mark_uninitialized(ex);
2713 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
2714 ext4_ext_dirty(handle, inode, path + depth);
2715
2716 ex3 = &newex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002717 ex3->ee_block = cpu_to_le32(map->m_lblk);
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002718 ext4_ext_store_pblock(ex3, newblock);
2719 ex3->ee_len = cpu_to_le16(allocated);
Mingming Cao00314622009-09-28 15:49:08 -04002720 err = ext4_ext_insert_extent(handle, inode, path,
2721 ex3, 0);
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002722 if (err == -ENOSPC) {
2723 err = ext4_ext_zeroout(inode, &orig_ex);
2724 if (err)
2725 goto fix_extent_len;
2726 ex->ee_block = orig_ex.ee_block;
2727 ex->ee_len = orig_ex.ee_len;
2728 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
2729 ext4_ext_dirty(handle, inode, path + depth);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002730 /* blocks available from map->m_lblk */
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002731 return allocated;
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002732
2733 } else if (err)
2734 goto fix_extent_len;
2735
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002736 /*
2737 * We need to zero out the second half because
2738 * an fallocate request can update file size and
2739 * converting the second half to initialized extent
2740 * implies that we can leak some junk data to user
2741 * space.
2742 */
2743 err = ext4_ext_zeroout(inode, ex3);
2744 if (err) {
2745 /*
2746 * We should actually mark the
2747 * second half as uninit and return error
2748 * Insert would have changed the extent
2749 */
2750 depth = ext_depth(inode);
2751 ext4_ext_drop_refs(path);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002752 path = ext4_ext_find_extent(inode, map->m_lblk,
2753 path);
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002754 if (IS_ERR(path)) {
2755 err = PTR_ERR(path);
2756 return err;
2757 }
Aneesh Kumar K.Vd03856b2008-08-02 18:51:32 -04002758 /* get the second half extent details */
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002759 ex = path[depth].p_ext;
2760 err = ext4_ext_get_access(handle, inode,
2761 path + depth);
2762 if (err)
2763 return err;
2764 ext4_ext_mark_uninitialized(ex);
2765 ext4_ext_dirty(handle, inode, path + depth);
2766 return err;
2767 }
2768
2769 /* zeroed the second half */
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002770 return allocated;
2771 }
Amit Arora56055d32007-07-17 21:42:38 -04002772 ex3 = &newex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002773 ex3->ee_block = cpu_to_le32(map->m_lblk + map->m_len);
2774 ext4_ext_store_pblock(ex3, newblock + map->m_len);
2775 ex3->ee_len = cpu_to_le16(allocated - map->m_len);
Amit Arora56055d32007-07-17 21:42:38 -04002776 ext4_ext_mark_uninitialized(ex3);
Mingming Cao00314622009-09-28 15:49:08 -04002777 err = ext4_ext_insert_extent(handle, inode, path, ex3, 0);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002778 if (err == -ENOSPC && may_zeroout) {
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002779 err = ext4_ext_zeroout(inode, &orig_ex);
2780 if (err)
2781 goto fix_extent_len;
2782 /* update the extent length and mark as initialized */
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002783 ex->ee_block = orig_ex.ee_block;
2784 ex->ee_len = orig_ex.ee_len;
2785 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002786 ext4_ext_dirty(handle, inode, path + depth);
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002787 /* zeroed the full extent */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002788 /* blocks available from map->m_lblk */
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002789 return allocated;
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002790
2791 } else if (err)
2792 goto fix_extent_len;
Amit Arora56055d32007-07-17 21:42:38 -04002793 /*
2794 * The depth, and hence eh & ex might change
2795 * as part of the insert above.
2796 */
2797 newdepth = ext_depth(inode);
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002798 /*
Coly Li73ac36e2009-01-07 18:09:16 -08002799 * update the extent length after successful insert of the
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002800 * split extent
2801 */
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002802 ee_len -= ext4_ext_get_actual_len(ex3);
2803 orig_ex.ee_len = cpu_to_le16(ee_len);
2804 may_zeroout = ee_block + ee_len <= eof_block;
2805
Aneesh Kumar K.Vd03856b2008-08-02 18:51:32 -04002806 depth = newdepth;
2807 ext4_ext_drop_refs(path);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002808 path = ext4_ext_find_extent(inode, map->m_lblk, path);
Aneesh Kumar K.Vd03856b2008-08-02 18:51:32 -04002809 if (IS_ERR(path)) {
2810 err = PTR_ERR(path);
2811 goto out;
Amit Arora56055d32007-07-17 21:42:38 -04002812 }
Aneesh Kumar K.Vd03856b2008-08-02 18:51:32 -04002813 eh = path[depth].p_hdr;
2814 ex = path[depth].p_ext;
2815 if (ex2 != &newex)
2816 ex2 = ex;
2817
2818 err = ext4_ext_get_access(handle, inode, path + depth);
2819 if (err)
2820 goto out;
2821
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002822 allocated = map->m_len;
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002823
2824 /* If extent has less than EXT4_EXT_ZERO_LEN and we are trying
2825 * to insert a extent in the middle zerout directly
2826 * otherwise give the extent a chance to merge to left
2827 */
2828 if (le16_to_cpu(orig_ex.ee_len) <= EXT4_EXT_ZERO_LEN &&
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002829 map->m_lblk != ee_block && may_zeroout) {
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002830 err = ext4_ext_zeroout(inode, &orig_ex);
2831 if (err)
2832 goto fix_extent_len;
2833 /* update the extent length and mark as initialized */
2834 ex->ee_block = orig_ex.ee_block;
2835 ex->ee_len = orig_ex.ee_len;
2836 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
2837 ext4_ext_dirty(handle, inode, path + depth);
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002838 /* zero out the first half */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002839 /* blocks available from map->m_lblk */
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002840 return allocated;
Aneesh Kumar K.V3977c962008-04-17 10:38:59 -04002841 }
Amit Arora56055d32007-07-17 21:42:38 -04002842 }
2843 /*
2844 * If there was a change of depth as part of the
2845 * insertion of ex3 above, we need to update the length
2846 * of the ex1 extent again here
2847 */
2848 if (ex1 && ex1 != ex) {
2849 ex1 = ex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002850 ex1->ee_len = cpu_to_le16(map->m_lblk - ee_block);
Amit Arora56055d32007-07-17 21:42:38 -04002851 ext4_ext_mark_uninitialized(ex1);
2852 ex2 = &newex;
2853 }
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002854 /* ex2: map->m_lblk to map->m_lblk + maxblocks-1 : initialised */
2855 ex2->ee_block = cpu_to_le32(map->m_lblk);
Amit Arora56055d32007-07-17 21:42:38 -04002856 ext4_ext_store_pblock(ex2, newblock);
2857 ex2->ee_len = cpu_to_le16(allocated);
2858 if (ex2 != ex)
2859 goto insert;
Amit Arora56055d32007-07-17 21:42:38 -04002860 /*
2861 * New (initialized) extent starts from the first block
2862 * in the current extent. i.e., ex2 == ex
2863 * We have to see if it can be merged with the extent
2864 * on the left.
2865 */
2866 if (ex2 > EXT_FIRST_EXTENT(eh)) {
2867 /*
2868 * To merge left, pass "ex2 - 1" to try_to_merge(),
2869 * since it merges towards right _only_.
2870 */
2871 ret = ext4_ext_try_to_merge(inode, path, ex2 - 1);
2872 if (ret) {
2873 err = ext4_ext_correct_indexes(handle, inode, path);
2874 if (err)
2875 goto out;
2876 depth = ext_depth(inode);
2877 ex2--;
2878 }
2879 }
2880 /*
2881 * Try to Merge towards right. This might be required
2882 * only when the whole extent is being written to.
2883 * i.e. ex2 == ex and ex3 == NULL.
2884 */
2885 if (!ex3) {
2886 ret = ext4_ext_try_to_merge(inode, path, ex2);
2887 if (ret) {
2888 err = ext4_ext_correct_indexes(handle, inode, path);
2889 if (err)
2890 goto out;
2891 }
2892 }
2893 /* Mark modified extent as dirty */
2894 err = ext4_ext_dirty(handle, inode, path + depth);
2895 goto out;
2896insert:
Mingming Cao00314622009-09-28 15:49:08 -04002897 err = ext4_ext_insert_extent(handle, inode, path, &newex, 0);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002898 if (err == -ENOSPC && may_zeroout) {
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002899 err = ext4_ext_zeroout(inode, &orig_ex);
2900 if (err)
2901 goto fix_extent_len;
2902 /* update the extent length and mark as initialized */
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002903 ex->ee_block = orig_ex.ee_block;
2904 ex->ee_len = orig_ex.ee_len;
2905 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
Aneesh Kumar K.V95c38892008-04-17 10:38:59 -04002906 ext4_ext_dirty(handle, inode, path + depth);
Aneesh Kumar K.V161e7b72008-04-29 22:03:59 -04002907 /* zero out the first half */
2908 return allocated;
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002909 } else if (err)
2910 goto fix_extent_len;
Amit Arora56055d32007-07-17 21:42:38 -04002911out:
Mingming553f9002009-09-18 13:34:55 -04002912 ext4_ext_show_leaf(inode, path);
Amit Arora56055d32007-07-17 21:42:38 -04002913 return err ? err : allocated;
Aneesh Kumar K.V093a0882008-04-29 08:11:12 -04002914
2915fix_extent_len:
2916 ex->ee_block = orig_ex.ee_block;
2917 ex->ee_len = orig_ex.ee_len;
2918 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
2919 ext4_ext_mark_uninitialized(ex);
2920 ext4_ext_dirty(handle, inode, path + depth);
2921 return err;
Amit Arora56055d32007-07-17 21:42:38 -04002922}
2923
Aneesh Kumar K.Vc278bfe2008-01-28 23:58:27 -05002924/*
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002925 * This function is called by ext4_ext_map_blocks() from
Mingming Cao00314622009-09-28 15:49:08 -04002926 * ext4_get_blocks_dio_write() when DIO to write
2927 * to an uninitialized extent.
2928 *
2929 * Writing to an uninitized extent may result in splitting the uninitialized
2930 * extent into multiple /intialized unintialized extents (up to three)
2931 * There are three possibilities:
2932 * a> There is no split required: Entire extent should be uninitialized
2933 * b> Splits in two extents: Write is happening at either end of the extent
2934 * c> Splits in three extents: Somone is writing in middle of the extent
2935 *
2936 * One of more index blocks maybe needed if the extent tree grow after
2937 * the unintialized extent split. To prevent ENOSPC occur at the IO
2938 * complete, we need to split the uninitialized extent before DIO submit
Uwe Kleine-König421f91d2010-06-11 12:17:00 +02002939 * the IO. The uninitialized extent called at this time will be split
Mingming Cao00314622009-09-28 15:49:08 -04002940 * into three uninitialized extent(at most). After IO complete, the part
2941 * being filled will be convert to initialized by the end_io callback function
2942 * via ext4_convert_unwritten_extents().
Mingmingba230c32009-11-06 04:01:23 -05002943 *
2944 * Returns the size of uninitialized extent to be written on success.
Mingming Cao00314622009-09-28 15:49:08 -04002945 */
2946static int ext4_split_unwritten_extents(handle_t *handle,
2947 struct inode *inode,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002948 struct ext4_map_blocks *map,
Mingming Cao00314622009-09-28 15:49:08 -04002949 struct ext4_ext_path *path,
Mingming Cao00314622009-09-28 15:49:08 -04002950 int flags)
2951{
2952 struct ext4_extent *ex, newex, orig_ex;
2953 struct ext4_extent *ex1 = NULL;
2954 struct ext4_extent *ex2 = NULL;
2955 struct ext4_extent *ex3 = NULL;
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002956 ext4_lblk_t ee_block, eof_block;
Mingming Cao00314622009-09-28 15:49:08 -04002957 unsigned int allocated, ee_len, depth;
2958 ext4_fsblk_t newblock;
2959 int err = 0;
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002960 int may_zeroout;
Mingming Cao00314622009-09-28 15:49:08 -04002961
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002962 ext_debug("ext4_split_unwritten_extents: inode %lu, logical"
2963 "block %llu, max_blocks %u\n", inode->i_ino,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002964 (unsigned long long)map->m_lblk, map->m_len);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002965
2966 eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >>
2967 inode->i_sb->s_blocksize_bits;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002968 if (eof_block < map->m_lblk + map->m_len)
2969 eof_block = map->m_lblk + map->m_len;
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002970
Mingming Cao00314622009-09-28 15:49:08 -04002971 depth = ext_depth(inode);
Mingming Cao00314622009-09-28 15:49:08 -04002972 ex = path[depth].p_ext;
2973 ee_block = le32_to_cpu(ex->ee_block);
2974 ee_len = ext4_ext_get_actual_len(ex);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002975 allocated = ee_len - (map->m_lblk - ee_block);
2976 newblock = map->m_lblk - ee_block + ext_pblock(ex);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002977
Mingming Cao00314622009-09-28 15:49:08 -04002978 ex2 = ex;
2979 orig_ex.ee_block = ex->ee_block;
2980 orig_ex.ee_len = cpu_to_le16(ee_len);
2981 ext4_ext_store_pblock(&orig_ex, ext_pblock(ex));
2982
2983 /*
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04002984 * It is safe to convert extent to initialized via explicit
2985 * zeroout only if extent is fully insde i_size or new_size.
2986 */
2987 may_zeroout = ee_block + ee_len <= eof_block;
2988
2989 /*
Mingmingba230c32009-11-06 04:01:23 -05002990 * If the uninitialized extent begins at the same logical
2991 * block where the write begins, and the write completely
2992 * covers the extent, then we don't need to split it.
Mingming Cao00314622009-09-28 15:49:08 -04002993 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04002994 if ((map->m_lblk == ee_block) && (allocated <= map->m_len))
Mingmingba230c32009-11-06 04:01:23 -05002995 return allocated;
Mingming Cao00314622009-09-28 15:49:08 -04002996
2997 err = ext4_ext_get_access(handle, inode, path + depth);
2998 if (err)
2999 goto out;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003000 /* ex1: ee_block to map->m_lblk - 1 : uninitialized */
3001 if (map->m_lblk > ee_block) {
Mingming Cao00314622009-09-28 15:49:08 -04003002 ex1 = ex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003003 ex1->ee_len = cpu_to_le16(map->m_lblk - ee_block);
Mingming Cao00314622009-09-28 15:49:08 -04003004 ext4_ext_mark_uninitialized(ex1);
3005 ex2 = &newex;
3006 }
3007 /*
3008 * for sanity, update the length of the ex2 extent before
3009 * we insert ex3, if ex1 is NULL. This is to avoid temporary
3010 * overlap of blocks.
3011 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003012 if (!ex1 && allocated > map->m_len)
3013 ex2->ee_len = cpu_to_le16(map->m_len);
Mingming Cao00314622009-09-28 15:49:08 -04003014 /* ex3: to ee_block + ee_len : uninitialised */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003015 if (allocated > map->m_len) {
Mingming Cao00314622009-09-28 15:49:08 -04003016 unsigned int newdepth;
3017 ex3 = &newex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003018 ex3->ee_block = cpu_to_le32(map->m_lblk + map->m_len);
3019 ext4_ext_store_pblock(ex3, newblock + map->m_len);
3020 ex3->ee_len = cpu_to_le16(allocated - map->m_len);
Mingming Cao00314622009-09-28 15:49:08 -04003021 ext4_ext_mark_uninitialized(ex3);
3022 err = ext4_ext_insert_extent(handle, inode, path, ex3, flags);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04003023 if (err == -ENOSPC && may_zeroout) {
Mingming Cao00314622009-09-28 15:49:08 -04003024 err = ext4_ext_zeroout(inode, &orig_ex);
3025 if (err)
3026 goto fix_extent_len;
3027 /* update the extent length and mark as initialized */
3028 ex->ee_block = orig_ex.ee_block;
3029 ex->ee_len = orig_ex.ee_len;
3030 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
3031 ext4_ext_dirty(handle, inode, path + depth);
3032 /* zeroed the full extent */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003033 /* blocks available from map->m_lblk */
Mingming Cao00314622009-09-28 15:49:08 -04003034 return allocated;
3035
3036 } else if (err)
3037 goto fix_extent_len;
3038 /*
3039 * The depth, and hence eh & ex might change
3040 * as part of the insert above.
3041 */
3042 newdepth = ext_depth(inode);
3043 /*
3044 * update the extent length after successful insert of the
3045 * split extent
3046 */
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04003047 ee_len -= ext4_ext_get_actual_len(ex3);
3048 orig_ex.ee_len = cpu_to_le16(ee_len);
3049 may_zeroout = ee_block + ee_len <= eof_block;
3050
Mingming Cao00314622009-09-28 15:49:08 -04003051 depth = newdepth;
3052 ext4_ext_drop_refs(path);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003053 path = ext4_ext_find_extent(inode, map->m_lblk, path);
Mingming Cao00314622009-09-28 15:49:08 -04003054 if (IS_ERR(path)) {
3055 err = PTR_ERR(path);
3056 goto out;
3057 }
Mingming Cao00314622009-09-28 15:49:08 -04003058 ex = path[depth].p_ext;
3059 if (ex2 != &newex)
3060 ex2 = ex;
3061
3062 err = ext4_ext_get_access(handle, inode, path + depth);
3063 if (err)
3064 goto out;
3065
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003066 allocated = map->m_len;
Mingming Cao00314622009-09-28 15:49:08 -04003067 }
3068 /*
3069 * If there was a change of depth as part of the
3070 * insertion of ex3 above, we need to update the length
3071 * of the ex1 extent again here
3072 */
3073 if (ex1 && ex1 != ex) {
3074 ex1 = ex;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003075 ex1->ee_len = cpu_to_le16(map->m_lblk - ee_block);
Mingming Cao00314622009-09-28 15:49:08 -04003076 ext4_ext_mark_uninitialized(ex1);
3077 ex2 = &newex;
3078 }
3079 /*
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003080 * ex2: map->m_lblk to map->m_lblk + map->m_len-1 : to be written
3081 * using direct I/O, uninitialised still.
Mingming Cao00314622009-09-28 15:49:08 -04003082 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003083 ex2->ee_block = cpu_to_le32(map->m_lblk);
Mingming Cao00314622009-09-28 15:49:08 -04003084 ext4_ext_store_pblock(ex2, newblock);
3085 ex2->ee_len = cpu_to_le16(allocated);
3086 ext4_ext_mark_uninitialized(ex2);
3087 if (ex2 != ex)
3088 goto insert;
3089 /* Mark modified extent as dirty */
3090 err = ext4_ext_dirty(handle, inode, path + depth);
3091 ext_debug("out here\n");
3092 goto out;
3093insert:
3094 err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);
Dmitry Monakhov21ca0872010-05-16 06:00:00 -04003095 if (err == -ENOSPC && may_zeroout) {
Mingming Cao00314622009-09-28 15:49:08 -04003096 err = ext4_ext_zeroout(inode, &orig_ex);
3097 if (err)
3098 goto fix_extent_len;
3099 /* update the extent length and mark as initialized */
3100 ex->ee_block = orig_ex.ee_block;
3101 ex->ee_len = orig_ex.ee_len;
3102 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
3103 ext4_ext_dirty(handle, inode, path + depth);
3104 /* zero out the first half */
3105 return allocated;
3106 } else if (err)
3107 goto fix_extent_len;
3108out:
3109 ext4_ext_show_leaf(inode, path);
3110 return err ? err : allocated;
3111
3112fix_extent_len:
3113 ex->ee_block = orig_ex.ee_block;
3114 ex->ee_len = orig_ex.ee_len;
3115 ext4_ext_store_pblock(ex, ext_pblock(&orig_ex));
3116 ext4_ext_mark_uninitialized(ex);
3117 ext4_ext_dirty(handle, inode, path + depth);
3118 return err;
3119}
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003120static int ext4_convert_unwritten_extents_endio(handle_t *handle,
Mingming Cao00314622009-09-28 15:49:08 -04003121 struct inode *inode,
3122 struct ext4_ext_path *path)
3123{
3124 struct ext4_extent *ex;
3125 struct ext4_extent_header *eh;
3126 int depth;
3127 int err = 0;
3128 int ret = 0;
3129
3130 depth = ext_depth(inode);
3131 eh = path[depth].p_hdr;
3132 ex = path[depth].p_ext;
3133
3134 err = ext4_ext_get_access(handle, inode, path + depth);
3135 if (err)
3136 goto out;
3137 /* first mark the extent as initialized */
3138 ext4_ext_mark_initialized(ex);
3139
3140 /*
3141 * We have to see if it can be merged with the extent
3142 * on the left.
3143 */
3144 if (ex > EXT_FIRST_EXTENT(eh)) {
3145 /*
3146 * To merge left, pass "ex - 1" to try_to_merge(),
3147 * since it merges towards right _only_.
3148 */
3149 ret = ext4_ext_try_to_merge(inode, path, ex - 1);
3150 if (ret) {
3151 err = ext4_ext_correct_indexes(handle, inode, path);
3152 if (err)
3153 goto out;
3154 depth = ext_depth(inode);
3155 ex--;
3156 }
3157 }
3158 /*
3159 * Try to Merge towards right.
3160 */
3161 ret = ext4_ext_try_to_merge(inode, path, ex);
3162 if (ret) {
3163 err = ext4_ext_correct_indexes(handle, inode, path);
3164 if (err)
3165 goto out;
3166 depth = ext_depth(inode);
3167 }
3168 /* Mark modified extent as dirty */
3169 err = ext4_ext_dirty(handle, inode, path + depth);
3170out:
3171 ext4_ext_show_leaf(inode, path);
3172 return err;
3173}
3174
Aneesh Kumar K.V515f41c2009-12-29 23:39:06 -05003175static void unmap_underlying_metadata_blocks(struct block_device *bdev,
3176 sector_t block, int count)
3177{
3178 int i;
3179 for (i = 0; i < count; i++)
3180 unmap_underlying_metadata(bdev, block + i);
3181}
3182
Theodore Ts'o58590b02010-10-27 21:23:12 -04003183/*
3184 * Handle EOFBLOCKS_FL flag, clearing it if necessary
3185 */
3186static int check_eofblocks_fl(handle_t *handle, struct inode *inode,
3187 struct ext4_map_blocks *map,
3188 struct ext4_ext_path *path,
3189 unsigned int len)
3190{
3191 int i, depth;
3192 struct ext4_extent_header *eh;
3193 struct ext4_extent *ex, *last_ex;
3194
3195 if (!ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS))
3196 return 0;
3197
3198 depth = ext_depth(inode);
3199 eh = path[depth].p_hdr;
3200 ex = path[depth].p_ext;
3201
3202 if (unlikely(!eh->eh_entries)) {
3203 EXT4_ERROR_INODE(inode, "eh->eh_entries == 0 and "
3204 "EOFBLOCKS_FL set");
3205 return -EIO;
3206 }
3207 last_ex = EXT_LAST_EXTENT(eh);
3208 /*
3209 * We should clear the EOFBLOCKS_FL flag if we are writing the
3210 * last block in the last extent in the file. We test this by
3211 * first checking to see if the caller to
3212 * ext4_ext_get_blocks() was interested in the last block (or
3213 * a block beyond the last block) in the current extent. If
3214 * this turns out to be false, we can bail out from this
3215 * function immediately.
3216 */
3217 if (map->m_lblk + len < le32_to_cpu(last_ex->ee_block) +
3218 ext4_ext_get_actual_len(last_ex))
3219 return 0;
3220 /*
3221 * If the caller does appear to be planning to write at or
3222 * beyond the end of the current extent, we then test to see
3223 * if the current extent is the last extent in the file, by
3224 * checking to make sure it was reached via the rightmost node
3225 * at each level of the tree.
3226 */
3227 for (i = depth-1; i >= 0; i--)
3228 if (path[i].p_idx != EXT_LAST_INDEX(path[i].p_hdr))
3229 return 0;
3230 ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
3231 return ext4_mark_inode_dirty(handle, inode);
3232}
3233
Mingming Cao00314622009-09-28 15:49:08 -04003234static int
3235ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003236 struct ext4_map_blocks *map,
Mingming Cao00314622009-09-28 15:49:08 -04003237 struct ext4_ext_path *path, int flags,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003238 unsigned int allocated, ext4_fsblk_t newblock)
Mingming Cao00314622009-09-28 15:49:08 -04003239{
3240 int ret = 0;
3241 int err = 0;
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003242 ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio;
Mingming Cao00314622009-09-28 15:49:08 -04003243
3244 ext_debug("ext4_ext_handle_uninitialized_extents: inode %lu, logical"
3245 "block %llu, max_blocks %u, flags %d, allocated %u",
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003246 inode->i_ino, (unsigned long long)map->m_lblk, map->m_len,
Mingming Cao00314622009-09-28 15:49:08 -04003247 flags, allocated);
3248 ext4_ext_show_leaf(inode, path);
3249
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003250 /* get_block() before submit the IO, split the extent */
Jiaying Zhang744692d2010-03-04 16:14:02 -05003251 if ((flags & EXT4_GET_BLOCKS_PRE_IO)) {
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003252 ret = ext4_split_unwritten_extents(handle, inode, map,
3253 path, flags);
Mingming5f524952009-11-10 10:48:04 -05003254 /*
3255 * Flag the inode(non aio case) or end_io struct (aio case)
3256 * that this IO needs to convertion to written when IO is
3257 * completed
3258 */
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003259 if (io)
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003260 io->flag = EXT4_IO_UNWRITTEN;
Mingming5f524952009-11-10 10:48:04 -05003261 else
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05003262 ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
Jiaying Zhang744692d2010-03-04 16:14:02 -05003263 if (ext4_should_dioread_nolock(inode))
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003264 map->m_flags |= EXT4_MAP_UNINIT;
Mingming Cao00314622009-09-28 15:49:08 -04003265 goto out;
3266 }
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003267 /* IO end_io complete, convert the filled extent to written */
Jiaying Zhang744692d2010-03-04 16:14:02 -05003268 if ((flags & EXT4_GET_BLOCKS_CONVERT)) {
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003269 ret = ext4_convert_unwritten_extents_endio(handle, inode,
Mingming Cao00314622009-09-28 15:49:08 -04003270 path);
Theodore Ts'o58590b02010-10-27 21:23:12 -04003271 if (ret >= 0) {
Jan Karab436b9b2009-12-08 23:51:10 -05003272 ext4_update_inode_fsync_trans(handle, inode, 1);
Theodore Ts'o58590b02010-10-27 21:23:12 -04003273 err = check_eofblocks_fl(handle, inode, map, path,
3274 map->m_len);
3275 } else
3276 err = ret;
Mingming Cao00314622009-09-28 15:49:08 -04003277 goto out2;
3278 }
3279 /* buffered IO case */
3280 /*
3281 * repeat fallocate creation request
3282 * we already have an unwritten extent
3283 */
3284 if (flags & EXT4_GET_BLOCKS_UNINIT_EXT)
3285 goto map_out;
3286
3287 /* buffered READ or buffered write_begin() lookup */
3288 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
3289 /*
3290 * We have blocks reserved already. We
3291 * return allocated blocks so that delalloc
3292 * won't do block reservation for us. But
3293 * the buffer head will be unmapped so that
3294 * a read from the block returns 0s.
3295 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003296 map->m_flags |= EXT4_MAP_UNWRITTEN;
Mingming Cao00314622009-09-28 15:49:08 -04003297 goto out1;
3298 }
3299
3300 /* buffered write, writepage time, convert*/
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003301 ret = ext4_ext_convert_to_initialized(handle, inode, map, path);
Theodore Ts'o58590b02010-10-27 21:23:12 -04003302 if (ret >= 0) {
Jan Karab436b9b2009-12-08 23:51:10 -05003303 ext4_update_inode_fsync_trans(handle, inode, 1);
Theodore Ts'o58590b02010-10-27 21:23:12 -04003304 err = check_eofblocks_fl(handle, inode, map, path, map->m_len);
3305 if (err < 0)
3306 goto out2;
3307 }
3308
Mingming Cao00314622009-09-28 15:49:08 -04003309out:
3310 if (ret <= 0) {
3311 err = ret;
3312 goto out2;
3313 } else
3314 allocated = ret;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003315 map->m_flags |= EXT4_MAP_NEW;
Aneesh Kumar K.V515f41c2009-12-29 23:39:06 -05003316 /*
3317 * if we allocated more blocks than requested
3318 * we need to make sure we unmap the extra block
3319 * allocated. The actual needed block will get
3320 * unmapped later when we find the buffer_head marked
3321 * new.
3322 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003323 if (allocated > map->m_len) {
Aneesh Kumar K.V515f41c2009-12-29 23:39:06 -05003324 unmap_underlying_metadata_blocks(inode->i_sb->s_bdev,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003325 newblock + map->m_len,
3326 allocated - map->m_len);
3327 allocated = map->m_len;
Aneesh Kumar K.V515f41c2009-12-29 23:39:06 -05003328 }
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -05003329
3330 /*
3331 * If we have done fallocate with the offset that is already
3332 * delayed allocated, we would have block reservation
3333 * and quota reservation done in the delayed write path.
3334 * But fallocate would have already updated quota and block
3335 * count for this offset. So cancel these reservation
3336 */
Aneesh Kumar K.V1296cc82010-01-15 01:27:59 -05003337 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -05003338 ext4_da_update_reserve_space(inode, allocated, 0);
3339
Mingming Cao00314622009-09-28 15:49:08 -04003340map_out:
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003341 map->m_flags |= EXT4_MAP_MAPPED;
Mingming Cao00314622009-09-28 15:49:08 -04003342out1:
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003343 if (allocated > map->m_len)
3344 allocated = map->m_len;
Mingming Cao00314622009-09-28 15:49:08 -04003345 ext4_ext_show_leaf(inode, path);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003346 map->m_pblk = newblock;
3347 map->m_len = allocated;
Mingming Cao00314622009-09-28 15:49:08 -04003348out2:
3349 if (path) {
3350 ext4_ext_drop_refs(path);
3351 kfree(path);
3352 }
3353 return err ? err : allocated;
3354}
Theodore Ts'o58590b02010-10-27 21:23:12 -04003355
Mingming Cao00314622009-09-28 15:49:08 -04003356/*
Mingming Caof5ab0d12008-02-25 15:29:55 -05003357 * Block allocation/map/preallocation routine for extents based files
3358 *
3359 *
Aneesh Kumar K.Vc278bfe2008-01-28 23:58:27 -05003360 * Need to be called with
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -05003361 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
3362 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
Mingming Caof5ab0d12008-02-25 15:29:55 -05003363 *
3364 * return > 0, number of of blocks already mapped/allocated
3365 * if create == 0 and these are pre-allocated blocks
3366 * buffer head is unmapped
3367 * otherwise blocks are mapped
3368 *
3369 * return = 0, if plain look up failed (blocks have not been allocated)
3370 * buffer head is unmapped
3371 *
3372 * return < 0, error case.
Aneesh Kumar K.Vc278bfe2008-01-28 23:58:27 -05003373 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003374int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
3375 struct ext4_map_blocks *map, int flags)
Alex Tomasa86c6182006-10-11 01:21:03 -07003376{
3377 struct ext4_ext_path *path = NULL;
Amit Arora56055d32007-07-17 21:42:38 -04003378 struct ext4_extent_header *eh;
Theodore Ts'o58590b02010-10-27 21:23:12 -04003379 struct ext4_extent newex, *ex;
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003380 ext4_fsblk_t newblock;
Theodore Ts'o58590b02010-10-27 21:23:12 -04003381 int err = 0, depth, ret, cache_type;
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003382 unsigned int allocated = 0;
Alex Tomasc9de5602008-01-29 00:19:52 -05003383 struct ext4_allocation_request ar;
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003384 ext4_io_end_t *io = EXT4_I(inode)->cur_aio_dio;
Alex Tomasa86c6182006-10-11 01:21:03 -07003385
Mingming84fe3be2009-09-01 08:44:37 -04003386 ext_debug("blocks %u/%u requested for inode %lu\n",
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003387 map->m_lblk, map->m_len, inode->i_ino);
Alex Tomasa86c6182006-10-11 01:21:03 -07003388
3389 /* check in cache */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003390 cache_type = ext4_ext_in_cache(inode, map->m_lblk, &newex);
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003391 if (cache_type) {
3392 if (cache_type == EXT4_EXT_CACHE_GAP) {
Theodore Ts'oc2177052009-05-14 00:58:52 -04003393 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
Amit Arora56055d32007-07-17 21:42:38 -04003394 /*
3395 * block isn't allocated yet and
3396 * user doesn't want to allocate it
3397 */
Alex Tomasa86c6182006-10-11 01:21:03 -07003398 goto out2;
3399 }
3400 /* we should allocate requested block */
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003401 } else if (cache_type == EXT4_EXT_CACHE_EXTENT) {
Alex Tomasa86c6182006-10-11 01:21:03 -07003402 /* block is already allocated */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003403 newblock = map->m_lblk
Dave Kleikamp8c55e202007-05-24 13:04:54 -04003404 - le32_to_cpu(newex.ee_block)
3405 + ext_pblock(&newex);
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003406 /* number of remaining blocks in the extent */
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05003407 allocated = ext4_ext_get_actual_len(&newex) -
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003408 (map->m_lblk - le32_to_cpu(newex.ee_block));
Alex Tomasa86c6182006-10-11 01:21:03 -07003409 goto out;
3410 } else {
3411 BUG();
3412 }
3413 }
3414
3415 /* find extent for this block */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003416 path = ext4_ext_find_extent(inode, map->m_lblk, NULL);
Alex Tomasa86c6182006-10-11 01:21:03 -07003417 if (IS_ERR(path)) {
3418 err = PTR_ERR(path);
3419 path = NULL;
3420 goto out2;
3421 }
3422
3423 depth = ext_depth(inode);
3424
3425 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003426 * consistent leaf must not be empty;
3427 * this situation is possible, though, _during_ tree modification;
Alex Tomasa86c6182006-10-11 01:21:03 -07003428 * this is why assert can't be put in ext4_ext_find_extent()
3429 */
Frank Mayhar273df552010-03-02 11:46:09 -05003430 if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
3431 EXT4_ERROR_INODE(inode, "bad extent address "
Theodore Ts'of70f3622010-05-16 23:00:00 -04003432 "lblock: %lu, depth: %d pblock %lld",
3433 (unsigned long) map->m_lblk, depth,
3434 path[depth].p_block);
Surbhi Palande034fb4c2009-12-14 09:53:52 -05003435 err = -EIO;
3436 goto out2;
3437 }
Amit Arora56055d32007-07-17 21:42:38 -04003438 eh = path[depth].p_hdr;
Alex Tomasa86c6182006-10-11 01:21:03 -07003439
Avantika Mathur7e028972006-12-06 20:41:33 -08003440 ex = path[depth].p_ext;
3441 if (ex) {
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05003442 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
Alex Tomasf65e6fb2006-10-11 01:21:05 -07003443 ext4_fsblk_t ee_start = ext_pblock(ex);
Amit Aroraa2df2a62007-07-17 21:42:41 -04003444 unsigned short ee_len;
Suparna Bhattacharya471d4012006-10-11 01:21:06 -07003445
3446 /*
Suparna Bhattacharya471d4012006-10-11 01:21:06 -07003447 * Uninitialized extents are treated as holes, except that
Amit Arora56055d32007-07-17 21:42:38 -04003448 * we split out initialized portions during a write.
Suparna Bhattacharya471d4012006-10-11 01:21:06 -07003449 */
Amit Aroraa2df2a62007-07-17 21:42:41 -04003450 ee_len = ext4_ext_get_actual_len(ex);
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003451 /* if found extent covers block, simply return it */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003452 if (in_range(map->m_lblk, ee_block, ee_len)) {
3453 newblock = map->m_lblk - ee_block + ee_start;
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003454 /* number of remaining blocks in the extent */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003455 allocated = ee_len - (map->m_lblk - ee_block);
3456 ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk,
3457 ee_block, ee_len, newblock);
Amit Arora56055d32007-07-17 21:42:38 -04003458
Amit Aroraa2df2a62007-07-17 21:42:41 -04003459 /* Do not put uninitialized extent in the cache */
Amit Arora56055d32007-07-17 21:42:38 -04003460 if (!ext4_ext_is_uninitialized(ex)) {
Amit Aroraa2df2a62007-07-17 21:42:41 -04003461 ext4_ext_put_in_cache(inode, ee_block,
3462 ee_len, ee_start,
3463 EXT4_EXT_CACHE_EXTENT);
Amit Arora56055d32007-07-17 21:42:38 -04003464 goto out;
3465 }
Mingming Cao00314622009-09-28 15:49:08 -04003466 ret = ext4_ext_handle_uninitialized_extents(handle,
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003467 inode, map, path, flags, allocated,
3468 newblock);
Mingming Cao00314622009-09-28 15:49:08 -04003469 return ret;
Alex Tomasa86c6182006-10-11 01:21:03 -07003470 }
3471 }
3472
3473 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003474 * requested block isn't allocated yet;
Alex Tomasa86c6182006-10-11 01:21:03 -07003475 * we couldn't try to create block if create flag is zero
3476 */
Theodore Ts'oc2177052009-05-14 00:58:52 -04003477 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
Amit Arora56055d32007-07-17 21:42:38 -04003478 /*
3479 * put just found gap into cache to speed up
3480 * subsequent requests
3481 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003482 ext4_ext_put_gap_in_cache(inode, path, map->m_lblk);
Alex Tomasa86c6182006-10-11 01:21:03 -07003483 goto out2;
3484 }
3485 /*
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -04003486 * Okay, we need to do block allocation.
Andrew Morton63f57932006-10-11 01:21:24 -07003487 */
Alex Tomasa86c6182006-10-11 01:21:03 -07003488
Alex Tomasc9de5602008-01-29 00:19:52 -05003489 /* find neighbour allocated blocks */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003490 ar.lleft = map->m_lblk;
Alex Tomasc9de5602008-01-29 00:19:52 -05003491 err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
3492 if (err)
3493 goto out2;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003494 ar.lright = map->m_lblk;
Alex Tomasc9de5602008-01-29 00:19:52 -05003495 err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright);
3496 if (err)
3497 goto out2;
Amit Arora25d14f92007-05-24 13:04:13 -04003498
Amit Arora749269f2007-07-18 09:02:56 -04003499 /*
3500 * See if request is beyond maximum number of blocks we can have in
3501 * a single extent. For an initialized extent this limit is
3502 * EXT_INIT_MAX_LEN and for an uninitialized extent this limit is
3503 * EXT_UNINIT_MAX_LEN.
3504 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003505 if (map->m_len > EXT_INIT_MAX_LEN &&
Theodore Ts'oc2177052009-05-14 00:58:52 -04003506 !(flags & EXT4_GET_BLOCKS_UNINIT_EXT))
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003507 map->m_len = EXT_INIT_MAX_LEN;
3508 else if (map->m_len > EXT_UNINIT_MAX_LEN &&
Theodore Ts'oc2177052009-05-14 00:58:52 -04003509 (flags & EXT4_GET_BLOCKS_UNINIT_EXT))
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003510 map->m_len = EXT_UNINIT_MAX_LEN;
Amit Arora749269f2007-07-18 09:02:56 -04003511
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003512 /* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */
3513 newex.ee_block = cpu_to_le32(map->m_lblk);
3514 newex.ee_len = cpu_to_le16(map->m_len);
Amit Arora25d14f92007-05-24 13:04:13 -04003515 err = ext4_ext_check_overlap(inode, &newex, path);
3516 if (err)
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05003517 allocated = ext4_ext_get_actual_len(&newex);
Amit Arora25d14f92007-05-24 13:04:13 -04003518 else
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003519 allocated = map->m_len;
Alex Tomasc9de5602008-01-29 00:19:52 -05003520
3521 /* allocate new block */
3522 ar.inode = inode;
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003523 ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);
3524 ar.logical = map->m_lblk;
Alex Tomasc9de5602008-01-29 00:19:52 -05003525 ar.len = allocated;
3526 if (S_ISREG(inode->i_mode))
3527 ar.flags = EXT4_MB_HINT_DATA;
3528 else
3529 /* disable in-core preallocation for non-regular files */
3530 ar.flags = 0;
3531 newblock = ext4_mb_new_blocks(handle, &ar, &err);
Alex Tomasa86c6182006-10-11 01:21:03 -07003532 if (!newblock)
3533 goto out2;
Mingming84fe3be2009-09-01 08:44:37 -04003534 ext_debug("allocate new block: goal %llu, found %llu/%u\n",
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003535 ar.goal, newblock, allocated);
Alex Tomasa86c6182006-10-11 01:21:03 -07003536
3537 /* try to insert new extent into found leaf and return */
Alex Tomasf65e6fb2006-10-11 01:21:05 -07003538 ext4_ext_store_pblock(&newex, newblock);
Alex Tomasc9de5602008-01-29 00:19:52 -05003539 newex.ee_len = cpu_to_le16(ar.len);
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003540 /* Mark uninitialized */
3541 if (flags & EXT4_GET_BLOCKS_UNINIT_EXT){
Amit Aroraa2df2a62007-07-17 21:42:41 -04003542 ext4_ext_mark_uninitialized(&newex);
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003543 /*
Jiaying Zhang744692d2010-03-04 16:14:02 -05003544 * io_end structure was created for every IO write to an
3545 * uninitialized extent. To avoid unecessary conversion,
3546 * here we flag the IO that really needs the conversion.
Mingming5f524952009-11-10 10:48:04 -05003547 * For non asycn direct IO case, flag the inode state
3548 * that we need to perform convertion when IO is done.
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003549 */
Jiaying Zhang744692d2010-03-04 16:14:02 -05003550 if ((flags & EXT4_GET_BLOCKS_PRE_IO)) {
Mingming5f524952009-11-10 10:48:04 -05003551 if (io)
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003552 io->flag = EXT4_IO_UNWRITTEN;
Mingming5f524952009-11-10 10:48:04 -05003553 else
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05003554 ext4_set_inode_state(inode,
3555 EXT4_STATE_DIO_UNWRITTEN);
Mingming5f524952009-11-10 10:48:04 -05003556 }
Jiaying Zhang744692d2010-03-04 16:14:02 -05003557 if (ext4_should_dioread_nolock(inode))
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003558 map->m_flags |= EXT4_MAP_UNINIT;
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003559 }
Jiaying Zhangc8d46e42010-02-24 09:52:53 -05003560
Theodore Ts'o58590b02010-10-27 21:23:12 -04003561 err = check_eofblocks_fl(handle, inode, map, path, ar.len);
3562 if (err)
3563 goto out2;
3564
Mingming Cao00314622009-09-28 15:49:08 -04003565 err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);
Alex Tomas315054f2007-05-24 13:04:25 -04003566 if (err) {
3567 /* free data blocks we just allocated */
Alex Tomasc9de5602008-01-29 00:19:52 -05003568 /* not a good idea to call discard here directly,
3569 * but otherwise we'd need to call it every free() */
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -04003570 ext4_discard_preallocations(inode);
Theodore Ts'oe6362602009-11-23 07:17:05 -05003571 ext4_free_blocks(handle, inode, 0, ext_pblock(&newex),
3572 ext4_ext_get_actual_len(&newex), 0);
Alex Tomasa86c6182006-10-11 01:21:03 -07003573 goto out2;
Alex Tomas315054f2007-05-24 13:04:25 -04003574 }
Alex Tomasa86c6182006-10-11 01:21:03 -07003575
Alex Tomasa86c6182006-10-11 01:21:03 -07003576 /* previous routine could use block we allocated */
Alex Tomasf65e6fb2006-10-11 01:21:05 -07003577 newblock = ext_pblock(&newex);
Aneesh Kumar K.Vb939e372008-01-28 23:58:27 -05003578 allocated = ext4_ext_get_actual_len(&newex);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003579 if (allocated > map->m_len)
3580 allocated = map->m_len;
3581 map->m_flags |= EXT4_MAP_NEW;
Alex Tomasa86c6182006-10-11 01:21:03 -07003582
Jan Karab436b9b2009-12-08 23:51:10 -05003583 /*
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -05003584 * Update reserved blocks/metadata blocks after successful
3585 * block allocation which had been deferred till now.
3586 */
Aneesh Kumar K.V1296cc82010-01-15 01:27:59 -05003587 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -05003588 ext4_da_update_reserve_space(inode, allocated, 1);
3589
3590 /*
Jan Karab436b9b2009-12-08 23:51:10 -05003591 * Cache the extent and update transaction to commit on fdatasync only
3592 * when it is _not_ an uninitialized extent.
3593 */
3594 if ((flags & EXT4_GET_BLOCKS_UNINIT_EXT) == 0) {
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003595 ext4_ext_put_in_cache(inode, map->m_lblk, allocated, newblock,
Amit Aroraa2df2a62007-07-17 21:42:41 -04003596 EXT4_EXT_CACHE_EXTENT);
Jan Karab436b9b2009-12-08 23:51:10 -05003597 ext4_update_inode_fsync_trans(handle, inode, 1);
3598 } else
3599 ext4_update_inode_fsync_trans(handle, inode, 0);
Alex Tomasa86c6182006-10-11 01:21:03 -07003600out:
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003601 if (allocated > map->m_len)
3602 allocated = map->m_len;
Alex Tomasa86c6182006-10-11 01:21:03 -07003603 ext4_ext_show_leaf(inode, path);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003604 map->m_flags |= EXT4_MAP_MAPPED;
3605 map->m_pblk = newblock;
3606 map->m_len = allocated;
Alex Tomasa86c6182006-10-11 01:21:03 -07003607out2:
3608 if (path) {
3609 ext4_ext_drop_refs(path);
3610 kfree(path);
3611 }
Alex Tomasa86c6182006-10-11 01:21:03 -07003612 return err ? err : allocated;
3613}
3614
Jan Karacf108bc2008-07-11 19:27:31 -04003615void ext4_ext_truncate(struct inode *inode)
Alex Tomasa86c6182006-10-11 01:21:03 -07003616{
3617 struct address_space *mapping = inode->i_mapping;
3618 struct super_block *sb = inode->i_sb;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05003619 ext4_lblk_t last_block;
Alex Tomasa86c6182006-10-11 01:21:03 -07003620 handle_t *handle;
3621 int err = 0;
3622
3623 /*
3624 * probably first extent we're gonna free will be last in block
3625 */
Mingming Caof3bd1f32008-08-19 22:16:03 -04003626 err = ext4_writepage_trans_blocks(inode);
Alex Tomasa86c6182006-10-11 01:21:03 -07003627 handle = ext4_journal_start(inode, err);
Jan Karacf108bc2008-07-11 19:27:31 -04003628 if (IS_ERR(handle))
Alex Tomasa86c6182006-10-11 01:21:03 -07003629 return;
Alex Tomasa86c6182006-10-11 01:21:03 -07003630
Jan Karacf108bc2008-07-11 19:27:31 -04003631 if (inode->i_size & (sb->s_blocksize - 1))
3632 ext4_block_truncate_page(handle, mapping, inode->i_size);
Alex Tomasa86c6182006-10-11 01:21:03 -07003633
Jan Kara9ddfc3d2008-07-11 19:27:31 -04003634 if (ext4_orphan_add(handle, inode))
3635 goto out_stop;
3636
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -05003637 down_write(&EXT4_I(inode)->i_data_sem);
Alex Tomasa86c6182006-10-11 01:21:03 -07003638 ext4_ext_invalidate_cache(inode);
3639
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -04003640 ext4_discard_preallocations(inode);
Alex Tomasc9de5602008-01-29 00:19:52 -05003641
Alex Tomasa86c6182006-10-11 01:21:03 -07003642 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003643 * TODO: optimization is possible here.
3644 * Probably we need not scan at all,
3645 * because page truncation is enough.
Alex Tomasa86c6182006-10-11 01:21:03 -07003646 */
Alex Tomasa86c6182006-10-11 01:21:03 -07003647
3648 /* we have to know where to truncate from in crash case */
3649 EXT4_I(inode)->i_disksize = inode->i_size;
3650 ext4_mark_inode_dirty(handle, inode);
3651
3652 last_block = (inode->i_size + sb->s_blocksize - 1)
3653 >> EXT4_BLOCK_SIZE_BITS(sb);
3654 err = ext4_ext_remove_space(inode, last_block);
3655
3656 /* In a multi-transaction truncate, we only make the final
Amit Arora56055d32007-07-17 21:42:38 -04003657 * transaction synchronous.
3658 */
Alex Tomasa86c6182006-10-11 01:21:03 -07003659 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -05003660 ext4_handle_sync(handle);
Alex Tomasa86c6182006-10-11 01:21:03 -07003661
3662out_stop:
Jan Kara9ddfc3d2008-07-11 19:27:31 -04003663 up_write(&EXT4_I(inode)->i_data_sem);
Alex Tomasa86c6182006-10-11 01:21:03 -07003664 /*
Randy Dunlapd0d856e2006-10-11 01:21:07 -07003665 * If this was a simple ftruncate() and the file will remain alive,
Alex Tomasa86c6182006-10-11 01:21:03 -07003666 * then we need to clear up the orphan record which we created above.
3667 * However, if this was a real unlink then we were called by
3668 * ext4_delete_inode(), and we allow that function to clean up the
3669 * orphan info for us.
3670 */
3671 if (inode->i_nlink)
3672 ext4_orphan_del(handle, inode);
3673
Solofo Ramangalahyef737722008-04-29 22:00:41 -04003674 inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
3675 ext4_mark_inode_dirty(handle, inode);
Alex Tomasa86c6182006-10-11 01:21:03 -07003676 ext4_journal_stop(handle);
3677}
3678
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003679static void ext4_falloc_update_inode(struct inode *inode,
3680 int mode, loff_t new_size, int update_ctime)
3681{
3682 struct timespec now;
3683
3684 if (update_ctime) {
3685 now = current_fs_time(inode->i_sb);
3686 if (!timespec_equal(&inode->i_ctime, &now))
3687 inode->i_ctime = now;
3688 }
3689 /*
3690 * Update only when preallocation was requested beyond
3691 * the file size.
3692 */
Aneesh Kumar K.Vcf17fea2008-09-13 13:06:18 -04003693 if (!(mode & FALLOC_FL_KEEP_SIZE)) {
3694 if (new_size > i_size_read(inode))
3695 i_size_write(inode, new_size);
3696 if (new_size > EXT4_I(inode)->i_disksize)
3697 ext4_update_i_disksize(inode, new_size);
Jiaying Zhangc8d46e42010-02-24 09:52:53 -05003698 } else {
3699 /*
3700 * Mark that we allocate beyond EOF so the subsequent truncate
3701 * can proceed even if the new size is the same as i_size.
3702 */
3703 if (new_size > i_size_read(inode))
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04003704 ext4_set_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003705 }
3706
3707}
3708
Amit Aroraa2df2a62007-07-17 21:42:41 -04003709/*
3710 * preallocate space for a file. This implements ext4's fallocate inode
3711 * operation, which gets called from sys_fallocate system call.
3712 * For block-mapped files, posix_fallocate should fall back to the method
3713 * of writing zeroes to the required new blocks (the same behavior which is
3714 * expected for file systems which do not support fallocate() system call).
3715 */
3716long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len)
3717{
3718 handle_t *handle;
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003719 loff_t new_size;
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003720 unsigned int max_blocks;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003721 int ret = 0;
3722 int ret2 = 0;
3723 int retries = 0;
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003724 struct ext4_map_blocks map;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003725 unsigned int credits, blkbits = inode->i_blkbits;
3726
3727 /*
3728 * currently supporting (pre)allocate mode for extent-based
3729 * files _only_
3730 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04003731 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Amit Aroraa2df2a62007-07-17 21:42:41 -04003732 return -EOPNOTSUPP;
3733
3734 /* preallocation to directories is currently not supported */
3735 if (S_ISDIR(inode->i_mode))
3736 return -ENODEV;
3737
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003738 map.m_lblk = offset >> blkbits;
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003739 /*
3740 * We can't just convert len to max_blocks because
3741 * If blocksize = 4096 offset = 3072 and len = 2048
3742 */
Amit Aroraa2df2a62007-07-17 21:42:41 -04003743 max_blocks = (EXT4_BLOCK_ALIGN(len + offset, blkbits) >> blkbits)
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003744 - map.m_lblk;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003745 /*
Mingming Caof3bd1f32008-08-19 22:16:03 -04003746 * credits to insert 1 extent into extent tree
Amit Aroraa2df2a62007-07-17 21:42:41 -04003747 */
Mingming Caof3bd1f32008-08-19 22:16:03 -04003748 credits = ext4_chunk_trans_blocks(inode, max_blocks);
Aneesh Kumar K.V55bd7252008-02-15 12:47:21 -05003749 mutex_lock(&inode->i_mutex);
Nikanth Karthikesan6d19c422010-05-16 14:00:00 -04003750 ret = inode_newsize_ok(inode, (len + offset));
3751 if (ret) {
3752 mutex_unlock(&inode->i_mutex);
3753 return ret;
3754 }
Amit Aroraa2df2a62007-07-17 21:42:41 -04003755retry:
3756 while (ret >= 0 && ret < max_blocks) {
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003757 map.m_lblk = map.m_lblk + ret;
3758 map.m_len = max_blocks = max_blocks - ret;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003759 handle = ext4_journal_start(inode, credits);
3760 if (IS_ERR(handle)) {
3761 ret = PTR_ERR(handle);
3762 break;
3763 }
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003764 ret = ext4_map_blocks(handle, inode, &map,
Theodore Ts'oc2177052009-05-14 00:58:52 -04003765 EXT4_GET_BLOCKS_CREATE_UNINIT_EXT);
Aneesh Kumar K.V221879c2008-01-28 23:58:27 -05003766 if (ret <= 0) {
Aneesh Kumar K.V2c986152008-02-25 15:41:35 -05003767#ifdef EXT4FS_DEBUG
3768 WARN_ON(ret <= 0);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003769 printk(KERN_ERR "%s: ext4_ext_map_blocks "
Aneesh Kumar K.V2c986152008-02-25 15:41:35 -05003770 "returned error inode#%lu, block=%u, "
Thadeu Lima de Souza Cascardo9fd97842009-01-26 19:26:26 -05003771 "max_blocks=%u", __func__,
Aneesh Kumar K.V221879c2008-01-28 23:58:27 -05003772 inode->i_ino, block, max_blocks);
Aneesh Kumar K.V2c986152008-02-25 15:41:35 -05003773#endif
Amit Aroraa2df2a62007-07-17 21:42:41 -04003774 ext4_mark_inode_dirty(handle, inode);
3775 ret2 = ext4_journal_stop(handle);
3776 break;
3777 }
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003778 if ((map.m_lblk + ret) >= (EXT4_BLOCK_ALIGN(offset + len,
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003779 blkbits) >> blkbits))
3780 new_size = offset + len;
3781 else
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003782 new_size = (map.m_lblk + ret) << blkbits;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003783
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003784 ext4_falloc_update_inode(inode, mode, new_size,
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003785 (map.m_flags & EXT4_MAP_NEW));
Amit Aroraa2df2a62007-07-17 21:42:41 -04003786 ext4_mark_inode_dirty(handle, inode);
3787 ret2 = ext4_journal_stop(handle);
3788 if (ret2)
3789 break;
3790 }
Aneesh Kumar K.Vfd287842008-04-29 08:11:12 -04003791 if (ret == -ENOSPC &&
3792 ext4_should_retry_alloc(inode->i_sb, &retries)) {
3793 ret = 0;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003794 goto retry;
Amit Aroraa2df2a62007-07-17 21:42:41 -04003795 }
Aneesh Kumar K.V55bd7252008-02-15 12:47:21 -05003796 mutex_unlock(&inode->i_mutex);
Amit Aroraa2df2a62007-07-17 21:42:41 -04003797 return ret > 0 ? ret2 : ret;
3798}
Eric Sandeen6873fa02008-10-07 00:46:36 -04003799
3800/*
Mingming Cao00314622009-09-28 15:49:08 -04003801 * This function convert a range of blocks to written extents
3802 * The caller of this function will pass the start offset and the size.
3803 * all unwritten extents within this range will be converted to
3804 * written extents.
3805 *
3806 * This function is called from the direct IO end io call back
3807 * function, to convert the fallocated extents after IO is completed.
Mingming109f5562009-11-10 10:48:08 -05003808 * Returns 0 on success.
Mingming Cao00314622009-09-28 15:49:08 -04003809 */
3810int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset,
Eric Sandeena1de02d2010-02-04 23:58:38 -05003811 ssize_t len)
Mingming Cao00314622009-09-28 15:49:08 -04003812{
3813 handle_t *handle;
Mingming Cao00314622009-09-28 15:49:08 -04003814 unsigned int max_blocks;
3815 int ret = 0;
3816 int ret2 = 0;
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003817 struct ext4_map_blocks map;
Mingming Cao00314622009-09-28 15:49:08 -04003818 unsigned int credits, blkbits = inode->i_blkbits;
3819
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003820 map.m_lblk = offset >> blkbits;
Mingming Cao00314622009-09-28 15:49:08 -04003821 /*
3822 * We can't just convert len to max_blocks because
3823 * If blocksize = 4096 offset = 3072 and len = 2048
3824 */
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003825 max_blocks = ((EXT4_BLOCK_ALIGN(len + offset, blkbits) >> blkbits) -
3826 map.m_lblk);
Mingming Cao00314622009-09-28 15:49:08 -04003827 /*
3828 * credits to insert 1 extent into extent tree
3829 */
3830 credits = ext4_chunk_trans_blocks(inode, max_blocks);
3831 while (ret >= 0 && ret < max_blocks) {
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003832 map.m_lblk += ret;
3833 map.m_len = (max_blocks -= ret);
Mingming Cao00314622009-09-28 15:49:08 -04003834 handle = ext4_journal_start(inode, credits);
3835 if (IS_ERR(handle)) {
3836 ret = PTR_ERR(handle);
3837 break;
3838 }
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003839 ret = ext4_map_blocks(handle, inode, &map,
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05003840 EXT4_GET_BLOCKS_IO_CONVERT_EXT);
Mingming Cao00314622009-09-28 15:49:08 -04003841 if (ret <= 0) {
3842 WARN_ON(ret <= 0);
Theodore Ts'oe35fd662010-05-16 19:00:00 -04003843 printk(KERN_ERR "%s: ext4_ext_map_blocks "
Mingming Cao00314622009-09-28 15:49:08 -04003844 "returned error inode#%lu, block=%u, "
3845 "max_blocks=%u", __func__,
Theodore Ts'o2ed88682010-05-16 20:00:00 -04003846 inode->i_ino, map.m_lblk, map.m_len);
Mingming Cao00314622009-09-28 15:49:08 -04003847 }
3848 ext4_mark_inode_dirty(handle, inode);
3849 ret2 = ext4_journal_stop(handle);
3850 if (ret <= 0 || ret2 )
3851 break;
3852 }
3853 return ret > 0 ? ret2 : ret;
3854}
3855/*
Eric Sandeen6873fa02008-10-07 00:46:36 -04003856 * Callback function called for each extent to gather FIEMAP information.
3857 */
Aneesh Kumar K.V3a06d772008-11-22 15:04:59 -05003858static int ext4_ext_fiemap_cb(struct inode *inode, struct ext4_ext_path *path,
Eric Sandeen6873fa02008-10-07 00:46:36 -04003859 struct ext4_ext_cache *newex, struct ext4_extent *ex,
3860 void *data)
3861{
3862 struct fiemap_extent_info *fieinfo = data;
Eric Sandeenc9877b22009-05-01 23:32:06 -04003863 unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
Eric Sandeen6873fa02008-10-07 00:46:36 -04003864 __u64 logical;
3865 __u64 physical;
3866 __u64 length;
3867 __u32 flags = 0;
3868 int error;
3869
3870 logical = (__u64)newex->ec_block << blksize_bits;
3871
3872 if (newex->ec_type == EXT4_EXT_CACHE_GAP) {
3873 pgoff_t offset;
3874 struct page *page;
3875 struct buffer_head *bh = NULL;
3876
3877 offset = logical >> PAGE_SHIFT;
3878 page = find_get_page(inode->i_mapping, offset);
3879 if (!page || !page_has_buffers(page))
3880 return EXT_CONTINUE;
3881
3882 bh = page_buffers(page);
3883
3884 if (!bh)
3885 return EXT_CONTINUE;
3886
3887 if (buffer_delay(bh)) {
3888 flags |= FIEMAP_EXTENT_DELALLOC;
3889 page_cache_release(page);
3890 } else {
3891 page_cache_release(page);
3892 return EXT_CONTINUE;
3893 }
3894 }
3895
3896 physical = (__u64)newex->ec_start << blksize_bits;
3897 length = (__u64)newex->ec_len << blksize_bits;
3898
3899 if (ex && ext4_ext_is_uninitialized(ex))
3900 flags |= FIEMAP_EXTENT_UNWRITTEN;
3901
3902 /*
3903 * If this extent reaches EXT_MAX_BLOCK, it must be last.
3904 *
3905 * Or if ext4_ext_next_allocated_block is EXT_MAX_BLOCK,
3906 * this also indicates no more allocated blocks.
3907 *
3908 * XXX this might miss a single-block extent at EXT_MAX_BLOCK
3909 */
Eric Sandeenc9877b22009-05-01 23:32:06 -04003910 if (ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCK ||
Theodore Ts'oeefd7f02009-05-02 19:05:37 -04003911 newex->ec_block + newex->ec_len - 1 == EXT_MAX_BLOCK) {
3912 loff_t size = i_size_read(inode);
3913 loff_t bs = EXT4_BLOCK_SIZE(inode->i_sb);
3914
Eric Sandeen6873fa02008-10-07 00:46:36 -04003915 flags |= FIEMAP_EXTENT_LAST;
Theodore Ts'oeefd7f02009-05-02 19:05:37 -04003916 if ((flags & FIEMAP_EXTENT_DELALLOC) &&
3917 logical+length > size)
3918 length = (size - logical + bs - 1) & ~(bs-1);
3919 }
Eric Sandeen6873fa02008-10-07 00:46:36 -04003920
3921 error = fiemap_fill_next_extent(fieinfo, logical, physical,
3922 length, flags);
3923 if (error < 0)
3924 return error;
3925 if (error == 1)
3926 return EXT_BREAK;
3927
3928 return EXT_CONTINUE;
3929}
3930
3931/* fiemap flags we can handle specified here */
3932#define EXT4_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
3933
Aneesh Kumar K.V3a06d772008-11-22 15:04:59 -05003934static int ext4_xattr_fiemap(struct inode *inode,
3935 struct fiemap_extent_info *fieinfo)
Eric Sandeen6873fa02008-10-07 00:46:36 -04003936{
3937 __u64 physical = 0;
3938 __u64 length;
3939 __u32 flags = FIEMAP_EXTENT_LAST;
3940 int blockbits = inode->i_sb->s_blocksize_bits;
3941 int error = 0;
3942
3943 /* in-inode? */
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05003944 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
Eric Sandeen6873fa02008-10-07 00:46:36 -04003945 struct ext4_iloc iloc;
3946 int offset; /* offset of xattr in inode */
3947
3948 error = ext4_get_inode_loc(inode, &iloc);
3949 if (error)
3950 return error;
3951 physical = iloc.bh->b_blocknr << blockbits;
3952 offset = EXT4_GOOD_OLD_INODE_SIZE +
3953 EXT4_I(inode)->i_extra_isize;
3954 physical += offset;
3955 length = EXT4_SB(inode->i_sb)->s_inode_size - offset;
3956 flags |= FIEMAP_EXTENT_DATA_INLINE;
Curt Wohlgemuthfd2dd9f2010-04-03 17:44:16 -04003957 brelse(iloc.bh);
Eric Sandeen6873fa02008-10-07 00:46:36 -04003958 } else { /* external block */
3959 physical = EXT4_I(inode)->i_file_acl << blockbits;
3960 length = inode->i_sb->s_blocksize;
3961 }
3962
3963 if (physical)
3964 error = fiemap_fill_next_extent(fieinfo, 0, physical,
3965 length, flags);
3966 return (error < 0 ? error : 0);
3967}
3968
3969int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3970 __u64 start, __u64 len)
3971{
3972 ext4_lblk_t start_blk;
Eric Sandeen6873fa02008-10-07 00:46:36 -04003973 int error = 0;
3974
3975 /* fallback to generic here if not in extents fmt */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04003976 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Eric Sandeen6873fa02008-10-07 00:46:36 -04003977 return generic_block_fiemap(inode, fieinfo, start, len,
3978 ext4_get_block);
3979
3980 if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS))
3981 return -EBADR;
3982
3983 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
3984 error = ext4_xattr_fiemap(inode, fieinfo);
3985 } else {
Leonard Michlmayraca92ff2010-03-04 17:07:28 -05003986 ext4_lblk_t len_blks;
3987 __u64 last_blk;
3988
Eric Sandeen6873fa02008-10-07 00:46:36 -04003989 start_blk = start >> inode->i_sb->s_blocksize_bits;
Leonard Michlmayraca92ff2010-03-04 17:07:28 -05003990 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
3991 if (last_blk >= EXT_MAX_BLOCK)
3992 last_blk = EXT_MAX_BLOCK-1;
3993 len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;
Eric Sandeen6873fa02008-10-07 00:46:36 -04003994
3995 /*
3996 * Walk the extent tree gathering extent information.
3997 * ext4_ext_fiemap_cb will push extents back to user.
3998 */
Eric Sandeen6873fa02008-10-07 00:46:36 -04003999 error = ext4_ext_walk_space(inode, start_blk, len_blks,
4000 ext4_ext_fiemap_cb, fieinfo);
Eric Sandeen6873fa02008-10-07 00:46:36 -04004001 }
4002
4003 return error;
4004}
4005