1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 /* 2 /*
3 * Copyright (c) 2003-2006, Cluster File Syste 3 * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
4 * Written by Alex Tomas <alex@clusterfs.com> 4 * Written by Alex Tomas <alex@clusterfs.com>
5 * 5 *
6 * Architecture independence: 6 * Architecture independence:
7 * Copyright (c) 2005, Bull S.A. 7 * Copyright (c) 2005, Bull S.A.
8 * Written by Pierre Peiffer <pierre.peiffer 8 * Written by Pierre Peiffer <pierre.peiffer@bull.net>
9 */ 9 */
10 10
11 /* 11 /*
12 * Extents support for EXT4 12 * Extents support for EXT4
13 * 13 *
14 * TODO: 14 * TODO:
15 * - ext4*_error() should be used in some si 15 * - ext4*_error() should be used in some situations
16 * - analyze all BUG()/BUG_ON(), use -EIO wh 16 * - analyze all BUG()/BUG_ON(), use -EIO where appropriate
17 * - smart tree reduction 17 * - smart tree reduction
18 */ 18 */
19 19
20 #include <linux/fs.h> 20 #include <linux/fs.h>
21 #include <linux/time.h> 21 #include <linux/time.h>
22 #include <linux/jbd2.h> 22 #include <linux/jbd2.h>
23 #include <linux/highuid.h> 23 #include <linux/highuid.h>
24 #include <linux/pagemap.h> 24 #include <linux/pagemap.h>
25 #include <linux/quotaops.h> 25 #include <linux/quotaops.h>
26 #include <linux/string.h> 26 #include <linux/string.h>
27 #include <linux/slab.h> 27 #include <linux/slab.h>
28 #include <linux/uaccess.h> 28 #include <linux/uaccess.h>
29 #include <linux/fiemap.h> 29 #include <linux/fiemap.h>
>> 30 #include <linux/backing-dev.h>
30 #include <linux/iomap.h> 31 #include <linux/iomap.h>
31 #include <linux/sched/mm.h> <<
32 #include "ext4_jbd2.h" 32 #include "ext4_jbd2.h"
33 #include "ext4_extents.h" 33 #include "ext4_extents.h"
34 #include "xattr.h" 34 #include "xattr.h"
35 35
36 #include <trace/events/ext4.h> 36 #include <trace/events/ext4.h>
37 37
38 /* 38 /*
39 * used by extent splitting. 39 * used by extent splitting.
40 */ 40 */
41 #define EXT4_EXT_MAY_ZEROOUT 0x1 /* safe t 41 #define EXT4_EXT_MAY_ZEROOUT 0x1 /* safe to zeroout if split fails \
42 due to 42 due to ENOSPC */
43 #define EXT4_EXT_MARK_UNWRIT1 0x2 /* mark f 43 #define EXT4_EXT_MARK_UNWRIT1 0x2 /* mark first half unwritten */
44 #define EXT4_EXT_MARK_UNWRIT2 0x4 /* mark s 44 #define EXT4_EXT_MARK_UNWRIT2 0x4 /* mark second half unwritten */
45 45
46 #define EXT4_EXT_DATA_VALID1 0x8 /* first 46 #define EXT4_EXT_DATA_VALID1 0x8 /* first half contains valid data */
47 #define EXT4_EXT_DATA_VALID2 0x10 /* second 47 #define EXT4_EXT_DATA_VALID2 0x10 /* second half contains valid data */
48 48
49 static __le32 ext4_extent_block_csum(struct in 49 static __le32 ext4_extent_block_csum(struct inode *inode,
50 struct ex 50 struct ext4_extent_header *eh)
51 { 51 {
52 struct ext4_inode_info *ei = EXT4_I(in 52 struct ext4_inode_info *ei = EXT4_I(inode);
53 struct ext4_sb_info *sbi = EXT4_SB(ino 53 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
54 __u32 csum; 54 __u32 csum;
55 55
56 csum = ext4_chksum(sbi, ei->i_csum_see 56 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh,
57 EXT4_EXTENT_TAIL_OF 57 EXT4_EXTENT_TAIL_OFFSET(eh));
58 return cpu_to_le32(csum); 58 return cpu_to_le32(csum);
59 } 59 }
60 60
61 static int ext4_extent_block_csum_verify(struc 61 static int ext4_extent_block_csum_verify(struct inode *inode,
62 struc 62 struct ext4_extent_header *eh)
63 { 63 {
64 struct ext4_extent_tail *et; 64 struct ext4_extent_tail *et;
65 65
66 if (!ext4_has_metadata_csum(inode->i_s 66 if (!ext4_has_metadata_csum(inode->i_sb))
67 return 1; 67 return 1;
68 68
69 et = find_ext4_extent_tail(eh); 69 et = find_ext4_extent_tail(eh);
70 if (et->et_checksum != ext4_extent_blo 70 if (et->et_checksum != ext4_extent_block_csum(inode, eh))
71 return 0; 71 return 0;
72 return 1; 72 return 1;
73 } 73 }
74 74
75 static void ext4_extent_block_csum_set(struct 75 static void ext4_extent_block_csum_set(struct inode *inode,
76 struct 76 struct ext4_extent_header *eh)
77 { 77 {
78 struct ext4_extent_tail *et; 78 struct ext4_extent_tail *et;
79 79
80 if (!ext4_has_metadata_csum(inode->i_s 80 if (!ext4_has_metadata_csum(inode->i_sb))
81 return; 81 return;
82 82
83 et = find_ext4_extent_tail(eh); 83 et = find_ext4_extent_tail(eh);
84 et->et_checksum = ext4_extent_block_cs 84 et->et_checksum = ext4_extent_block_csum(inode, eh);
85 } 85 }
86 86
87 static struct ext4_ext_path *ext4_split_extent !! 87 static int ext4_split_extent_at(handle_t *handle,
88 !! 88 struct inode *inode,
89 !! 89 struct ext4_ext_path **ppath,
90 !! 90 ext4_lblk_t split,
91 !! 91 int split_flag,
>> 92 int flags);
92 93
93 static int ext4_ext_trunc_restart_fn(struct in 94 static int ext4_ext_trunc_restart_fn(struct inode *inode, int *dropped)
94 { 95 {
95 /* 96 /*
96 * Drop i_data_sem to avoid deadlock w 97 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
97 * moment, get_block can be called onl 98 * moment, get_block can be called only for blocks inside i_size since
98 * page cache has been already dropped 99 * page cache has been already dropped and writes are blocked by
99 * i_rwsem. So we can safely drop the !! 100 * i_mutex. So we can safely drop the i_data_sem here.
100 */ 101 */
101 BUG_ON(EXT4_JOURNAL(inode) == NULL); 102 BUG_ON(EXT4_JOURNAL(inode) == NULL);
102 ext4_discard_preallocations(inode); !! 103 ext4_discard_preallocations(inode, 0);
103 up_write(&EXT4_I(inode)->i_data_sem); 104 up_write(&EXT4_I(inode)->i_data_sem);
104 *dropped = 1; 105 *dropped = 1;
105 return 0; 106 return 0;
106 } 107 }
107 108
108 static inline void ext4_ext_path_brelse(struct <<
109 { <<
110 brelse(path->p_bh); <<
111 path->p_bh = NULL; <<
112 } <<
113 <<
114 static void ext4_ext_drop_refs(struct ext4_ext <<
115 { <<
116 int depth, i; <<
117 <<
118 if (IS_ERR_OR_NULL(path)) <<
119 return; <<
120 depth = path->p_depth; <<
121 for (i = 0; i <= depth; i++, path++) <<
122 ext4_ext_path_brelse(path); <<
123 } <<
124 <<
125 void ext4_free_ext_path(struct ext4_ext_path * <<
126 { <<
127 if (IS_ERR_OR_NULL(path)) <<
128 return; <<
129 ext4_ext_drop_refs(path); <<
130 kfree(path); <<
131 } <<
132 <<
133 /* 109 /*
134 * Make sure 'handle' has at least 'check_cred 110 * Make sure 'handle' has at least 'check_cred' credits. If not, restart
135 * transaction with 'restart_cred' credits. Th 111 * transaction with 'restart_cred' credits. The function drops i_data_sem
136 * when restarting transaction and gets it aft 112 * when restarting transaction and gets it after transaction is restarted.
137 * 113 *
138 * The function returns 0 on success, 1 if tra 114 * The function returns 0 on success, 1 if transaction had to be restarted,
139 * and < 0 in case of fatal error. 115 * and < 0 in case of fatal error.
140 */ 116 */
141 int ext4_datasem_ensure_credits(handle_t *hand 117 int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
142 int check_cred 118 int check_cred, int restart_cred,
143 int revoke_cre 119 int revoke_cred)
144 { 120 {
145 int ret; 121 int ret;
146 int dropped = 0; 122 int dropped = 0;
147 123
148 ret = ext4_journal_ensure_credits_fn(h 124 ret = ext4_journal_ensure_credits_fn(handle, check_cred, restart_cred,
149 revoke_cred, ext4_ext_trunc_re 125 revoke_cred, ext4_ext_trunc_restart_fn(inode, &dropped));
150 if (dropped) 126 if (dropped)
151 down_write(&EXT4_I(inode)->i_d 127 down_write(&EXT4_I(inode)->i_data_sem);
152 return ret; 128 return ret;
153 } 129 }
154 130
155 /* 131 /*
156 * could return: 132 * could return:
157 * - EROFS 133 * - EROFS
158 * - ENOMEM 134 * - ENOMEM
159 */ 135 */
160 static int ext4_ext_get_access(handle_t *handl 136 static int ext4_ext_get_access(handle_t *handle, struct inode *inode,
161 struct ext4_ex 137 struct ext4_ext_path *path)
162 { 138 {
163 int err = 0; 139 int err = 0;
164 140
165 if (path->p_bh) { 141 if (path->p_bh) {
166 /* path points to block */ 142 /* path points to block */
167 BUFFER_TRACE(path->p_bh, "get_ 143 BUFFER_TRACE(path->p_bh, "get_write_access");
168 err = ext4_journal_get_write_a !! 144 err = ext4_journal_get_write_access(handle, path->p_bh);
169 <<
170 /* 145 /*
171 * The extent buffer's verifie 146 * The extent buffer's verified bit will be set again in
172 * __ext4_ext_dirty(). We coul 147 * __ext4_ext_dirty(). We could leave an inconsistent
173 * buffer if the extents updat 148 * buffer if the extents updating procudure break off du
174 * to some error happens, forc 149 * to some error happens, force to check it again.
175 */ 150 */
176 if (!err) 151 if (!err)
177 clear_buffer_verified( 152 clear_buffer_verified(path->p_bh);
178 } 153 }
179 /* path points to leaf/index in inode 154 /* path points to leaf/index in inode body */
180 /* we use in-core data, no need to pro 155 /* we use in-core data, no need to protect them */
181 return err; 156 return err;
182 } 157 }
183 158
184 /* 159 /*
185 * could return: 160 * could return:
186 * - EROFS 161 * - EROFS
187 * - ENOMEM 162 * - ENOMEM
188 * - EIO 163 * - EIO
189 */ 164 */
190 static int __ext4_ext_dirty(const char *where, 165 static int __ext4_ext_dirty(const char *where, unsigned int line,
191 handle_t *handle, 166 handle_t *handle, struct inode *inode,
192 struct ext4_ext_pa 167 struct ext4_ext_path *path)
193 { 168 {
194 int err; 169 int err;
195 170
196 WARN_ON(!rwsem_is_locked(&EXT4_I(inode 171 WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem));
197 if (path->p_bh) { 172 if (path->p_bh) {
198 ext4_extent_block_csum_set(ino 173 ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh));
199 /* path points to block */ 174 /* path points to block */
200 err = __ext4_handle_dirty_meta 175 err = __ext4_handle_dirty_metadata(where, line, handle,
201 176 inode, path->p_bh);
202 /* Extents updating done, re-s 177 /* Extents updating done, re-set verified flag */
203 if (!err) 178 if (!err)
204 set_buffer_verified(pa 179 set_buffer_verified(path->p_bh);
205 } else { 180 } else {
206 /* path points to leaf/index i 181 /* path points to leaf/index in inode body */
207 err = ext4_mark_inode_dirty(ha 182 err = ext4_mark_inode_dirty(handle, inode);
208 } 183 }
209 return err; 184 return err;
210 } 185 }
211 186
212 #define ext4_ext_dirty(handle, inode, path) \ 187 #define ext4_ext_dirty(handle, inode, path) \
213 __ext4_ext_dirty(__func__, __L 188 __ext4_ext_dirty(__func__, __LINE__, (handle), (inode), (path))
214 189
215 static ext4_fsblk_t ext4_ext_find_goal(struct 190 static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
216 struct ext4_ext_ 191 struct ext4_ext_path *path,
217 ext4_lblk_t bloc 192 ext4_lblk_t block)
218 { 193 {
219 if (path) { 194 if (path) {
220 int depth = path->p_depth; 195 int depth = path->p_depth;
221 struct ext4_extent *ex; 196 struct ext4_extent *ex;
222 197
223 /* 198 /*
224 * Try to predict block placem 199 * Try to predict block placement assuming that we are
225 * filling in a file which wil 200 * filling in a file which will eventually be
226 * non-sparse --- i.e., in the 201 * non-sparse --- i.e., in the case of libbfd writing
227 * an ELF object sections out- 202 * an ELF object sections out-of-order but in a way
228 * the eventually results in a 203 * the eventually results in a contiguous object or
229 * executable file, or some da 204 * executable file, or some database extending a table
230 * space file. However, this 205 * space file. However, this is actually somewhat
231 * non-ideal if we are writing 206 * non-ideal if we are writing a sparse file such as
232 * qemu or KVM writing a raw i 207 * qemu or KVM writing a raw image file that is going
233 * to stay fairly sparse, sinc 208 * to stay fairly sparse, since it will end up
234 * fragmenting the file system 209 * fragmenting the file system's free space. Maybe we
235 * should have some hueristics 210 * should have some hueristics or some way to allow
236 * userspace to pass a hint to 211 * userspace to pass a hint to file system,
237 * especially if the latter ca 212 * especially if the latter case turns out to be
238 * common. 213 * common.
239 */ 214 */
240 ex = path[depth].p_ext; 215 ex = path[depth].p_ext;
241 if (ex) { 216 if (ex) {
242 ext4_fsblk_t ext_pblk 217 ext4_fsblk_t ext_pblk = ext4_ext_pblock(ex);
243 ext4_lblk_t ext_block 218 ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block);
244 219
245 if (block > ext_block) 220 if (block > ext_block)
246 return ext_pbl 221 return ext_pblk + (block - ext_block);
247 else 222 else
248 return ext_pbl 223 return ext_pblk - (ext_block - block);
249 } 224 }
250 225
251 /* it looks like index is empt 226 /* it looks like index is empty;
252 * try to find starting block 227 * try to find starting block from index itself */
253 if (path[depth].p_bh) 228 if (path[depth].p_bh)
254 return path[depth].p_b 229 return path[depth].p_bh->b_blocknr;
255 } 230 }
256 231
257 /* OK. use inode's group */ 232 /* OK. use inode's group */
258 return ext4_inode_to_goal_block(inode) 233 return ext4_inode_to_goal_block(inode);
259 } 234 }
260 235
261 /* 236 /*
262 * Allocation for a meta data block 237 * Allocation for a meta data block
263 */ 238 */
264 static ext4_fsblk_t 239 static ext4_fsblk_t
265 ext4_ext_new_meta_block(handle_t *handle, stru 240 ext4_ext_new_meta_block(handle_t *handle, struct inode *inode,
266 struct ext4_ext_path * 241 struct ext4_ext_path *path,
267 struct ext4_extent *ex 242 struct ext4_extent *ex, int *err, unsigned int flags)
268 { 243 {
269 ext4_fsblk_t goal, newblock; 244 ext4_fsblk_t goal, newblock;
270 245
271 goal = ext4_ext_find_goal(inode, path, 246 goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
272 newblock = ext4_new_meta_blocks(handle 247 newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
273 NULL, 248 NULL, err);
274 return newblock; 249 return newblock;
275 } 250 }
276 251
277 static inline int ext4_ext_space_block(struct 252 static inline int ext4_ext_space_block(struct inode *inode, int check)
278 { 253 {
279 int size; 254 int size;
280 255
281 size = (inode->i_sb->s_blocksize - siz 256 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
282 / sizeof(struct ext4_e 257 / sizeof(struct ext4_extent);
283 #ifdef AGGRESSIVE_TEST 258 #ifdef AGGRESSIVE_TEST
284 if (!check && size > 6) 259 if (!check && size > 6)
285 size = 6; 260 size = 6;
286 #endif 261 #endif
287 return size; 262 return size;
288 } 263 }
289 264
290 static inline int ext4_ext_space_block_idx(str 265 static inline int ext4_ext_space_block_idx(struct inode *inode, int check)
291 { 266 {
292 int size; 267 int size;
293 268
294 size = (inode->i_sb->s_blocksize - siz 269 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header))
295 / sizeof(struct ext4_e 270 / sizeof(struct ext4_extent_idx);
296 #ifdef AGGRESSIVE_TEST 271 #ifdef AGGRESSIVE_TEST
297 if (!check && size > 5) 272 if (!check && size > 5)
298 size = 5; 273 size = 5;
299 #endif 274 #endif
300 return size; 275 return size;
301 } 276 }
302 277
303 static inline int ext4_ext_space_root(struct i 278 static inline int ext4_ext_space_root(struct inode *inode, int check)
304 { 279 {
305 int size; 280 int size;
306 281
307 size = sizeof(EXT4_I(inode)->i_data); 282 size = sizeof(EXT4_I(inode)->i_data);
308 size -= sizeof(struct ext4_extent_head 283 size -= sizeof(struct ext4_extent_header);
309 size /= sizeof(struct ext4_extent); 284 size /= sizeof(struct ext4_extent);
310 #ifdef AGGRESSIVE_TEST 285 #ifdef AGGRESSIVE_TEST
311 if (!check && size > 3) 286 if (!check && size > 3)
312 size = 3; 287 size = 3;
313 #endif 288 #endif
314 return size; 289 return size;
315 } 290 }
316 291
317 static inline int ext4_ext_space_root_idx(stru 292 static inline int ext4_ext_space_root_idx(struct inode *inode, int check)
318 { 293 {
319 int size; 294 int size;
320 295
321 size = sizeof(EXT4_I(inode)->i_data); 296 size = sizeof(EXT4_I(inode)->i_data);
322 size -= sizeof(struct ext4_extent_head 297 size -= sizeof(struct ext4_extent_header);
323 size /= sizeof(struct ext4_extent_idx) 298 size /= sizeof(struct ext4_extent_idx);
324 #ifdef AGGRESSIVE_TEST 299 #ifdef AGGRESSIVE_TEST
325 if (!check && size > 4) 300 if (!check && size > 4)
326 size = 4; 301 size = 4;
327 #endif 302 #endif
328 return size; 303 return size;
329 } 304 }
330 305
331 static inline struct ext4_ext_path * !! 306 static inline int
332 ext4_force_split_extent_at(handle_t *handle, s 307 ext4_force_split_extent_at(handle_t *handle, struct inode *inode,
333 struct ext4_ext_pat !! 308 struct ext4_ext_path **ppath, ext4_lblk_t lblk,
334 int nofail) 309 int nofail)
335 { 310 {
>> 311 struct ext4_ext_path *path = *ppath;
336 int unwritten = ext4_ext_is_unwritten( 312 int unwritten = ext4_ext_is_unwritten(path[path->p_depth].p_ext);
337 int flags = EXT4_EX_NOCACHE | EXT4_GET 313 int flags = EXT4_EX_NOCACHE | EXT4_GET_BLOCKS_PRE_IO;
338 314
339 if (nofail) 315 if (nofail)
340 flags |= EXT4_GET_BLOCKS_METAD 316 flags |= EXT4_GET_BLOCKS_METADATA_NOFAIL | EXT4_EX_NOFAIL;
341 317
342 return ext4_split_extent_at(handle, in !! 318 return ext4_split_extent_at(handle, inode, ppath, lblk, unwritten ?
343 EXT4_EXT_MARK_UNWRIT1| 319 EXT4_EXT_MARK_UNWRIT1|EXT4_EXT_MARK_UNWRIT2 : 0,
344 flags); 320 flags);
345 } 321 }
346 322
347 static int 323 static int
348 ext4_ext_max_entries(struct inode *inode, int 324 ext4_ext_max_entries(struct inode *inode, int depth)
349 { 325 {
350 int max; 326 int max;
351 327
352 if (depth == ext_depth(inode)) { 328 if (depth == ext_depth(inode)) {
353 if (depth == 0) 329 if (depth == 0)
354 max = ext4_ext_space_r 330 max = ext4_ext_space_root(inode, 1);
355 else 331 else
356 max = ext4_ext_space_r 332 max = ext4_ext_space_root_idx(inode, 1);
357 } else { 333 } else {
358 if (depth == 0) 334 if (depth == 0)
359 max = ext4_ext_space_b 335 max = ext4_ext_space_block(inode, 1);
360 else 336 else
361 max = ext4_ext_space_b 337 max = ext4_ext_space_block_idx(inode, 1);
362 } 338 }
363 339
364 return max; 340 return max;
365 } 341 }
366 342
367 static int ext4_valid_extent(struct inode *ino 343 static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
368 { 344 {
369 ext4_fsblk_t block = ext4_ext_pblock(e 345 ext4_fsblk_t block = ext4_ext_pblock(ext);
370 int len = ext4_ext_get_actual_len(ext) 346 int len = ext4_ext_get_actual_len(ext);
371 ext4_lblk_t lblock = le32_to_cpu(ext-> 347 ext4_lblk_t lblock = le32_to_cpu(ext->ee_block);
372 348
373 /* 349 /*
374 * We allow neither: 350 * We allow neither:
375 * - zero length 351 * - zero length
376 * - overflow/wrap-around 352 * - overflow/wrap-around
377 */ 353 */
378 if (lblock + len <= lblock) 354 if (lblock + len <= lblock)
379 return 0; 355 return 0;
380 return ext4_inode_block_valid(inode, b 356 return ext4_inode_block_valid(inode, block, len);
381 } 357 }
382 358
383 static int ext4_valid_extent_idx(struct inode 359 static int ext4_valid_extent_idx(struct inode *inode,
384 struct ext4_ex 360 struct ext4_extent_idx *ext_idx)
385 { 361 {
386 ext4_fsblk_t block = ext4_idx_pblock(e 362 ext4_fsblk_t block = ext4_idx_pblock(ext_idx);
387 363
388 return ext4_inode_block_valid(inode, b 364 return ext4_inode_block_valid(inode, block, 1);
389 } 365 }
390 366
391 static int ext4_valid_extent_entries(struct in 367 static int ext4_valid_extent_entries(struct inode *inode,
392 struct ex 368 struct ext4_extent_header *eh,
393 ext4_lblk 369 ext4_lblk_t lblk, ext4_fsblk_t *pblk,
394 int depth 370 int depth)
395 { 371 {
396 unsigned short entries; 372 unsigned short entries;
397 ext4_lblk_t lblock = 0; 373 ext4_lblk_t lblock = 0;
398 ext4_lblk_t cur = 0; 374 ext4_lblk_t cur = 0;
399 375
400 if (eh->eh_entries == 0) 376 if (eh->eh_entries == 0)
401 return 1; 377 return 1;
402 378
403 entries = le16_to_cpu(eh->eh_entries); 379 entries = le16_to_cpu(eh->eh_entries);
404 380
405 if (depth == 0) { 381 if (depth == 0) {
406 /* leaf entries */ 382 /* leaf entries */
407 struct ext4_extent *ext = EXT_ 383 struct ext4_extent *ext = EXT_FIRST_EXTENT(eh);
408 384
409 /* 385 /*
410 * The logical block in the fi 386 * The logical block in the first entry should equal to
411 * the number in the index blo 387 * the number in the index block.
412 */ 388 */
413 if (depth != ext_depth(inode) 389 if (depth != ext_depth(inode) &&
414 lblk != le32_to_cpu(ext->e 390 lblk != le32_to_cpu(ext->ee_block))
415 return 0; 391 return 0;
416 while (entries) { 392 while (entries) {
417 if (!ext4_valid_extent 393 if (!ext4_valid_extent(inode, ext))
418 return 0; 394 return 0;
419 395
420 /* Check for overlappi 396 /* Check for overlapping extents */
421 lblock = le32_to_cpu(e 397 lblock = le32_to_cpu(ext->ee_block);
422 if (lblock < cur) { 398 if (lblock < cur) {
423 *pblk = ext4_e 399 *pblk = ext4_ext_pblock(ext);
424 return 0; 400 return 0;
425 } 401 }
426 cur = lblock + ext4_ex 402 cur = lblock + ext4_ext_get_actual_len(ext);
427 ext++; 403 ext++;
428 entries--; 404 entries--;
429 } 405 }
430 } else { 406 } else {
431 struct ext4_extent_idx *ext_id 407 struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh);
432 408
433 /* 409 /*
434 * The logical block in the fi 410 * The logical block in the first entry should equal to
435 * the number in the parent in 411 * the number in the parent index block.
436 */ 412 */
437 if (depth != ext_depth(inode) 413 if (depth != ext_depth(inode) &&
438 lblk != le32_to_cpu(ext_id 414 lblk != le32_to_cpu(ext_idx->ei_block))
439 return 0; 415 return 0;
440 while (entries) { 416 while (entries) {
441 if (!ext4_valid_extent 417 if (!ext4_valid_extent_idx(inode, ext_idx))
442 return 0; 418 return 0;
443 419
444 /* Check for overlappi 420 /* Check for overlapping index extents */
445 lblock = le32_to_cpu(e 421 lblock = le32_to_cpu(ext_idx->ei_block);
446 if (lblock < cur) { 422 if (lblock < cur) {
447 *pblk = ext4_i 423 *pblk = ext4_idx_pblock(ext_idx);
448 return 0; 424 return 0;
449 } 425 }
450 ext_idx++; 426 ext_idx++;
451 entries--; 427 entries--;
452 cur = lblock + 1; 428 cur = lblock + 1;
453 } 429 }
454 } 430 }
455 return 1; 431 return 1;
456 } 432 }
457 433
458 static int __ext4_ext_check(const char *functi 434 static int __ext4_ext_check(const char *function, unsigned int line,
459 struct inode *inod 435 struct inode *inode, struct ext4_extent_header *eh,
460 int depth, ext4_fs 436 int depth, ext4_fsblk_t pblk, ext4_lblk_t lblk)
461 { 437 {
462 const char *error_msg; 438 const char *error_msg;
463 int max = 0, err = -EFSCORRUPTED; 439 int max = 0, err = -EFSCORRUPTED;
464 440
465 if (unlikely(eh->eh_magic != EXT4_EXT_ 441 if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) {
466 error_msg = "invalid magic"; 442 error_msg = "invalid magic";
467 goto corrupted; 443 goto corrupted;
468 } 444 }
469 if (unlikely(le16_to_cpu(eh->eh_depth) 445 if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {
470 error_msg = "unexpected eh_dep 446 error_msg = "unexpected eh_depth";
471 goto corrupted; 447 goto corrupted;
472 } 448 }
473 if (unlikely(eh->eh_max == 0)) { 449 if (unlikely(eh->eh_max == 0)) {
474 error_msg = "invalid eh_max"; 450 error_msg = "invalid eh_max";
475 goto corrupted; 451 goto corrupted;
476 } 452 }
477 max = ext4_ext_max_entries(inode, dept 453 max = ext4_ext_max_entries(inode, depth);
478 if (unlikely(le16_to_cpu(eh->eh_max) > 454 if (unlikely(le16_to_cpu(eh->eh_max) > max)) {
479 error_msg = "too large eh_max" 455 error_msg = "too large eh_max";
480 goto corrupted; 456 goto corrupted;
481 } 457 }
482 if (unlikely(le16_to_cpu(eh->eh_entrie 458 if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) {
483 error_msg = "invalid eh_entrie 459 error_msg = "invalid eh_entries";
484 goto corrupted; 460 goto corrupted;
485 } 461 }
486 if (unlikely((eh->eh_entries == 0) && 462 if (unlikely((eh->eh_entries == 0) && (depth > 0))) {
487 error_msg = "eh_entries is 0 b 463 error_msg = "eh_entries is 0 but eh_depth is > 0";
488 goto corrupted; 464 goto corrupted;
489 } 465 }
490 if (!ext4_valid_extent_entries(inode, 466 if (!ext4_valid_extent_entries(inode, eh, lblk, &pblk, depth)) {
491 error_msg = "invalid extent en 467 error_msg = "invalid extent entries";
492 goto corrupted; 468 goto corrupted;
493 } 469 }
494 if (unlikely(depth > 32)) { 470 if (unlikely(depth > 32)) {
495 error_msg = "too large eh_dept 471 error_msg = "too large eh_depth";
496 goto corrupted; 472 goto corrupted;
497 } 473 }
498 /* Verify checksum on non-root extent 474 /* Verify checksum on non-root extent tree nodes */
499 if (ext_depth(inode) != depth && 475 if (ext_depth(inode) != depth &&
500 !ext4_extent_block_csum_verify(ino 476 !ext4_extent_block_csum_verify(inode, eh)) {
501 error_msg = "extent tree corru 477 error_msg = "extent tree corrupted";
502 err = -EFSBADCRC; 478 err = -EFSBADCRC;
503 goto corrupted; 479 goto corrupted;
504 } 480 }
505 return 0; 481 return 0;
506 482
507 corrupted: 483 corrupted:
508 ext4_error_inode_err(inode, function, 484 ext4_error_inode_err(inode, function, line, 0, -err,
509 "pblk %llu bad he 485 "pblk %llu bad header/extent: %s - magic %x, "
510 "entries %u, max 486 "entries %u, max %u(%u), depth %u(%u)",
511 (unsigned long lo 487 (unsigned long long) pblk, error_msg,
512 le16_to_cpu(eh->e 488 le16_to_cpu(eh->eh_magic),
513 le16_to_cpu(eh->e 489 le16_to_cpu(eh->eh_entries),
514 le16_to_cpu(eh->e 490 le16_to_cpu(eh->eh_max),
515 max, le16_to_cpu( 491 max, le16_to_cpu(eh->eh_depth), depth);
516 return err; 492 return err;
517 } 493 }
518 494
519 #define ext4_ext_check(inode, eh, depth, pblk) 495 #define ext4_ext_check(inode, eh, depth, pblk) \
520 __ext4_ext_check(__func__, __LINE__, ( 496 __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk), 0)
521 497
522 int ext4_ext_check_inode(struct inode *inode) 498 int ext4_ext_check_inode(struct inode *inode)
523 { 499 {
524 return ext4_ext_check(inode, ext_inode 500 return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode), 0);
525 } 501 }
526 502
527 static void ext4_cache_extents(struct inode *i 503 static void ext4_cache_extents(struct inode *inode,
528 struct ext4_ext 504 struct ext4_extent_header *eh)
529 { 505 {
530 struct ext4_extent *ex = EXT_FIRST_EXT 506 struct ext4_extent *ex = EXT_FIRST_EXTENT(eh);
531 ext4_lblk_t prev = 0; 507 ext4_lblk_t prev = 0;
532 int i; 508 int i;
533 509
534 for (i = le16_to_cpu(eh->eh_entries); 510 for (i = le16_to_cpu(eh->eh_entries); i > 0; i--, ex++) {
535 unsigned int status = EXTENT_S 511 unsigned int status = EXTENT_STATUS_WRITTEN;
536 ext4_lblk_t lblk = le32_to_cpu 512 ext4_lblk_t lblk = le32_to_cpu(ex->ee_block);
537 int len = ext4_ext_get_actual_ 513 int len = ext4_ext_get_actual_len(ex);
538 514
539 if (prev && (prev != lblk)) 515 if (prev && (prev != lblk))
540 ext4_es_cache_extent(i 516 ext4_es_cache_extent(inode, prev, lblk - prev, ~0,
541 E 517 EXTENT_STATUS_HOLE);
542 518
543 if (ext4_ext_is_unwritten(ex)) 519 if (ext4_ext_is_unwritten(ex))
544 status = EXTENT_STATUS 520 status = EXTENT_STATUS_UNWRITTEN;
545 ext4_es_cache_extent(inode, lb 521 ext4_es_cache_extent(inode, lblk, len,
546 ext4_ext_ 522 ext4_ext_pblock(ex), status);
547 prev = lblk + len; 523 prev = lblk + len;
548 } 524 }
549 } 525 }
550 526
551 static struct buffer_head * 527 static struct buffer_head *
552 __read_extent_tree_block(const char *function, 528 __read_extent_tree_block(const char *function, unsigned int line,
553 struct inode *inode, 529 struct inode *inode, struct ext4_extent_idx *idx,
554 int depth, int flags) 530 int depth, int flags)
555 { 531 {
556 struct buffer_head *bh; 532 struct buffer_head *bh;
557 int err; 533 int err;
558 gfp_t gfp_fl 534 gfp_t gfp_flags = __GFP_MOVABLE | GFP_NOFS;
559 ext4_fsblk_t pblk; 535 ext4_fsblk_t pblk;
560 536
561 if (flags & EXT4_EX_NOFAIL) 537 if (flags & EXT4_EX_NOFAIL)
562 gfp_flags |= __GFP_NOFAIL; 538 gfp_flags |= __GFP_NOFAIL;
563 539
564 pblk = ext4_idx_pblock(idx); 540 pblk = ext4_idx_pblock(idx);
565 bh = sb_getblk_gfp(inode->i_sb, pblk, 541 bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags);
566 if (unlikely(!bh)) 542 if (unlikely(!bh))
567 return ERR_PTR(-ENOMEM); 543 return ERR_PTR(-ENOMEM);
568 544
569 if (!bh_uptodate_or_lock(bh)) { 545 if (!bh_uptodate_or_lock(bh)) {
570 trace_ext4_ext_load_extent(ino 546 trace_ext4_ext_load_extent(inode, pblk, _RET_IP_);
571 err = ext4_read_bh(bh, 0, NULL 547 err = ext4_read_bh(bh, 0, NULL);
572 if (err < 0) 548 if (err < 0)
573 goto errout; 549 goto errout;
574 } 550 }
575 if (buffer_verified(bh) && !(flags & E 551 if (buffer_verified(bh) && !(flags & EXT4_EX_FORCE_CACHE))
576 return bh; 552 return bh;
577 err = __ext4_ext_check(function, line, 553 err = __ext4_ext_check(function, line, inode, ext_block_hdr(bh),
578 depth, pblk, le 554 depth, pblk, le32_to_cpu(idx->ei_block));
579 if (err) 555 if (err)
580 goto errout; 556 goto errout;
581 set_buffer_verified(bh); 557 set_buffer_verified(bh);
582 /* 558 /*
583 * If this is a leaf block, cache all 559 * If this is a leaf block, cache all of its entries
584 */ 560 */
585 if (!(flags & EXT4_EX_NOCACHE) && dept 561 if (!(flags & EXT4_EX_NOCACHE) && depth == 0) {
586 struct ext4_extent_header *eh 562 struct ext4_extent_header *eh = ext_block_hdr(bh);
587 ext4_cache_extents(inode, eh); 563 ext4_cache_extents(inode, eh);
588 } 564 }
589 return bh; 565 return bh;
590 errout: 566 errout:
591 put_bh(bh); 567 put_bh(bh);
592 return ERR_PTR(err); 568 return ERR_PTR(err);
593 569
594 } 570 }
595 571
596 #define read_extent_tree_block(inode, idx, dep 572 #define read_extent_tree_block(inode, idx, depth, flags) \
597 __read_extent_tree_block(__func__, __L 573 __read_extent_tree_block(__func__, __LINE__, (inode), (idx), \
598 (depth), (fla 574 (depth), (flags))
599 575
600 /* 576 /*
601 * This function is called to cache a file's e 577 * This function is called to cache a file's extent information in the
602 * extent status tree 578 * extent status tree
603 */ 579 */
604 int ext4_ext_precache(struct inode *inode) 580 int ext4_ext_precache(struct inode *inode)
605 { 581 {
606 struct ext4_inode_info *ei = EXT4_I(in 582 struct ext4_inode_info *ei = EXT4_I(inode);
607 struct ext4_ext_path *path = NULL; 583 struct ext4_ext_path *path = NULL;
608 struct buffer_head *bh; 584 struct buffer_head *bh;
609 int i = 0, depth, ret = 0; 585 int i = 0, depth, ret = 0;
610 586
611 if (!ext4_test_inode_flag(inode, EXT4_ 587 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
612 return 0; /* not an exte 588 return 0; /* not an extent-mapped inode */
613 589
614 down_read(&ei->i_data_sem); 590 down_read(&ei->i_data_sem);
615 depth = ext_depth(inode); 591 depth = ext_depth(inode);
616 592
617 /* Don't cache anything if there are n 593 /* Don't cache anything if there are no external extent blocks */
618 if (!depth) { 594 if (!depth) {
619 up_read(&ei->i_data_sem); 595 up_read(&ei->i_data_sem);
620 return ret; 596 return ret;
621 } 597 }
622 598
623 path = kcalloc(depth + 1, sizeof(struc 599 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
624 GFP_NOFS); 600 GFP_NOFS);
625 if (path == NULL) { 601 if (path == NULL) {
626 up_read(&ei->i_data_sem); 602 up_read(&ei->i_data_sem);
627 return -ENOMEM; 603 return -ENOMEM;
628 } 604 }
629 605
630 path[0].p_hdr = ext_inode_hdr(inode); 606 path[0].p_hdr = ext_inode_hdr(inode);
631 ret = ext4_ext_check(inode, path[0].p_ 607 ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0);
632 if (ret) 608 if (ret)
633 goto out; 609 goto out;
634 path[0].p_idx = EXT_FIRST_INDEX(path[0 610 path[0].p_idx = EXT_FIRST_INDEX(path[0].p_hdr);
635 while (i >= 0) { 611 while (i >= 0) {
636 /* 612 /*
637 * If this is a leaf block or 613 * If this is a leaf block or we've reached the end of
638 * the index block, go up 614 * the index block, go up
639 */ 615 */
640 if ((i == depth) || 616 if ((i == depth) ||
641 path[i].p_idx > EXT_LAST_I 617 path[i].p_idx > EXT_LAST_INDEX(path[i].p_hdr)) {
642 ext4_ext_path_brelse(p !! 618 brelse(path[i].p_bh);
>> 619 path[i].p_bh = NULL;
643 i--; 620 i--;
644 continue; 621 continue;
645 } 622 }
646 bh = read_extent_tree_block(in 623 bh = read_extent_tree_block(inode, path[i].p_idx++,
647 de 624 depth - i - 1,
648 EX 625 EXT4_EX_FORCE_CACHE);
649 if (IS_ERR(bh)) { 626 if (IS_ERR(bh)) {
650 ret = PTR_ERR(bh); 627 ret = PTR_ERR(bh);
651 break; 628 break;
652 } 629 }
653 i++; 630 i++;
654 path[i].p_bh = bh; 631 path[i].p_bh = bh;
655 path[i].p_hdr = ext_block_hdr( 632 path[i].p_hdr = ext_block_hdr(bh);
656 path[i].p_idx = EXT_FIRST_INDE 633 path[i].p_idx = EXT_FIRST_INDEX(path[i].p_hdr);
657 } 634 }
658 ext4_set_inode_state(inode, EXT4_STATE 635 ext4_set_inode_state(inode, EXT4_STATE_EXT_PRECACHED);
659 out: 636 out:
660 up_read(&ei->i_data_sem); 637 up_read(&ei->i_data_sem);
661 ext4_free_ext_path(path); !! 638 ext4_ext_drop_refs(path);
>> 639 kfree(path);
662 return ret; 640 return ret;
663 } 641 }
664 642
665 #ifdef EXT_DEBUG 643 #ifdef EXT_DEBUG
666 static void ext4_ext_show_path(struct inode *i 644 static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
667 { 645 {
668 int k, l = path->p_depth; 646 int k, l = path->p_depth;
669 647
670 ext_debug(inode, "path:"); 648 ext_debug(inode, "path:");
671 for (k = 0; k <= l; k++, path++) { 649 for (k = 0; k <= l; k++, path++) {
672 if (path->p_idx) { 650 if (path->p_idx) {
673 ext_debug(inode, " %d 651 ext_debug(inode, " %d->%llu",
674 le32_to_cpu( 652 le32_to_cpu(path->p_idx->ei_block),
675 ext4_idx_pbl 653 ext4_idx_pblock(path->p_idx));
676 } else if (path->p_ext) { 654 } else if (path->p_ext) {
677 ext_debug(inode, " %d 655 ext_debug(inode, " %d:[%d]%d:%llu ",
678 le32_to_cpu( 656 le32_to_cpu(path->p_ext->ee_block),
679 ext4_ext_is_ 657 ext4_ext_is_unwritten(path->p_ext),
680 ext4_ext_get 658 ext4_ext_get_actual_len(path->p_ext),
681 ext4_ext_pbl 659 ext4_ext_pblock(path->p_ext));
682 } else 660 } else
683 ext_debug(inode, " [] 661 ext_debug(inode, " []");
684 } 662 }
685 ext_debug(inode, "\n"); 663 ext_debug(inode, "\n");
686 } 664 }
687 665
688 static void ext4_ext_show_leaf(struct inode *i 666 static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
689 { 667 {
690 int depth = ext_depth(inode); 668 int depth = ext_depth(inode);
691 struct ext4_extent_header *eh; 669 struct ext4_extent_header *eh;
692 struct ext4_extent *ex; 670 struct ext4_extent *ex;
693 int i; 671 int i;
694 672
695 if (IS_ERR_OR_NULL(path)) !! 673 if (!path)
696 return; 674 return;
697 675
698 eh = path[depth].p_hdr; 676 eh = path[depth].p_hdr;
699 ex = EXT_FIRST_EXTENT(eh); 677 ex = EXT_FIRST_EXTENT(eh);
700 678
701 ext_debug(inode, "Displaying leaf exte 679 ext_debug(inode, "Displaying leaf extents\n");
702 680
703 for (i = 0; i < le16_to_cpu(eh->eh_ent 681 for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) {
704 ext_debug(inode, "%d:[%d]%d:%l 682 ext_debug(inode, "%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block),
705 ext4_ext_is_unwritte 683 ext4_ext_is_unwritten(ex),
706 ext4_ext_get_actual_ 684 ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex));
707 } 685 }
708 ext_debug(inode, "\n"); 686 ext_debug(inode, "\n");
709 } 687 }
710 688
711 static void ext4_ext_show_move(struct inode *i 689 static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path,
712 ext4_fsblk_t newblock, 690 ext4_fsblk_t newblock, int level)
713 { 691 {
714 int depth = ext_depth(inode); 692 int depth = ext_depth(inode);
715 struct ext4_extent *ex; 693 struct ext4_extent *ex;
716 694
717 if (depth != level) { 695 if (depth != level) {
718 struct ext4_extent_idx *idx; 696 struct ext4_extent_idx *idx;
719 idx = path[level].p_idx; 697 idx = path[level].p_idx;
720 while (idx <= EXT_MAX_INDEX(pa 698 while (idx <= EXT_MAX_INDEX(path[level].p_hdr)) {
721 ext_debug(inode, "%d: 699 ext_debug(inode, "%d: move %d:%llu in new index %llu\n",
722 level, le32_ 700 level, le32_to_cpu(idx->ei_block),
723 ext4_idx_pbl 701 ext4_idx_pblock(idx), newblock);
724 idx++; 702 idx++;
725 } 703 }
726 704
727 return; 705 return;
728 } 706 }
729 707
730 ex = path[depth].p_ext; 708 ex = path[depth].p_ext;
731 while (ex <= EXT_MAX_EXTENT(path[depth 709 while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) {
732 ext_debug(inode, "move %d:%llu 710 ext_debug(inode, "move %d:%llu:[%d]%d in new leaf %llu\n",
733 le32_to_cpu(ex 711 le32_to_cpu(ex->ee_block),
734 ext4_ext_pbloc 712 ext4_ext_pblock(ex),
735 ext4_ext_is_un 713 ext4_ext_is_unwritten(ex),
736 ext4_ext_get_a 714 ext4_ext_get_actual_len(ex),
737 newblock); 715 newblock);
738 ex++; 716 ex++;
739 } 717 }
740 } 718 }
741 719
742 #else 720 #else
743 #define ext4_ext_show_path(inode, path) 721 #define ext4_ext_show_path(inode, path)
744 #define ext4_ext_show_leaf(inode, path) 722 #define ext4_ext_show_leaf(inode, path)
745 #define ext4_ext_show_move(inode, path, newblo 723 #define ext4_ext_show_move(inode, path, newblock, level)
746 #endif 724 #endif
747 725
>> 726 void ext4_ext_drop_refs(struct ext4_ext_path *path)
>> 727 {
>> 728 int depth, i;
>> 729
>> 730 if (!path)
>> 731 return;
>> 732 depth = path->p_depth;
>> 733 for (i = 0; i <= depth; i++, path++) {
>> 734 brelse(path->p_bh);
>> 735 path->p_bh = NULL;
>> 736 }
>> 737 }
>> 738
748 /* 739 /*
749 * ext4_ext_binsearch_idx: 740 * ext4_ext_binsearch_idx:
750 * binary search for the closest index of the 741 * binary search for the closest index of the given block
751 * the header must be checked before calling t 742 * the header must be checked before calling this
752 */ 743 */
753 static void 744 static void
754 ext4_ext_binsearch_idx(struct inode *inode, 745 ext4_ext_binsearch_idx(struct inode *inode,
755 struct ext4_ext_path * 746 struct ext4_ext_path *path, ext4_lblk_t block)
756 { 747 {
757 struct ext4_extent_header *eh = path-> 748 struct ext4_extent_header *eh = path->p_hdr;
758 struct ext4_extent_idx *r, *l, *m; 749 struct ext4_extent_idx *r, *l, *m;
759 750
760 751
761 ext_debug(inode, "binsearch for %u(idx 752 ext_debug(inode, "binsearch for %u(idx): ", block);
762 753
763 l = EXT_FIRST_INDEX(eh) + 1; 754 l = EXT_FIRST_INDEX(eh) + 1;
764 r = EXT_LAST_INDEX(eh); 755 r = EXT_LAST_INDEX(eh);
765 while (l <= r) { 756 while (l <= r) {
766 m = l + (r - l) / 2; 757 m = l + (r - l) / 2;
767 ext_debug(inode, "%p(%u):%p(%u <<
768 le32_to_cpu(l->ei_bl <<
769 r, le32_to_cpu(r->ei <<
770 <<
771 if (block < le32_to_cpu(m->ei_ 758 if (block < le32_to_cpu(m->ei_block))
772 r = m - 1; 759 r = m - 1;
773 else 760 else
774 l = m + 1; 761 l = m + 1;
>> 762 ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,
>> 763 le32_to_cpu(l->ei_block), m, le32_to_cpu(m->ei_block),
>> 764 r, le32_to_cpu(r->ei_block));
775 } 765 }
776 766
777 path->p_idx = l - 1; 767 path->p_idx = l - 1;
778 ext_debug(inode, " -> %u->%lld ", le3 768 ext_debug(inode, " -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block),
779 ext4_idx_pblock(path->p_idx) 769 ext4_idx_pblock(path->p_idx));
780 770
781 #ifdef CHECK_BINSEARCH 771 #ifdef CHECK_BINSEARCH
782 { 772 {
783 struct ext4_extent_idx *chix, 773 struct ext4_extent_idx *chix, *ix;
784 int k; 774 int k;
785 775
786 chix = ix = EXT_FIRST_INDEX(eh 776 chix = ix = EXT_FIRST_INDEX(eh);
787 for (k = 0; k < le16_to_cpu(eh 777 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {
788 if (k != 0 && le32_to_ 778 if (k != 0 && le32_to_cpu(ix->ei_block) <=
789 le32_to_cpu(ix[-1] 779 le32_to_cpu(ix[-1].ei_block)) {
790 printk(KERN_DE 780 printk(KERN_DEBUG "k=%d, ix=0x%p, "
791 "first= 781 "first=0x%p\n", k,
792 ix, EXT 782 ix, EXT_FIRST_INDEX(eh));
793 printk(KERN_DE 783 printk(KERN_DEBUG "%u <= %u\n",
794 le32_to 784 le32_to_cpu(ix->ei_block),
795 le32_to 785 le32_to_cpu(ix[-1].ei_block));
796 } 786 }
797 BUG_ON(k && le32_to_cp 787 BUG_ON(k && le32_to_cpu(ix->ei_block)
798 <= 788 <= le32_to_cpu(ix[-1].ei_block));
799 if (block < le32_to_cp 789 if (block < le32_to_cpu(ix->ei_block))
800 break; 790 break;
801 chix = ix; 791 chix = ix;
802 } 792 }
803 BUG_ON(chix != path->p_idx); 793 BUG_ON(chix != path->p_idx);
804 } 794 }
805 #endif 795 #endif
806 796
807 } 797 }
808 798
809 /* 799 /*
810 * ext4_ext_binsearch: 800 * ext4_ext_binsearch:
811 * binary search for closest extent of the giv 801 * binary search for closest extent of the given block
812 * the header must be checked before calling t 802 * the header must be checked before calling this
813 */ 803 */
814 static void 804 static void
815 ext4_ext_binsearch(struct inode *inode, 805 ext4_ext_binsearch(struct inode *inode,
816 struct ext4_ext_path *path, ex 806 struct ext4_ext_path *path, ext4_lblk_t block)
817 { 807 {
818 struct ext4_extent_header *eh = path-> 808 struct ext4_extent_header *eh = path->p_hdr;
819 struct ext4_extent *r, *l, *m; 809 struct ext4_extent *r, *l, *m;
820 810
821 if (eh->eh_entries == 0) { 811 if (eh->eh_entries == 0) {
822 /* 812 /*
823 * this leaf is empty: 813 * this leaf is empty:
824 * we get such a leaf in split 814 * we get such a leaf in split/add case
825 */ 815 */
826 return; 816 return;
827 } 817 }
828 818
829 ext_debug(inode, "binsearch for %u: " 819 ext_debug(inode, "binsearch for %u: ", block);
830 820
831 l = EXT_FIRST_EXTENT(eh) + 1; 821 l = EXT_FIRST_EXTENT(eh) + 1;
832 r = EXT_LAST_EXTENT(eh); 822 r = EXT_LAST_EXTENT(eh);
833 823
834 while (l <= r) { 824 while (l <= r) {
835 m = l + (r - l) / 2; 825 m = l + (r - l) / 2;
836 ext_debug(inode, "%p(%u):%p(%u <<
837 le32_to_cpu(l->ee_bl <<
838 r, le32_to_cpu(r->ee <<
839 <<
840 if (block < le32_to_cpu(m->ee_ 826 if (block < le32_to_cpu(m->ee_block))
841 r = m - 1; 827 r = m - 1;
842 else 828 else
843 l = m + 1; 829 l = m + 1;
>> 830 ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,
>> 831 le32_to_cpu(l->ee_block), m, le32_to_cpu(m->ee_block),
>> 832 r, le32_to_cpu(r->ee_block));
844 } 833 }
845 834
846 path->p_ext = l - 1; 835 path->p_ext = l - 1;
847 ext_debug(inode, " -> %d:%llu:[%d]%d 836 ext_debug(inode, " -> %d:%llu:[%d]%d ",
848 le32_to_cpu(path->p_ex 837 le32_to_cpu(path->p_ext->ee_block),
849 ext4_ext_pblock(path-> 838 ext4_ext_pblock(path->p_ext),
850 ext4_ext_is_unwritten( 839 ext4_ext_is_unwritten(path->p_ext),
851 ext4_ext_get_actual_le 840 ext4_ext_get_actual_len(path->p_ext));
852 841
853 #ifdef CHECK_BINSEARCH 842 #ifdef CHECK_BINSEARCH
854 { 843 {
855 struct ext4_extent *chex, *ex; 844 struct ext4_extent *chex, *ex;
856 int k; 845 int k;
857 846
858 chex = ex = EXT_FIRST_EXTENT(e 847 chex = ex = EXT_FIRST_EXTENT(eh);
859 for (k = 0; k < le16_to_cpu(eh 848 for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) {
860 BUG_ON(k && le32_to_cp 849 BUG_ON(k && le32_to_cpu(ex->ee_block)
861 <= l 850 <= le32_to_cpu(ex[-1].ee_block));
862 if (block < le32_to_cp 851 if (block < le32_to_cpu(ex->ee_block))
863 break; 852 break;
864 chex = ex; 853 chex = ex;
865 } 854 }
866 BUG_ON(chex != path->p_ext); 855 BUG_ON(chex != path->p_ext);
867 } 856 }
868 #endif 857 #endif
869 858
870 } 859 }
871 860
872 void ext4_ext_tree_init(handle_t *handle, stru 861 void ext4_ext_tree_init(handle_t *handle, struct inode *inode)
873 { 862 {
874 struct ext4_extent_header *eh; 863 struct ext4_extent_header *eh;
875 864
876 eh = ext_inode_hdr(inode); 865 eh = ext_inode_hdr(inode);
877 eh->eh_depth = 0; 866 eh->eh_depth = 0;
878 eh->eh_entries = 0; 867 eh->eh_entries = 0;
879 eh->eh_magic = EXT4_EXT_MAGIC; 868 eh->eh_magic = EXT4_EXT_MAGIC;
880 eh->eh_max = cpu_to_le16(ext4_ext_spac 869 eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0));
881 eh->eh_generation = 0; 870 eh->eh_generation = 0;
882 ext4_mark_inode_dirty(handle, inode); 871 ext4_mark_inode_dirty(handle, inode);
883 } 872 }
884 873
885 struct ext4_ext_path * 874 struct ext4_ext_path *
886 ext4_find_extent(struct inode *inode, ext4_lbl 875 ext4_find_extent(struct inode *inode, ext4_lblk_t block,
887 struct ext4_ext_path *path, i !! 876 struct ext4_ext_path **orig_path, int flags)
888 { 877 {
889 struct ext4_extent_header *eh; 878 struct ext4_extent_header *eh;
890 struct buffer_head *bh; 879 struct buffer_head *bh;
>> 880 struct ext4_ext_path *path = orig_path ? *orig_path : NULL;
891 short int depth, i, ppos = 0; 881 short int depth, i, ppos = 0;
892 int ret; 882 int ret;
893 gfp_t gfp_flags = GFP_NOFS; 883 gfp_t gfp_flags = GFP_NOFS;
894 884
895 if (flags & EXT4_EX_NOFAIL) 885 if (flags & EXT4_EX_NOFAIL)
896 gfp_flags |= __GFP_NOFAIL; 886 gfp_flags |= __GFP_NOFAIL;
897 887
898 eh = ext_inode_hdr(inode); 888 eh = ext_inode_hdr(inode);
899 depth = ext_depth(inode); 889 depth = ext_depth(inode);
900 if (depth < 0 || depth > EXT4_MAX_EXTE 890 if (depth < 0 || depth > EXT4_MAX_EXTENT_DEPTH) {
901 EXT4_ERROR_INODE(inode, "inode 891 EXT4_ERROR_INODE(inode, "inode has invalid extent depth: %d",
902 depth); 892 depth);
903 ret = -EFSCORRUPTED; 893 ret = -EFSCORRUPTED;
904 goto err; 894 goto err;
905 } 895 }
906 896
907 if (path) { 897 if (path) {
908 ext4_ext_drop_refs(path); 898 ext4_ext_drop_refs(path);
909 if (depth > path[0].p_maxdepth 899 if (depth > path[0].p_maxdepth) {
910 kfree(path); 900 kfree(path);
911 path = NULL; !! 901 *orig_path = path = NULL;
912 } 902 }
913 } 903 }
914 if (!path) { 904 if (!path) {
915 /* account possible depth incr 905 /* account possible depth increase */
916 path = kcalloc(depth + 2, size 906 path = kcalloc(depth + 2, sizeof(struct ext4_ext_path),
917 gfp_flags); 907 gfp_flags);
918 if (unlikely(!path)) 908 if (unlikely(!path))
919 return ERR_PTR(-ENOMEM 909 return ERR_PTR(-ENOMEM);
920 path[0].p_maxdepth = depth + 1 910 path[0].p_maxdepth = depth + 1;
921 } 911 }
922 path[0].p_hdr = eh; 912 path[0].p_hdr = eh;
923 path[0].p_bh = NULL; 913 path[0].p_bh = NULL;
924 914
925 i = depth; 915 i = depth;
926 if (!(flags & EXT4_EX_NOCACHE) && dept 916 if (!(flags & EXT4_EX_NOCACHE) && depth == 0)
927 ext4_cache_extents(inode, eh); 917 ext4_cache_extents(inode, eh);
928 /* walk through the tree */ 918 /* walk through the tree */
929 while (i) { 919 while (i) {
930 ext_debug(inode, "depth %d: nu 920 ext_debug(inode, "depth %d: num %d, max %d\n",
931 ppos, le16_to_cpu(eh 921 ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
932 922
933 ext4_ext_binsearch_idx(inode, 923 ext4_ext_binsearch_idx(inode, path + ppos, block);
934 path[ppos].p_block = ext4_idx_ 924 path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx);
935 path[ppos].p_depth = i; 925 path[ppos].p_depth = i;
936 path[ppos].p_ext = NULL; 926 path[ppos].p_ext = NULL;
937 927
938 bh = read_extent_tree_block(in 928 bh = read_extent_tree_block(inode, path[ppos].p_idx, --i, flags);
939 if (IS_ERR(bh)) { 929 if (IS_ERR(bh)) {
940 ret = PTR_ERR(bh); 930 ret = PTR_ERR(bh);
941 goto err; 931 goto err;
942 } 932 }
943 933
944 eh = ext_block_hdr(bh); 934 eh = ext_block_hdr(bh);
945 ppos++; 935 ppos++;
946 path[ppos].p_bh = bh; 936 path[ppos].p_bh = bh;
947 path[ppos].p_hdr = eh; 937 path[ppos].p_hdr = eh;
948 } 938 }
949 939
950 path[ppos].p_depth = i; 940 path[ppos].p_depth = i;
951 path[ppos].p_ext = NULL; 941 path[ppos].p_ext = NULL;
952 path[ppos].p_idx = NULL; 942 path[ppos].p_idx = NULL;
953 943
954 /* find extent */ 944 /* find extent */
955 ext4_ext_binsearch(inode, path + ppos, 945 ext4_ext_binsearch(inode, path + ppos, block);
956 /* if not an empty leaf */ 946 /* if not an empty leaf */
957 if (path[ppos].p_ext) 947 if (path[ppos].p_ext)
958 path[ppos].p_block = ext4_ext_ 948 path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext);
959 949
960 ext4_ext_show_path(inode, path); 950 ext4_ext_show_path(inode, path);
961 951
>> 952 if (orig_path)
>> 953 *orig_path = path;
962 return path; 954 return path;
963 955
964 err: 956 err:
965 ext4_free_ext_path(path); !! 957 ext4_ext_drop_refs(path);
>> 958 kfree(path);
>> 959 if (orig_path)
>> 960 *orig_path = NULL;
966 return ERR_PTR(ret); 961 return ERR_PTR(ret);
967 } 962 }
968 963
969 /* 964 /*
970 * ext4_ext_insert_index: 965 * ext4_ext_insert_index:
971 * insert new index [@logical;@ptr] into the b 966 * insert new index [@logical;@ptr] into the block at @curp;
972 * check where to insert: before @curp or afte 967 * check where to insert: before @curp or after @curp
973 */ 968 */
974 static int ext4_ext_insert_index(handle_t *han 969 static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
975 struct ext4_e 970 struct ext4_ext_path *curp,
976 int logical, 971 int logical, ext4_fsblk_t ptr)
977 { 972 {
978 struct ext4_extent_idx *ix; 973 struct ext4_extent_idx *ix;
979 int len, err; 974 int len, err;
980 975
981 err = ext4_ext_get_access(handle, inod 976 err = ext4_ext_get_access(handle, inode, curp);
982 if (err) 977 if (err)
983 return err; 978 return err;
984 979
985 if (unlikely(logical == le32_to_cpu(cu 980 if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) {
986 EXT4_ERROR_INODE(inode, 981 EXT4_ERROR_INODE(inode,
987 "logical %d = 982 "logical %d == ei_block %d!",
988 logical, le32 983 logical, le32_to_cpu(curp->p_idx->ei_block));
989 return -EFSCORRUPTED; 984 return -EFSCORRUPTED;
990 } 985 }
991 986
992 if (unlikely(le16_to_cpu(curp->p_hdr-> 987 if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries)
993 >= le16_to_cpu(cu 988 >= le16_to_cpu(curp->p_hdr->eh_max))) {
994 EXT4_ERROR_INODE(inode, 989 EXT4_ERROR_INODE(inode,
995 "eh_entries % 990 "eh_entries %d >= eh_max %d!",
996 le16_to_cpu(c 991 le16_to_cpu(curp->p_hdr->eh_entries),
997 le16_to_cpu(c 992 le16_to_cpu(curp->p_hdr->eh_max));
998 return -EFSCORRUPTED; 993 return -EFSCORRUPTED;
999 } 994 }
1000 995
1001 if (logical > le32_to_cpu(curp->p_idx 996 if (logical > le32_to_cpu(curp->p_idx->ei_block)) {
1002 /* insert after */ 997 /* insert after */
1003 ext_debug(inode, "insert new 998 ext_debug(inode, "insert new index %d after: %llu\n",
1004 logical, ptr); 999 logical, ptr);
1005 ix = curp->p_idx + 1; 1000 ix = curp->p_idx + 1;
1006 } else { 1001 } else {
1007 /* insert before */ 1002 /* insert before */
1008 ext_debug(inode, "insert new 1003 ext_debug(inode, "insert new index %d before: %llu\n",
1009 logical, ptr); 1004 logical, ptr);
1010 ix = curp->p_idx; 1005 ix = curp->p_idx;
1011 } 1006 }
1012 1007
1013 if (unlikely(ix > EXT_MAX_INDEX(curp- 1008 if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) {
1014 EXT4_ERROR_INODE(inode, "ix > 1009 EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!");
1015 return -EFSCORRUPTED; 1010 return -EFSCORRUPTED;
1016 } 1011 }
1017 1012
1018 len = EXT_LAST_INDEX(curp->p_hdr) - i 1013 len = EXT_LAST_INDEX(curp->p_hdr) - ix + 1;
1019 BUG_ON(len < 0); 1014 BUG_ON(len < 0);
1020 if (len > 0) { 1015 if (len > 0) {
1021 ext_debug(inode, "insert new 1016 ext_debug(inode, "insert new index %d: "
1022 "move %d indi 1017 "move %d indices from 0x%p to 0x%p\n",
1023 logical, len, 1018 logical, len, ix, ix + 1);
1024 memmove(ix + 1, ix, len * siz 1019 memmove(ix + 1, ix, len * sizeof(struct ext4_extent_idx));
1025 } 1020 }
1026 1021
1027 ix->ei_block = cpu_to_le32(logical); 1022 ix->ei_block = cpu_to_le32(logical);
1028 ext4_idx_store_pblock(ix, ptr); 1023 ext4_idx_store_pblock(ix, ptr);
1029 le16_add_cpu(&curp->p_hdr->eh_entries 1024 le16_add_cpu(&curp->p_hdr->eh_entries, 1);
1030 1025
1031 if (unlikely(ix > EXT_LAST_INDEX(curp 1026 if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) {
1032 EXT4_ERROR_INODE(inode, "ix > 1027 EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
1033 return -EFSCORRUPTED; 1028 return -EFSCORRUPTED;
1034 } 1029 }
1035 1030
1036 err = ext4_ext_dirty(handle, inode, c 1031 err = ext4_ext_dirty(handle, inode, curp);
1037 ext4_std_error(inode->i_sb, err); 1032 ext4_std_error(inode->i_sb, err);
1038 1033
1039 return err; 1034 return err;
1040 } 1035 }
1041 1036
1042 /* 1037 /*
1043 * ext4_ext_split: 1038 * ext4_ext_split:
1044 * inserts new subtree into the path, using f 1039 * inserts new subtree into the path, using free index entry
1045 * at depth @at: 1040 * at depth @at:
1046 * - allocates all needed blocks (new leaf an 1041 * - allocates all needed blocks (new leaf and all intermediate index blocks)
1047 * - makes decision where to split 1042 * - makes decision where to split
1048 * - moves remaining extents and index entrie 1043 * - moves remaining extents and index entries (right to the split point)
1049 * into the newly allocated blocks 1044 * into the newly allocated blocks
1050 * - initializes subtree 1045 * - initializes subtree
1051 */ 1046 */
1052 static int ext4_ext_split(handle_t *handle, s 1047 static int ext4_ext_split(handle_t *handle, struct inode *inode,
1053 unsigned int flags, 1048 unsigned int flags,
1054 struct ext4_ext_pat 1049 struct ext4_ext_path *path,
1055 struct ext4_extent 1050 struct ext4_extent *newext, int at)
1056 { 1051 {
1057 struct buffer_head *bh = NULL; 1052 struct buffer_head *bh = NULL;
1058 int depth = ext_depth(inode); 1053 int depth = ext_depth(inode);
1059 struct ext4_extent_header *neh; 1054 struct ext4_extent_header *neh;
1060 struct ext4_extent_idx *fidx; 1055 struct ext4_extent_idx *fidx;
1061 int i = at, k, m, a; 1056 int i = at, k, m, a;
1062 ext4_fsblk_t newblock, oldblock; 1057 ext4_fsblk_t newblock, oldblock;
1063 __le32 border; 1058 __le32 border;
1064 ext4_fsblk_t *ablocks = NULL; /* arra 1059 ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */
1065 gfp_t gfp_flags = GFP_NOFS; 1060 gfp_t gfp_flags = GFP_NOFS;
1066 int err = 0; 1061 int err = 0;
1067 size_t ext_size = 0; 1062 size_t ext_size = 0;
1068 1063
1069 if (flags & EXT4_EX_NOFAIL) 1064 if (flags & EXT4_EX_NOFAIL)
1070 gfp_flags |= __GFP_NOFAIL; 1065 gfp_flags |= __GFP_NOFAIL;
1071 1066
1072 /* make decision: where to split? */ 1067 /* make decision: where to split? */
1073 /* FIXME: now decision is simplest: a 1068 /* FIXME: now decision is simplest: at current extent */
1074 1069
1075 /* if current leaf will be split, the 1070 /* if current leaf will be split, then we should use
1076 * border from split point */ 1071 * border from split point */
1077 if (unlikely(path[depth].p_ext > EXT_ 1072 if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {
1078 EXT4_ERROR_INODE(inode, "p_ex 1073 EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
1079 return -EFSCORRUPTED; 1074 return -EFSCORRUPTED;
1080 } 1075 }
1081 if (path[depth].p_ext != EXT_MAX_EXTE 1076 if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
1082 border = path[depth].p_ext[1] 1077 border = path[depth].p_ext[1].ee_block;
1083 ext_debug(inode, "leaf will b 1078 ext_debug(inode, "leaf will be split."
1084 " next leaf s 1079 " next leaf starts at %d\n",
1085 le32_to_cpu 1080 le32_to_cpu(border));
1086 } else { 1081 } else {
1087 border = newext->ee_block; 1082 border = newext->ee_block;
1088 ext_debug(inode, "leaf will b 1083 ext_debug(inode, "leaf will be added."
1089 " next leaf s 1084 " next leaf starts at %d\n",
1090 le32_to_cpu(b 1085 le32_to_cpu(border));
1091 } 1086 }
1092 1087
1093 /* 1088 /*
1094 * If error occurs, then we break pro 1089 * If error occurs, then we break processing
1095 * and mark filesystem read-only. ind 1090 * and mark filesystem read-only. index won't
1096 * be inserted and tree will be in co 1091 * be inserted and tree will be in consistent
1097 * state. Next mount will repair buff 1092 * state. Next mount will repair buffers too.
1098 */ 1093 */
1099 1094
1100 /* 1095 /*
1101 * Get array to track all allocated b 1096 * Get array to track all allocated blocks.
1102 * We need this to handle errors and 1097 * We need this to handle errors and free blocks
1103 * upon them. 1098 * upon them.
1104 */ 1099 */
1105 ablocks = kcalloc(depth, sizeof(ext4_ 1100 ablocks = kcalloc(depth, sizeof(ext4_fsblk_t), gfp_flags);
1106 if (!ablocks) 1101 if (!ablocks)
1107 return -ENOMEM; 1102 return -ENOMEM;
1108 1103
1109 /* allocate all needed blocks */ 1104 /* allocate all needed blocks */
1110 ext_debug(inode, "allocate %d blocks 1105 ext_debug(inode, "allocate %d blocks for indexes/leaf\n", depth - at);
1111 for (a = 0; a < depth - at; a++) { 1106 for (a = 0; a < depth - at; a++) {
1112 newblock = ext4_ext_new_meta_ 1107 newblock = ext4_ext_new_meta_block(handle, inode, path,
1113 1108 newext, &err, flags);
1114 if (newblock == 0) 1109 if (newblock == 0)
1115 goto cleanup; 1110 goto cleanup;
1116 ablocks[a] = newblock; 1111 ablocks[a] = newblock;
1117 } 1112 }
1118 1113
1119 /* initialize new leaf */ 1114 /* initialize new leaf */
1120 newblock = ablocks[--a]; 1115 newblock = ablocks[--a];
1121 if (unlikely(newblock == 0)) { 1116 if (unlikely(newblock == 0)) {
1122 EXT4_ERROR_INODE(inode, "newb 1117 EXT4_ERROR_INODE(inode, "newblock == 0!");
1123 err = -EFSCORRUPTED; 1118 err = -EFSCORRUPTED;
1124 goto cleanup; 1119 goto cleanup;
1125 } 1120 }
1126 bh = sb_getblk_gfp(inode->i_sb, newbl 1121 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1127 if (unlikely(!bh)) { 1122 if (unlikely(!bh)) {
1128 err = -ENOMEM; 1123 err = -ENOMEM;
1129 goto cleanup; 1124 goto cleanup;
1130 } 1125 }
1131 lock_buffer(bh); 1126 lock_buffer(bh);
1132 1127
1133 err = ext4_journal_get_create_access( !! 1128 err = ext4_journal_get_create_access(handle, bh);
1134 <<
1135 if (err) 1129 if (err)
1136 goto cleanup; 1130 goto cleanup;
1137 1131
1138 neh = ext_block_hdr(bh); 1132 neh = ext_block_hdr(bh);
1139 neh->eh_entries = 0; 1133 neh->eh_entries = 0;
1140 neh->eh_max = cpu_to_le16(ext4_ext_sp 1134 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1141 neh->eh_magic = EXT4_EXT_MAGIC; 1135 neh->eh_magic = EXT4_EXT_MAGIC;
1142 neh->eh_depth = 0; 1136 neh->eh_depth = 0;
1143 neh->eh_generation = 0; 1137 neh->eh_generation = 0;
1144 1138
1145 /* move remainder of path[depth] to t 1139 /* move remainder of path[depth] to the new leaf */
1146 if (unlikely(path[depth].p_hdr->eh_en 1140 if (unlikely(path[depth].p_hdr->eh_entries !=
1147 path[depth].p_hdr->eh_ma 1141 path[depth].p_hdr->eh_max)) {
1148 EXT4_ERROR_INODE(inode, "eh_e 1142 EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
1149 path[depth]. 1143 path[depth].p_hdr->eh_entries,
1150 path[depth]. 1144 path[depth].p_hdr->eh_max);
1151 err = -EFSCORRUPTED; 1145 err = -EFSCORRUPTED;
1152 goto cleanup; 1146 goto cleanup;
1153 } 1147 }
1154 /* start copy from next extent */ 1148 /* start copy from next extent */
1155 m = EXT_MAX_EXTENT(path[depth].p_hdr) 1149 m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++;
1156 ext4_ext_show_move(inode, path, newbl 1150 ext4_ext_show_move(inode, path, newblock, depth);
1157 if (m) { 1151 if (m) {
1158 struct ext4_extent *ex; 1152 struct ext4_extent *ex;
1159 ex = EXT_FIRST_EXTENT(neh); 1153 ex = EXT_FIRST_EXTENT(neh);
1160 memmove(ex, path[depth].p_ext 1154 memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m);
1161 le16_add_cpu(&neh->eh_entries 1155 le16_add_cpu(&neh->eh_entries, m);
1162 } 1156 }
1163 1157
1164 /* zero out unused area in the extent 1158 /* zero out unused area in the extent block */
1165 ext_size = sizeof(struct ext4_extent_ 1159 ext_size = sizeof(struct ext4_extent_header) +
1166 sizeof(struct ext4_extent) * 1160 sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries);
1167 memset(bh->b_data + ext_size, 0, inod 1161 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1168 ext4_extent_block_csum_set(inode, neh 1162 ext4_extent_block_csum_set(inode, neh);
1169 set_buffer_uptodate(bh); 1163 set_buffer_uptodate(bh);
1170 unlock_buffer(bh); 1164 unlock_buffer(bh);
1171 1165
1172 err = ext4_handle_dirty_metadata(hand 1166 err = ext4_handle_dirty_metadata(handle, inode, bh);
1173 if (err) 1167 if (err)
1174 goto cleanup; 1168 goto cleanup;
1175 brelse(bh); 1169 brelse(bh);
1176 bh = NULL; 1170 bh = NULL;
1177 1171
1178 /* correct old leaf */ 1172 /* correct old leaf */
1179 if (m) { 1173 if (m) {
1180 err = ext4_ext_get_access(han 1174 err = ext4_ext_get_access(handle, inode, path + depth);
1181 if (err) 1175 if (err)
1182 goto cleanup; 1176 goto cleanup;
1183 le16_add_cpu(&path[depth].p_h 1177 le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);
1184 err = ext4_ext_dirty(handle, 1178 err = ext4_ext_dirty(handle, inode, path + depth);
1185 if (err) 1179 if (err)
1186 goto cleanup; 1180 goto cleanup;
1187 1181
1188 } 1182 }
1189 1183
1190 /* create intermediate indexes */ 1184 /* create intermediate indexes */
1191 k = depth - at - 1; 1185 k = depth - at - 1;
1192 if (unlikely(k < 0)) { 1186 if (unlikely(k < 0)) {
1193 EXT4_ERROR_INODE(inode, "k %d 1187 EXT4_ERROR_INODE(inode, "k %d < 0!", k);
1194 err = -EFSCORRUPTED; 1188 err = -EFSCORRUPTED;
1195 goto cleanup; 1189 goto cleanup;
1196 } 1190 }
1197 if (k) 1191 if (k)
1198 ext_debug(inode, "create %d i 1192 ext_debug(inode, "create %d intermediate indices\n", k);
1199 /* insert new index into current inde 1193 /* insert new index into current index block */
1200 /* current depth stored in i var */ 1194 /* current depth stored in i var */
1201 i = depth - 1; 1195 i = depth - 1;
1202 while (k--) { 1196 while (k--) {
1203 oldblock = newblock; 1197 oldblock = newblock;
1204 newblock = ablocks[--a]; 1198 newblock = ablocks[--a];
1205 bh = sb_getblk(inode->i_sb, n 1199 bh = sb_getblk(inode->i_sb, newblock);
1206 if (unlikely(!bh)) { 1200 if (unlikely(!bh)) {
1207 err = -ENOMEM; 1201 err = -ENOMEM;
1208 goto cleanup; 1202 goto cleanup;
1209 } 1203 }
1210 lock_buffer(bh); 1204 lock_buffer(bh);
1211 1205
1212 err = ext4_journal_get_create !! 1206 err = ext4_journal_get_create_access(handle, bh);
1213 <<
1214 if (err) 1207 if (err)
1215 goto cleanup; 1208 goto cleanup;
1216 1209
1217 neh = ext_block_hdr(bh); 1210 neh = ext_block_hdr(bh);
1218 neh->eh_entries = cpu_to_le16 1211 neh->eh_entries = cpu_to_le16(1);
1219 neh->eh_magic = EXT4_EXT_MAGI 1212 neh->eh_magic = EXT4_EXT_MAGIC;
1220 neh->eh_max = cpu_to_le16(ext 1213 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1221 neh->eh_depth = cpu_to_le16(d 1214 neh->eh_depth = cpu_to_le16(depth - i);
1222 neh->eh_generation = 0; 1215 neh->eh_generation = 0;
1223 fidx = EXT_FIRST_INDEX(neh); 1216 fidx = EXT_FIRST_INDEX(neh);
1224 fidx->ei_block = border; 1217 fidx->ei_block = border;
1225 ext4_idx_store_pblock(fidx, o 1218 ext4_idx_store_pblock(fidx, oldblock);
1226 1219
1227 ext_debug(inode, "int.index a 1220 ext_debug(inode, "int.index at %d (block %llu): %u -> %llu\n",
1228 i, newblock, 1221 i, newblock, le32_to_cpu(border), oldblock);
1229 1222
1230 /* move remainder of path[i] 1223 /* move remainder of path[i] to the new index block */
1231 if (unlikely(EXT_MAX_INDEX(pa 1224 if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) !=
1232 EXT_L 1225 EXT_LAST_INDEX(path[i].p_hdr))) {
1233 EXT4_ERROR_INODE(inod 1226 EXT4_ERROR_INODE(inode,
1234 "EXT 1227 "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!",
1235 le32 1228 le32_to_cpu(path[i].p_ext->ee_block));
1236 err = -EFSCORRUPTED; 1229 err = -EFSCORRUPTED;
1237 goto cleanup; 1230 goto cleanup;
1238 } 1231 }
1239 /* start copy indexes */ 1232 /* start copy indexes */
1240 m = EXT_MAX_INDEX(path[i].p_h 1233 m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++;
1241 ext_debug(inode, "cur 0x%p, l 1234 ext_debug(inode, "cur 0x%p, last 0x%p\n", path[i].p_idx,
1242 EXT_MAX_INDEX 1235 EXT_MAX_INDEX(path[i].p_hdr));
1243 ext4_ext_show_move(inode, pat 1236 ext4_ext_show_move(inode, path, newblock, i);
1244 if (m) { 1237 if (m) {
1245 memmove(++fidx, path[ 1238 memmove(++fidx, path[i].p_idx,
1246 sizeof(struct 1239 sizeof(struct ext4_extent_idx) * m);
1247 le16_add_cpu(&neh->eh 1240 le16_add_cpu(&neh->eh_entries, m);
1248 } 1241 }
1249 /* zero out unused area in th 1242 /* zero out unused area in the extent block */
1250 ext_size = sizeof(struct ext4 1243 ext_size = sizeof(struct ext4_extent_header) +
1251 (sizeof(struct ext4_extent 1244 (sizeof(struct ext4_extent) * le16_to_cpu(neh->eh_entries));
1252 memset(bh->b_data + ext_size, 1245 memset(bh->b_data + ext_size, 0,
1253 inode->i_sb->s_blocks 1246 inode->i_sb->s_blocksize - ext_size);
1254 ext4_extent_block_csum_set(in 1247 ext4_extent_block_csum_set(inode, neh);
1255 set_buffer_uptodate(bh); 1248 set_buffer_uptodate(bh);
1256 unlock_buffer(bh); 1249 unlock_buffer(bh);
1257 1250
1258 err = ext4_handle_dirty_metad 1251 err = ext4_handle_dirty_metadata(handle, inode, bh);
1259 if (err) 1252 if (err)
1260 goto cleanup; 1253 goto cleanup;
1261 brelse(bh); 1254 brelse(bh);
1262 bh = NULL; 1255 bh = NULL;
1263 1256
1264 /* correct old index */ 1257 /* correct old index */
1265 if (m) { 1258 if (m) {
1266 err = ext4_ext_get_ac 1259 err = ext4_ext_get_access(handle, inode, path + i);
1267 if (err) 1260 if (err)
1268 goto cleanup; 1261 goto cleanup;
1269 le16_add_cpu(&path[i] 1262 le16_add_cpu(&path[i].p_hdr->eh_entries, -m);
1270 err = ext4_ext_dirty( 1263 err = ext4_ext_dirty(handle, inode, path + i);
1271 if (err) 1264 if (err)
1272 goto cleanup; 1265 goto cleanup;
1273 } 1266 }
1274 1267
1275 i--; 1268 i--;
1276 } 1269 }
1277 1270
1278 /* insert new index */ 1271 /* insert new index */
1279 err = ext4_ext_insert_index(handle, i 1272 err = ext4_ext_insert_index(handle, inode, path + at,
1280 le32_to_c 1273 le32_to_cpu(border), newblock);
1281 1274
1282 cleanup: 1275 cleanup:
1283 if (bh) { 1276 if (bh) {
1284 if (buffer_locked(bh)) 1277 if (buffer_locked(bh))
1285 unlock_buffer(bh); 1278 unlock_buffer(bh);
1286 brelse(bh); 1279 brelse(bh);
1287 } 1280 }
1288 1281
1289 if (err) { 1282 if (err) {
1290 /* free all allocated blocks 1283 /* free all allocated blocks in error case */
1291 for (i = 0; i < depth; i++) { 1284 for (i = 0; i < depth; i++) {
1292 if (!ablocks[i]) 1285 if (!ablocks[i])
1293 continue; 1286 continue;
1294 ext4_free_blocks(hand 1287 ext4_free_blocks(handle, inode, NULL, ablocks[i], 1,
1295 EXT4 1288 EXT4_FREE_BLOCKS_METADATA);
1296 } 1289 }
1297 } 1290 }
1298 kfree(ablocks); 1291 kfree(ablocks);
1299 1292
1300 return err; 1293 return err;
1301 } 1294 }
1302 1295
1303 /* 1296 /*
1304 * ext4_ext_grow_indepth: 1297 * ext4_ext_grow_indepth:
1305 * implements tree growing procedure: 1298 * implements tree growing procedure:
1306 * - allocates new block 1299 * - allocates new block
1307 * - moves top-level data (index block or lea 1300 * - moves top-level data (index block or leaf) into the new block
1308 * - initializes new top-level, creating inde 1301 * - initializes new top-level, creating index that points to the
1309 * just created block 1302 * just created block
1310 */ 1303 */
1311 static int ext4_ext_grow_indepth(handle_t *ha 1304 static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
1312 unsigned int 1305 unsigned int flags)
1313 { 1306 {
1314 struct ext4_extent_header *neh; 1307 struct ext4_extent_header *neh;
1315 struct buffer_head *bh; 1308 struct buffer_head *bh;
1316 ext4_fsblk_t newblock, goal = 0; 1309 ext4_fsblk_t newblock, goal = 0;
1317 struct ext4_super_block *es = EXT4_SB 1310 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
1318 int err = 0; 1311 int err = 0;
1319 size_t ext_size = 0; 1312 size_t ext_size = 0;
1320 1313
1321 /* Try to prepend new index to old on 1314 /* Try to prepend new index to old one */
1322 if (ext_depth(inode)) 1315 if (ext_depth(inode))
1323 goal = ext4_idx_pblock(EXT_FI 1316 goal = ext4_idx_pblock(EXT_FIRST_INDEX(ext_inode_hdr(inode)));
1324 if (goal > le32_to_cpu(es->s_first_da 1317 if (goal > le32_to_cpu(es->s_first_data_block)) {
1325 flags |= EXT4_MB_HINT_TRY_GOA 1318 flags |= EXT4_MB_HINT_TRY_GOAL;
1326 goal--; 1319 goal--;
1327 } else 1320 } else
1328 goal = ext4_inode_to_goal_blo 1321 goal = ext4_inode_to_goal_block(inode);
1329 newblock = ext4_new_meta_blocks(handl 1322 newblock = ext4_new_meta_blocks(handle, inode, goal, flags,
1330 NULL, 1323 NULL, &err);
1331 if (newblock == 0) 1324 if (newblock == 0)
1332 return err; 1325 return err;
1333 1326
1334 bh = sb_getblk_gfp(inode->i_sb, newbl 1327 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
1335 if (unlikely(!bh)) 1328 if (unlikely(!bh))
1336 return -ENOMEM; 1329 return -ENOMEM;
1337 lock_buffer(bh); 1330 lock_buffer(bh);
1338 1331
1339 err = ext4_journal_get_create_access( !! 1332 err = ext4_journal_get_create_access(handle, bh);
1340 <<
1341 if (err) { 1333 if (err) {
1342 unlock_buffer(bh); 1334 unlock_buffer(bh);
1343 goto out; 1335 goto out;
1344 } 1336 }
1345 1337
1346 ext_size = sizeof(EXT4_I(inode)->i_da 1338 ext_size = sizeof(EXT4_I(inode)->i_data);
1347 /* move top-level index/leaf into new 1339 /* move top-level index/leaf into new block */
1348 memmove(bh->b_data, EXT4_I(inode)->i_ 1340 memmove(bh->b_data, EXT4_I(inode)->i_data, ext_size);
1349 /* zero out unused area in the extent 1341 /* zero out unused area in the extent block */
1350 memset(bh->b_data + ext_size, 0, inod 1342 memset(bh->b_data + ext_size, 0, inode->i_sb->s_blocksize - ext_size);
1351 1343
1352 /* set size of new block */ 1344 /* set size of new block */
1353 neh = ext_block_hdr(bh); 1345 neh = ext_block_hdr(bh);
1354 /* old root could have indexes or lea 1346 /* old root could have indexes or leaves
1355 * so calculate e_max right way */ 1347 * so calculate e_max right way */
1356 if (ext_depth(inode)) 1348 if (ext_depth(inode))
1357 neh->eh_max = cpu_to_le16(ext 1349 neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0));
1358 else 1350 else
1359 neh->eh_max = cpu_to_le16(ext 1351 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
1360 neh->eh_magic = EXT4_EXT_MAGIC; 1352 neh->eh_magic = EXT4_EXT_MAGIC;
1361 ext4_extent_block_csum_set(inode, neh 1353 ext4_extent_block_csum_set(inode, neh);
1362 set_buffer_uptodate(bh); 1354 set_buffer_uptodate(bh);
1363 set_buffer_verified(bh); <<
1364 unlock_buffer(bh); 1355 unlock_buffer(bh);
1365 1356
1366 err = ext4_handle_dirty_metadata(hand 1357 err = ext4_handle_dirty_metadata(handle, inode, bh);
1367 if (err) 1358 if (err)
1368 goto out; 1359 goto out;
1369 1360
1370 /* Update top-level index: num,max,po 1361 /* Update top-level index: num,max,pointer */
1371 neh = ext_inode_hdr(inode); 1362 neh = ext_inode_hdr(inode);
1372 neh->eh_entries = cpu_to_le16(1); 1363 neh->eh_entries = cpu_to_le16(1);
1373 ext4_idx_store_pblock(EXT_FIRST_INDEX 1364 ext4_idx_store_pblock(EXT_FIRST_INDEX(neh), newblock);
1374 if (neh->eh_depth == 0) { 1365 if (neh->eh_depth == 0) {
1375 /* Root extent block becomes 1366 /* Root extent block becomes index block */
1376 neh->eh_max = cpu_to_le16(ext 1367 neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0));
1377 EXT_FIRST_INDEX(neh)->ei_bloc 1368 EXT_FIRST_INDEX(neh)->ei_block =
1378 EXT_FIRST_EXTENT(neh) 1369 EXT_FIRST_EXTENT(neh)->ee_block;
1379 } 1370 }
1380 ext_debug(inode, "new root: num %d(%d 1371 ext_debug(inode, "new root: num %d(%d), lblock %d, ptr %llu\n",
1381 le16_to_cpu(neh->eh_entries 1372 le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),
1382 le32_to_cpu(EXT_FIRST_INDEX 1373 le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block),
1383 ext4_idx_pblock(EXT_FIRST_I 1374 ext4_idx_pblock(EXT_FIRST_INDEX(neh)));
1384 1375
1385 le16_add_cpu(&neh->eh_depth, 1); 1376 le16_add_cpu(&neh->eh_depth, 1);
1386 err = ext4_mark_inode_dirty(handle, i 1377 err = ext4_mark_inode_dirty(handle, inode);
1387 out: 1378 out:
1388 brelse(bh); 1379 brelse(bh);
1389 1380
1390 return err; 1381 return err;
1391 } 1382 }
1392 1383
1393 /* 1384 /*
1394 * ext4_ext_create_new_leaf: 1385 * ext4_ext_create_new_leaf:
1395 * finds empty index and adds new leaf. 1386 * finds empty index and adds new leaf.
1396 * if no free index is found, then it request 1387 * if no free index is found, then it requests in-depth growing.
1397 */ 1388 */
1398 static struct ext4_ext_path * !! 1389 static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode,
1399 ext4_ext_create_new_leaf(handle_t *handle, st !! 1390 unsigned int mb_flags,
1400 unsigned int mb_flag !! 1391 unsigned int gb_flags,
1401 struct ext4_ext_path !! 1392 struct ext4_ext_path **ppath,
1402 struct ext4_extent * !! 1393 struct ext4_extent *newext)
1403 { 1394 {
>> 1395 struct ext4_ext_path *path = *ppath;
1404 struct ext4_ext_path *curp; 1396 struct ext4_ext_path *curp;
1405 int depth, i, err = 0; 1397 int depth, i, err = 0;
1406 ext4_lblk_t ee_block = le32_to_cpu(ne <<
1407 1398
1408 repeat: 1399 repeat:
1409 i = depth = ext_depth(inode); 1400 i = depth = ext_depth(inode);
1410 1401
1411 /* walk up to the tree and look for f 1402 /* walk up to the tree and look for free index entry */
1412 curp = path + depth; 1403 curp = path + depth;
1413 while (i > 0 && !EXT_HAS_FREE_INDEX(c 1404 while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) {
1414 i--; 1405 i--;
1415 curp--; 1406 curp--;
1416 } 1407 }
1417 1408
1418 /* we use already allocated block for 1409 /* we use already allocated block for index block,
1419 * so subsequent data blocks should b 1410 * so subsequent data blocks should be contiguous */
1420 if (EXT_HAS_FREE_INDEX(curp)) { 1411 if (EXT_HAS_FREE_INDEX(curp)) {
1421 /* if we found index with fre 1412 /* if we found index with free entry, then use that
1422 * entry: create all needed s 1413 * entry: create all needed subtree and add new leaf */
1423 err = ext4_ext_split(handle, 1414 err = ext4_ext_split(handle, inode, mb_flags, path, newext, i);
1424 if (err) 1415 if (err)
1425 goto errout; !! 1416 goto out;
1426 1417
1427 /* refill path */ 1418 /* refill path */
1428 path = ext4_find_extent(inode !! 1419 path = ext4_find_extent(inode,
1429 return path; !! 1420 (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1430 } !! 1421 ppath, gb_flags);
1431 !! 1422 if (IS_ERR(path))
1432 /* tree is full, time to grow in dept !! 1423 err = PTR_ERR(path);
1433 err = ext4_ext_grow_indepth(handle, i !! 1424 } else {
1434 if (err) !! 1425 /* tree is full, time to grow in depth */
1435 goto errout; !! 1426 err = ext4_ext_grow_indepth(handle, inode, mb_flags);
>> 1427 if (err)
>> 1428 goto out;
1436 1429
1437 /* refill path */ !! 1430 /* refill path */
1438 path = ext4_find_extent(inode, ee_blo !! 1431 path = ext4_find_extent(inode,
1439 if (IS_ERR(path)) !! 1432 (ext4_lblk_t)le32_to_cpu(newext->ee_block),
1440 return path; !! 1433 ppath, gb_flags);
>> 1434 if (IS_ERR(path)) {
>> 1435 err = PTR_ERR(path);
>> 1436 goto out;
>> 1437 }
1441 1438
1442 /* !! 1439 /*
1443 * only first (depth 0 -> 1) produces !! 1440 * only first (depth 0 -> 1) produces free space;
1444 * in all other cases we have to spli !! 1441 * in all other cases we have to split the grown tree
1445 */ !! 1442 */
1446 depth = ext_depth(inode); !! 1443 depth = ext_depth(inode);
1447 if (path[depth].p_hdr->eh_entries == !! 1444 if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
1448 /* now we need to split */ !! 1445 /* now we need to split */
1449 goto repeat; !! 1446 goto repeat;
>> 1447 }
1450 } 1448 }
1451 1449
1452 return path; !! 1450 out:
1453 !! 1451 return err;
1454 errout: <<
1455 ext4_free_ext_path(path); <<
1456 return ERR_PTR(err); <<
1457 } 1452 }
1458 1453
1459 /* 1454 /*
1460 * search the closest allocated block to the 1455 * search the closest allocated block to the left for *logical
1461 * and returns it at @logical + it's physical 1456 * and returns it at @logical + it's physical address at @phys
1462 * if *logical is the smallest allocated bloc 1457 * if *logical is the smallest allocated block, the function
1463 * returns 0 at @phys 1458 * returns 0 at @phys
1464 * return value contains 0 (success) or error 1459 * return value contains 0 (success) or error code
1465 */ 1460 */
1466 static int ext4_ext_search_left(struct inode 1461 static int ext4_ext_search_left(struct inode *inode,
1467 struct ext4_e 1462 struct ext4_ext_path *path,
1468 ext4_lblk_t * 1463 ext4_lblk_t *logical, ext4_fsblk_t *phys)
1469 { 1464 {
1470 struct ext4_extent_idx *ix; 1465 struct ext4_extent_idx *ix;
1471 struct ext4_extent *ex; 1466 struct ext4_extent *ex;
1472 int depth, ee_len; 1467 int depth, ee_len;
1473 1468
1474 if (unlikely(path == NULL)) { 1469 if (unlikely(path == NULL)) {
1475 EXT4_ERROR_INODE(inode, "path 1470 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1476 return -EFSCORRUPTED; 1471 return -EFSCORRUPTED;
1477 } 1472 }
1478 depth = path->p_depth; 1473 depth = path->p_depth;
1479 *phys = 0; 1474 *phys = 0;
1480 1475
1481 if (depth == 0 && path->p_ext == NULL 1476 if (depth == 0 && path->p_ext == NULL)
1482 return 0; 1477 return 0;
1483 1478
1484 /* usually extent in the path covers 1479 /* usually extent in the path covers blocks smaller
1485 * then *logical, but it can be that 1480 * then *logical, but it can be that extent is the
1486 * first one in the file */ 1481 * first one in the file */
1487 1482
1488 ex = path[depth].p_ext; 1483 ex = path[depth].p_ext;
1489 ee_len = ext4_ext_get_actual_len(ex); 1484 ee_len = ext4_ext_get_actual_len(ex);
1490 if (*logical < le32_to_cpu(ex->ee_blo 1485 if (*logical < le32_to_cpu(ex->ee_block)) {
1491 if (unlikely(EXT_FIRST_EXTENT 1486 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1492 EXT4_ERROR_INODE(inod 1487 EXT4_ERROR_INODE(inode,
1493 "EXT 1488 "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!",
1494 *log 1489 *logical, le32_to_cpu(ex->ee_block));
1495 return -EFSCORRUPTED; 1490 return -EFSCORRUPTED;
1496 } 1491 }
1497 while (--depth >= 0) { 1492 while (--depth >= 0) {
1498 ix = path[depth].p_id 1493 ix = path[depth].p_idx;
1499 if (unlikely(ix != EX 1494 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1500 EXT4_ERROR_IN 1495 EXT4_ERROR_INODE(inode,
1501 "ix (%d) != 1496 "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!",
1502 ix != NULL 1497 ix != NULL ? le32_to_cpu(ix->ei_block) : 0,
1503 le32_to_cpu !! 1498 EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?
>> 1499 le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0,
1504 depth); 1500 depth);
1505 return -EFSCO 1501 return -EFSCORRUPTED;
1506 } 1502 }
1507 } 1503 }
1508 return 0; 1504 return 0;
1509 } 1505 }
1510 1506
1511 if (unlikely(*logical < (le32_to_cpu( 1507 if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1512 EXT4_ERROR_INODE(inode, 1508 EXT4_ERROR_INODE(inode,
1513 "logical %d 1509 "logical %d < ee_block %d + ee_len %d!",
1514 *logical, le 1510 *logical, le32_to_cpu(ex->ee_block), ee_len);
1515 return -EFSCORRUPTED; 1511 return -EFSCORRUPTED;
1516 } 1512 }
1517 1513
1518 *logical = le32_to_cpu(ex->ee_block) 1514 *logical = le32_to_cpu(ex->ee_block) + ee_len - 1;
1519 *phys = ext4_ext_pblock(ex) + ee_len 1515 *phys = ext4_ext_pblock(ex) + ee_len - 1;
1520 return 0; 1516 return 0;
1521 } 1517 }
1522 1518
1523 /* 1519 /*
1524 * Search the closest allocated block to the 1520 * Search the closest allocated block to the right for *logical
1525 * and returns it at @logical + it's physical 1521 * and returns it at @logical + it's physical address at @phys.
1526 * If not exists, return 0 and @phys is set t 1522 * If not exists, return 0 and @phys is set to 0. We will return
1527 * 1 which means we found an allocated block 1523 * 1 which means we found an allocated block and ret_ex is valid.
1528 * Or return a (< 0) error code. 1524 * Or return a (< 0) error code.
1529 */ 1525 */
1530 static int ext4_ext_search_right(struct inode 1526 static int ext4_ext_search_right(struct inode *inode,
1531 struct ext4_ 1527 struct ext4_ext_path *path,
1532 ext4_lblk_t 1528 ext4_lblk_t *logical, ext4_fsblk_t *phys,
1533 struct ext4_ 1529 struct ext4_extent *ret_ex)
1534 { 1530 {
1535 struct buffer_head *bh = NULL; 1531 struct buffer_head *bh = NULL;
1536 struct ext4_extent_header *eh; 1532 struct ext4_extent_header *eh;
1537 struct ext4_extent_idx *ix; 1533 struct ext4_extent_idx *ix;
1538 struct ext4_extent *ex; 1534 struct ext4_extent *ex;
1539 int depth; /* Note, NOT eh_depth 1535 int depth; /* Note, NOT eh_depth; depth from top of tree */
1540 int ee_len; 1536 int ee_len;
1541 1537
1542 if (unlikely(path == NULL)) { 1538 if (unlikely(path == NULL)) {
1543 EXT4_ERROR_INODE(inode, "path 1539 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1544 return -EFSCORRUPTED; 1540 return -EFSCORRUPTED;
1545 } 1541 }
1546 depth = path->p_depth; 1542 depth = path->p_depth;
1547 *phys = 0; 1543 *phys = 0;
1548 1544
1549 if (depth == 0 && path->p_ext == NULL 1545 if (depth == 0 && path->p_ext == NULL)
1550 return 0; 1546 return 0;
1551 1547
1552 /* usually extent in the path covers 1548 /* usually extent in the path covers blocks smaller
1553 * then *logical, but it can be that 1549 * then *logical, but it can be that extent is the
1554 * first one in the file */ 1550 * first one in the file */
1555 1551
1556 ex = path[depth].p_ext; 1552 ex = path[depth].p_ext;
1557 ee_len = ext4_ext_get_actual_len(ex); 1553 ee_len = ext4_ext_get_actual_len(ex);
1558 if (*logical < le32_to_cpu(ex->ee_blo 1554 if (*logical < le32_to_cpu(ex->ee_block)) {
1559 if (unlikely(EXT_FIRST_EXTENT 1555 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1560 EXT4_ERROR_INODE(inod 1556 EXT4_ERROR_INODE(inode,
1561 "fir 1557 "first_extent(path[%d].p_hdr) != ex",
1562 dept 1558 depth);
1563 return -EFSCORRUPTED; 1559 return -EFSCORRUPTED;
1564 } 1560 }
1565 while (--depth >= 0) { 1561 while (--depth >= 0) {
1566 ix = path[depth].p_id 1562 ix = path[depth].p_idx;
1567 if (unlikely(ix != EX 1563 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1568 EXT4_ERROR_IN 1564 EXT4_ERROR_INODE(inode,
1569 1565 "ix != EXT_FIRST_INDEX *logical %d!",
1570 1566 *logical);
1571 return -EFSCO 1567 return -EFSCORRUPTED;
1572 } 1568 }
1573 } 1569 }
1574 goto found_extent; 1570 goto found_extent;
1575 } 1571 }
1576 1572
1577 if (unlikely(*logical < (le32_to_cpu( 1573 if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) {
1578 EXT4_ERROR_INODE(inode, 1574 EXT4_ERROR_INODE(inode,
1579 "logical %d 1575 "logical %d < ee_block %d + ee_len %d!",
1580 *logical, le 1576 *logical, le32_to_cpu(ex->ee_block), ee_len);
1581 return -EFSCORRUPTED; 1577 return -EFSCORRUPTED;
1582 } 1578 }
1583 1579
1584 if (ex != EXT_LAST_EXTENT(path[depth] 1580 if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
1585 /* next allocated block in th 1581 /* next allocated block in this leaf */
1586 ex++; 1582 ex++;
1587 goto found_extent; 1583 goto found_extent;
1588 } 1584 }
1589 1585
1590 /* go up and search for index to the 1586 /* go up and search for index to the right */
1591 while (--depth >= 0) { 1587 while (--depth >= 0) {
1592 ix = path[depth].p_idx; 1588 ix = path[depth].p_idx;
1593 if (ix != EXT_LAST_INDEX(path 1589 if (ix != EXT_LAST_INDEX(path[depth].p_hdr))
1594 goto got_index; 1590 goto got_index;
1595 } 1591 }
1596 1592
1597 /* we've gone up to the root and foun 1593 /* we've gone up to the root and found no index to the right */
1598 return 0; 1594 return 0;
1599 1595
1600 got_index: 1596 got_index:
1601 /* we've found index to the right, le 1597 /* we've found index to the right, let's
1602 * follow it and find the closest all 1598 * follow it and find the closest allocated
1603 * block to the right */ 1599 * block to the right */
1604 ix++; 1600 ix++;
1605 while (++depth < path->p_depth) { 1601 while (++depth < path->p_depth) {
1606 /* subtract from p_depth to g 1602 /* subtract from p_depth to get proper eh_depth */
1607 bh = read_extent_tree_block(i 1603 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1608 if (IS_ERR(bh)) 1604 if (IS_ERR(bh))
1609 return PTR_ERR(bh); 1605 return PTR_ERR(bh);
1610 eh = ext_block_hdr(bh); 1606 eh = ext_block_hdr(bh);
1611 ix = EXT_FIRST_INDEX(eh); 1607 ix = EXT_FIRST_INDEX(eh);
1612 put_bh(bh); 1608 put_bh(bh);
1613 } 1609 }
1614 1610
1615 bh = read_extent_tree_block(inode, ix 1611 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1616 if (IS_ERR(bh)) 1612 if (IS_ERR(bh))
1617 return PTR_ERR(bh); 1613 return PTR_ERR(bh);
1618 eh = ext_block_hdr(bh); 1614 eh = ext_block_hdr(bh);
1619 ex = EXT_FIRST_EXTENT(eh); 1615 ex = EXT_FIRST_EXTENT(eh);
1620 found_extent: 1616 found_extent:
1621 *logical = le32_to_cpu(ex->ee_block); 1617 *logical = le32_to_cpu(ex->ee_block);
1622 *phys = ext4_ext_pblock(ex); 1618 *phys = ext4_ext_pblock(ex);
1623 if (ret_ex) 1619 if (ret_ex)
1624 *ret_ex = *ex; 1620 *ret_ex = *ex;
1625 if (bh) 1621 if (bh)
1626 put_bh(bh); 1622 put_bh(bh);
1627 return 1; 1623 return 1;
1628 } 1624 }
1629 1625
1630 /* 1626 /*
1631 * ext4_ext_next_allocated_block: 1627 * ext4_ext_next_allocated_block:
1632 * returns allocated block in subsequent exte 1628 * returns allocated block in subsequent extent or EXT_MAX_BLOCKS.
1633 * NOTE: it considers block number from index 1629 * NOTE: it considers block number from index entry as
1634 * allocated block. Thus, index entries have 1630 * allocated block. Thus, index entries have to be consistent
1635 * with leaves. 1631 * with leaves.
1636 */ 1632 */
1637 ext4_lblk_t 1633 ext4_lblk_t
1638 ext4_ext_next_allocated_block(struct ext4_ext 1634 ext4_ext_next_allocated_block(struct ext4_ext_path *path)
1639 { 1635 {
1640 int depth; 1636 int depth;
1641 1637
1642 BUG_ON(path == NULL); 1638 BUG_ON(path == NULL);
1643 depth = path->p_depth; 1639 depth = path->p_depth;
1644 1640
1645 if (depth == 0 && path->p_ext == NULL 1641 if (depth == 0 && path->p_ext == NULL)
1646 return EXT_MAX_BLOCKS; 1642 return EXT_MAX_BLOCKS;
1647 1643
1648 while (depth >= 0) { 1644 while (depth >= 0) {
1649 struct ext4_ext_path *p = &pa 1645 struct ext4_ext_path *p = &path[depth];
1650 1646
1651 if (depth == path->p_depth) { 1647 if (depth == path->p_depth) {
1652 /* leaf */ 1648 /* leaf */
1653 if (p->p_ext && p->p_ 1649 if (p->p_ext && p->p_ext != EXT_LAST_EXTENT(p->p_hdr))
1654 return le32_t 1650 return le32_to_cpu(p->p_ext[1].ee_block);
1655 } else { 1651 } else {
1656 /* index */ 1652 /* index */
1657 if (p->p_idx != EXT_L 1653 if (p->p_idx != EXT_LAST_INDEX(p->p_hdr))
1658 return le32_t 1654 return le32_to_cpu(p->p_idx[1].ei_block);
1659 } 1655 }
1660 depth--; 1656 depth--;
1661 } 1657 }
1662 1658
1663 return EXT_MAX_BLOCKS; 1659 return EXT_MAX_BLOCKS;
1664 } 1660 }
1665 1661
1666 /* 1662 /*
1667 * ext4_ext_next_leaf_block: 1663 * ext4_ext_next_leaf_block:
1668 * returns first allocated block from next le 1664 * returns first allocated block from next leaf or EXT_MAX_BLOCKS
1669 */ 1665 */
1670 static ext4_lblk_t ext4_ext_next_leaf_block(s 1666 static ext4_lblk_t ext4_ext_next_leaf_block(struct ext4_ext_path *path)
1671 { 1667 {
1672 int depth; 1668 int depth;
1673 1669
1674 BUG_ON(path == NULL); 1670 BUG_ON(path == NULL);
1675 depth = path->p_depth; 1671 depth = path->p_depth;
1676 1672
1677 /* zero-tree has no leaf blocks at al 1673 /* zero-tree has no leaf blocks at all */
1678 if (depth == 0) 1674 if (depth == 0)
1679 return EXT_MAX_BLOCKS; 1675 return EXT_MAX_BLOCKS;
1680 1676
1681 /* go to index block */ 1677 /* go to index block */
1682 depth--; 1678 depth--;
1683 1679
1684 while (depth >= 0) { 1680 while (depth >= 0) {
1685 if (path[depth].p_idx != 1681 if (path[depth].p_idx !=
1686 EXT_LAST_INDE 1682 EXT_LAST_INDEX(path[depth].p_hdr))
1687 return (ext4_lblk_t) 1683 return (ext4_lblk_t)
1688 le32_to_cpu(p 1684 le32_to_cpu(path[depth].p_idx[1].ei_block);
1689 depth--; 1685 depth--;
1690 } 1686 }
1691 1687
1692 return EXT_MAX_BLOCKS; 1688 return EXT_MAX_BLOCKS;
1693 } 1689 }
1694 1690
1695 /* 1691 /*
1696 * ext4_ext_correct_indexes: 1692 * ext4_ext_correct_indexes:
1697 * if leaf gets modified and modified extent 1693 * if leaf gets modified and modified extent is first in the leaf,
1698 * then we have to correct all indexes above. 1694 * then we have to correct all indexes above.
1699 * TODO: do we need to correct tree in all ca 1695 * TODO: do we need to correct tree in all cases?
1700 */ 1696 */
1701 static int ext4_ext_correct_indexes(handle_t 1697 static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
1702 struct ext4_e 1698 struct ext4_ext_path *path)
1703 { 1699 {
1704 struct ext4_extent_header *eh; 1700 struct ext4_extent_header *eh;
1705 int depth = ext_depth(inode); 1701 int depth = ext_depth(inode);
1706 struct ext4_extent *ex; 1702 struct ext4_extent *ex;
1707 __le32 border; 1703 __le32 border;
1708 int k, err = 0; 1704 int k, err = 0;
1709 1705
1710 eh = path[depth].p_hdr; 1706 eh = path[depth].p_hdr;
1711 ex = path[depth].p_ext; 1707 ex = path[depth].p_ext;
1712 1708
1713 if (unlikely(ex == NULL || eh == NULL 1709 if (unlikely(ex == NULL || eh == NULL)) {
1714 EXT4_ERROR_INODE(inode, 1710 EXT4_ERROR_INODE(inode,
1715 "ex %p == NU 1711 "ex %p == NULL or eh %p == NULL", ex, eh);
1716 return -EFSCORRUPTED; 1712 return -EFSCORRUPTED;
1717 } 1713 }
1718 1714
1719 if (depth == 0) { 1715 if (depth == 0) {
1720 /* there is no tree at all */ 1716 /* there is no tree at all */
1721 return 0; 1717 return 0;
1722 } 1718 }
1723 1719
1724 if (ex != EXT_FIRST_EXTENT(eh)) { 1720 if (ex != EXT_FIRST_EXTENT(eh)) {
1725 /* we correct tree if first l 1721 /* we correct tree if first leaf got modified only */
1726 return 0; 1722 return 0;
1727 } 1723 }
1728 1724
1729 /* 1725 /*
1730 * TODO: we need correction if border 1726 * TODO: we need correction if border is smaller than current one
1731 */ 1727 */
1732 k = depth - 1; 1728 k = depth - 1;
1733 border = path[depth].p_ext->ee_block; 1729 border = path[depth].p_ext->ee_block;
1734 err = ext4_ext_get_access(handle, ino 1730 err = ext4_ext_get_access(handle, inode, path + k);
1735 if (err) 1731 if (err)
1736 return err; 1732 return err;
1737 path[k].p_idx->ei_block = border; 1733 path[k].p_idx->ei_block = border;
1738 err = ext4_ext_dirty(handle, inode, p 1734 err = ext4_ext_dirty(handle, inode, path + k);
1739 if (err) 1735 if (err)
1740 return err; 1736 return err;
1741 1737
1742 while (k--) { 1738 while (k--) {
1743 /* change all left-side index 1739 /* change all left-side indexes */
1744 if (path[k+1].p_idx != EXT_FI 1740 if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr))
1745 break; 1741 break;
1746 err = ext4_ext_get_access(han 1742 err = ext4_ext_get_access(handle, inode, path + k);
1747 if (err) 1743 if (err)
1748 goto clean; !! 1744 break;
1749 path[k].p_idx->ei_block = bor 1745 path[k].p_idx->ei_block = border;
1750 err = ext4_ext_dirty(handle, 1746 err = ext4_ext_dirty(handle, inode, path + k);
1751 if (err) 1747 if (err)
1752 goto clean; !! 1748 break;
1753 } 1749 }
1754 return 0; <<
1755 <<
1756 clean: <<
1757 /* <<
1758 * The path[k].p_bh is either unmodif <<
1759 * set (see ext4_ext_get_access()). S <<
1760 * of the successfully modified exten <<
1761 * these extents to be checked to avo <<
1762 */ <<
1763 while (++k < depth) <<
1764 clear_buffer_verified(path[k] <<
1765 1750
1766 return err; 1751 return err;
1767 } 1752 }
1768 1753
1769 static int ext4_can_extents_be_merged(struct 1754 static int ext4_can_extents_be_merged(struct inode *inode,
1770 struct 1755 struct ext4_extent *ex1,
1771 struct 1756 struct ext4_extent *ex2)
1772 { 1757 {
1773 unsigned short ext1_ee_len, ext2_ee_l 1758 unsigned short ext1_ee_len, ext2_ee_len;
1774 1759
1775 if (ext4_ext_is_unwritten(ex1) != ext 1760 if (ext4_ext_is_unwritten(ex1) != ext4_ext_is_unwritten(ex2))
1776 return 0; 1761 return 0;
1777 1762
1778 ext1_ee_len = ext4_ext_get_actual_len 1763 ext1_ee_len = ext4_ext_get_actual_len(ex1);
1779 ext2_ee_len = ext4_ext_get_actual_len 1764 ext2_ee_len = ext4_ext_get_actual_len(ex2);
1780 1765
1781 if (le32_to_cpu(ex1->ee_block) + ext1 1766 if (le32_to_cpu(ex1->ee_block) + ext1_ee_len !=
1782 le32_to_cpu(ex2->ee_b 1767 le32_to_cpu(ex2->ee_block))
1783 return 0; 1768 return 0;
1784 1769
1785 if (ext1_ee_len + ext2_ee_len > EXT_I 1770 if (ext1_ee_len + ext2_ee_len > EXT_INIT_MAX_LEN)
1786 return 0; 1771 return 0;
1787 1772
1788 if (ext4_ext_is_unwritten(ex1) && 1773 if (ext4_ext_is_unwritten(ex1) &&
1789 ext1_ee_len + ext2_ee_len > EXT_U 1774 ext1_ee_len + ext2_ee_len > EXT_UNWRITTEN_MAX_LEN)
1790 return 0; 1775 return 0;
1791 #ifdef AGGRESSIVE_TEST 1776 #ifdef AGGRESSIVE_TEST
1792 if (ext1_ee_len >= 4) 1777 if (ext1_ee_len >= 4)
1793 return 0; 1778 return 0;
1794 #endif 1779 #endif
1795 1780
1796 if (ext4_ext_pblock(ex1) + ext1_ee_le 1781 if (ext4_ext_pblock(ex1) + ext1_ee_len == ext4_ext_pblock(ex2))
1797 return 1; 1782 return 1;
1798 return 0; 1783 return 0;
1799 } 1784 }
1800 1785
1801 /* 1786 /*
1802 * This function tries to merge the "ex" exte 1787 * This function tries to merge the "ex" extent to the next extent in the tree.
1803 * It always tries to merge towards right. If 1788 * It always tries to merge towards right. If you want to merge towards
1804 * left, pass "ex - 1" as argument instead of 1789 * left, pass "ex - 1" as argument instead of "ex".
1805 * Returns 0 if the extents (ex and ex+1) wer 1790 * Returns 0 if the extents (ex and ex+1) were _not_ merged and returns
1806 * 1 if they got merged. 1791 * 1 if they got merged.
1807 */ 1792 */
1808 static int ext4_ext_try_to_merge_right(struct 1793 static int ext4_ext_try_to_merge_right(struct inode *inode,
1809 struct ext4_ 1794 struct ext4_ext_path *path,
1810 struct ext4_ 1795 struct ext4_extent *ex)
1811 { 1796 {
1812 struct ext4_extent_header *eh; 1797 struct ext4_extent_header *eh;
1813 unsigned int depth, len; 1798 unsigned int depth, len;
1814 int merge_done = 0, unwritten; 1799 int merge_done = 0, unwritten;
1815 1800
1816 depth = ext_depth(inode); 1801 depth = ext_depth(inode);
1817 BUG_ON(path[depth].p_hdr == NULL); 1802 BUG_ON(path[depth].p_hdr == NULL);
1818 eh = path[depth].p_hdr; 1803 eh = path[depth].p_hdr;
1819 1804
1820 while (ex < EXT_LAST_EXTENT(eh)) { 1805 while (ex < EXT_LAST_EXTENT(eh)) {
1821 if (!ext4_can_extents_be_merg 1806 if (!ext4_can_extents_be_merged(inode, ex, ex + 1))
1822 break; 1807 break;
1823 /* merge with next extent! */ 1808 /* merge with next extent! */
1824 unwritten = ext4_ext_is_unwri 1809 unwritten = ext4_ext_is_unwritten(ex);
1825 ex->ee_len = cpu_to_le16(ext4 1810 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
1826 + ext4_ext_ge 1811 + ext4_ext_get_actual_len(ex + 1));
1827 if (unwritten) 1812 if (unwritten)
1828 ext4_ext_mark_unwritt 1813 ext4_ext_mark_unwritten(ex);
1829 1814
1830 if (ex + 1 < EXT_LAST_EXTENT( 1815 if (ex + 1 < EXT_LAST_EXTENT(eh)) {
1831 len = (EXT_LAST_EXTEN 1816 len = (EXT_LAST_EXTENT(eh) - ex - 1)
1832 * sizeof(stru 1817 * sizeof(struct ext4_extent);
1833 memmove(ex + 1, ex + 1818 memmove(ex + 1, ex + 2, len);
1834 } 1819 }
1835 le16_add_cpu(&eh->eh_entries, 1820 le16_add_cpu(&eh->eh_entries, -1);
1836 merge_done = 1; 1821 merge_done = 1;
1837 WARN_ON(eh->eh_entries == 0); 1822 WARN_ON(eh->eh_entries == 0);
1838 if (!eh->eh_entries) 1823 if (!eh->eh_entries)
1839 EXT4_ERROR_INODE(inod 1824 EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!");
1840 } 1825 }
1841 1826
1842 return merge_done; 1827 return merge_done;
1843 } 1828 }
1844 1829
1845 /* 1830 /*
1846 * This function does a very simple check to 1831 * This function does a very simple check to see if we can collapse
1847 * an extent tree with a single extent tree l 1832 * an extent tree with a single extent tree leaf block into the inode.
1848 */ 1833 */
1849 static void ext4_ext_try_to_merge_up(handle_t 1834 static void ext4_ext_try_to_merge_up(handle_t *handle,
1850 struct i 1835 struct inode *inode,
1851 struct e 1836 struct ext4_ext_path *path)
1852 { 1837 {
1853 size_t s; 1838 size_t s;
1854 unsigned max_root = ext4_ext_space_ro 1839 unsigned max_root = ext4_ext_space_root(inode, 0);
1855 ext4_fsblk_t blk; 1840 ext4_fsblk_t blk;
1856 1841
1857 if ((path[0].p_depth != 1) || 1842 if ((path[0].p_depth != 1) ||
1858 (le16_to_cpu(path[0].p_hdr->eh_en 1843 (le16_to_cpu(path[0].p_hdr->eh_entries) != 1) ||
1859 (le16_to_cpu(path[1].p_hdr->eh_en 1844 (le16_to_cpu(path[1].p_hdr->eh_entries) > max_root))
1860 return; 1845 return;
1861 1846
1862 /* 1847 /*
1863 * We need to modify the block alloca 1848 * We need to modify the block allocation bitmap and the block
1864 * group descriptor to release the ex 1849 * group descriptor to release the extent tree block. If we
1865 * can't get the journal credits, giv 1850 * can't get the journal credits, give up.
1866 */ 1851 */
1867 if (ext4_journal_extend(handle, 2, 1852 if (ext4_journal_extend(handle, 2,
1868 ext4_free_metadata_re 1853 ext4_free_metadata_revoke_credits(inode->i_sb, 1)))
1869 return; 1854 return;
1870 1855
1871 /* 1856 /*
1872 * Copy the extent data up to the ino 1857 * Copy the extent data up to the inode
1873 */ 1858 */
1874 blk = ext4_idx_pblock(path[0].p_idx); 1859 blk = ext4_idx_pblock(path[0].p_idx);
1875 s = le16_to_cpu(path[1].p_hdr->eh_ent 1860 s = le16_to_cpu(path[1].p_hdr->eh_entries) *
1876 sizeof(struct ext4_extent_idx 1861 sizeof(struct ext4_extent_idx);
1877 s += sizeof(struct ext4_extent_header 1862 s += sizeof(struct ext4_extent_header);
1878 1863
1879 path[1].p_maxdepth = path[0].p_maxdep 1864 path[1].p_maxdepth = path[0].p_maxdepth;
1880 memcpy(path[0].p_hdr, path[1].p_hdr, 1865 memcpy(path[0].p_hdr, path[1].p_hdr, s);
1881 path[0].p_depth = 0; 1866 path[0].p_depth = 0;
1882 path[0].p_ext = EXT_FIRST_EXTENT(path 1867 path[0].p_ext = EXT_FIRST_EXTENT(path[0].p_hdr) +
1883 (path[1].p_ext - EXT_FIRST_EX 1868 (path[1].p_ext - EXT_FIRST_EXTENT(path[1].p_hdr));
1884 path[0].p_hdr->eh_max = cpu_to_le16(m 1869 path[0].p_hdr->eh_max = cpu_to_le16(max_root);
1885 1870
1886 ext4_ext_path_brelse(path + 1); !! 1871 brelse(path[1].p_bh);
>> 1872 path[1].p_bh = NULL;
1887 ext4_free_blocks(handle, inode, NULL, 1873 ext4_free_blocks(handle, inode, NULL, blk, 1,
1888 EXT4_FREE_BLOCKS_MET 1874 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
1889 } 1875 }
1890 1876
1891 /* 1877 /*
1892 * This function tries to merge the @ex exten 1878 * This function tries to merge the @ex extent to neighbours in the tree, then
1893 * tries to collapse the extent tree into the 1879 * tries to collapse the extent tree into the inode.
1894 */ 1880 */
1895 static void ext4_ext_try_to_merge(handle_t *h 1881 static void ext4_ext_try_to_merge(handle_t *handle,
1896 struct inod 1882 struct inode *inode,
1897 struct ext4 1883 struct ext4_ext_path *path,
1898 struct ext4 1884 struct ext4_extent *ex)
1899 { 1885 {
1900 struct ext4_extent_header *eh; 1886 struct ext4_extent_header *eh;
1901 unsigned int depth; 1887 unsigned int depth;
1902 int merge_done = 0; 1888 int merge_done = 0;
1903 1889
1904 depth = ext_depth(inode); 1890 depth = ext_depth(inode);
1905 BUG_ON(path[depth].p_hdr == NULL); 1891 BUG_ON(path[depth].p_hdr == NULL);
1906 eh = path[depth].p_hdr; 1892 eh = path[depth].p_hdr;
1907 1893
1908 if (ex > EXT_FIRST_EXTENT(eh)) 1894 if (ex > EXT_FIRST_EXTENT(eh))
1909 merge_done = ext4_ext_try_to_ 1895 merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1);
1910 1896
1911 if (!merge_done) 1897 if (!merge_done)
1912 (void) ext4_ext_try_to_merge_ 1898 (void) ext4_ext_try_to_merge_right(inode, path, ex);
1913 1899
1914 ext4_ext_try_to_merge_up(handle, inod 1900 ext4_ext_try_to_merge_up(handle, inode, path);
1915 } 1901 }
1916 1902
1917 /* 1903 /*
1918 * check if a portion of the "newext" extent 1904 * check if a portion of the "newext" extent overlaps with an
1919 * existing extent. 1905 * existing extent.
1920 * 1906 *
1921 * If there is an overlap discovered, it upda 1907 * If there is an overlap discovered, it updates the length of the newext
1922 * such that there will be no overlap, and th 1908 * such that there will be no overlap, and then returns 1.
1923 * If there is no overlap found, it returns 0 1909 * If there is no overlap found, it returns 0.
1924 */ 1910 */
1925 static unsigned int ext4_ext_check_overlap(st 1911 static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi,
1926 st 1912 struct inode *inode,
1927 st 1913 struct ext4_extent *newext,
1928 st 1914 struct ext4_ext_path *path)
1929 { 1915 {
1930 ext4_lblk_t b1, b2; 1916 ext4_lblk_t b1, b2;
1931 unsigned int depth, len1; 1917 unsigned int depth, len1;
1932 unsigned int ret = 0; 1918 unsigned int ret = 0;
1933 1919
1934 b1 = le32_to_cpu(newext->ee_block); 1920 b1 = le32_to_cpu(newext->ee_block);
1935 len1 = ext4_ext_get_actual_len(newext 1921 len1 = ext4_ext_get_actual_len(newext);
1936 depth = ext_depth(inode); 1922 depth = ext_depth(inode);
1937 if (!path[depth].p_ext) 1923 if (!path[depth].p_ext)
1938 goto out; 1924 goto out;
1939 b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu 1925 b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block));
1940 1926
1941 /* 1927 /*
1942 * get the next allocated block if th 1928 * get the next allocated block if the extent in the path
1943 * is before the requested block(s) 1929 * is before the requested block(s)
1944 */ 1930 */
1945 if (b2 < b1) { 1931 if (b2 < b1) {
1946 b2 = ext4_ext_next_allocated_ 1932 b2 = ext4_ext_next_allocated_block(path);
1947 if (b2 == EXT_MAX_BLOCKS) 1933 if (b2 == EXT_MAX_BLOCKS)
1948 goto out; 1934 goto out;
1949 b2 = EXT4_LBLK_CMASK(sbi, b2) 1935 b2 = EXT4_LBLK_CMASK(sbi, b2);
1950 } 1936 }
1951 1937
1952 /* check for wrap through zero on ext 1938 /* check for wrap through zero on extent logical start block*/
1953 if (b1 + len1 < b1) { 1939 if (b1 + len1 < b1) {
1954 len1 = EXT_MAX_BLOCKS - b1; 1940 len1 = EXT_MAX_BLOCKS - b1;
1955 newext->ee_len = cpu_to_le16( 1941 newext->ee_len = cpu_to_le16(len1);
1956 ret = 1; 1942 ret = 1;
1957 } 1943 }
1958 1944
1959 /* check for overlap */ 1945 /* check for overlap */
1960 if (b1 + len1 > b2) { 1946 if (b1 + len1 > b2) {
1961 newext->ee_len = cpu_to_le16( 1947 newext->ee_len = cpu_to_le16(b2 - b1);
1962 ret = 1; 1948 ret = 1;
1963 } 1949 }
1964 out: 1950 out:
1965 return ret; 1951 return ret;
1966 } 1952 }
1967 1953
1968 /* 1954 /*
1969 * ext4_ext_insert_extent: 1955 * ext4_ext_insert_extent:
1970 * tries to merge requested extent into the e 1956 * tries to merge requested extent into the existing extent or
1971 * inserts requested extent as new one into t 1957 * inserts requested extent as new one into the tree,
1972 * creating new leaf in the no-space case. 1958 * creating new leaf in the no-space case.
1973 */ 1959 */
1974 struct ext4_ext_path * !! 1960 int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1975 ext4_ext_insert_extent(handle_t *handle, stru !! 1961 struct ext4_ext_path **ppath,
1976 struct ext4_ext_path * !! 1962 struct ext4_extent *newext, int gb_flags)
1977 struct ext4_extent *ne <<
1978 { 1963 {
>> 1964 struct ext4_ext_path *path = *ppath;
1979 struct ext4_extent_header *eh; 1965 struct ext4_extent_header *eh;
1980 struct ext4_extent *ex, *fex; 1966 struct ext4_extent *ex, *fex;
1981 struct ext4_extent *nearex; /* neares 1967 struct ext4_extent *nearex; /* nearest extent */
1982 int depth, len, err = 0; !! 1968 struct ext4_ext_path *npath = NULL;
>> 1969 int depth, len, err;
1983 ext4_lblk_t next; 1970 ext4_lblk_t next;
1984 int mb_flags = 0, unwritten; 1971 int mb_flags = 0, unwritten;
1985 1972
1986 if (gb_flags & EXT4_GET_BLOCKS_DELALL 1973 if (gb_flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
1987 mb_flags |= EXT4_MB_DELALLOC_ 1974 mb_flags |= EXT4_MB_DELALLOC_RESERVED;
1988 if (unlikely(ext4_ext_get_actual_len( 1975 if (unlikely(ext4_ext_get_actual_len(newext) == 0)) {
1989 EXT4_ERROR_INODE(inode, "ext4 1976 EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
1990 err = -EFSCORRUPTED; !! 1977 return -EFSCORRUPTED;
1991 goto errout; <<
1992 } 1978 }
1993 depth = ext_depth(inode); 1979 depth = ext_depth(inode);
1994 ex = path[depth].p_ext; 1980 ex = path[depth].p_ext;
1995 eh = path[depth].p_hdr; 1981 eh = path[depth].p_hdr;
1996 if (unlikely(path[depth].p_hdr == NUL 1982 if (unlikely(path[depth].p_hdr == NULL)) {
1997 EXT4_ERROR_INODE(inode, "path 1983 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
1998 err = -EFSCORRUPTED; !! 1984 return -EFSCORRUPTED;
1999 goto errout; <<
2000 } 1985 }
2001 1986
2002 /* try to insert block into found ext 1987 /* try to insert block into found extent and return */
2003 if (ex && !(gb_flags & EXT4_GET_BLOCK 1988 if (ex && !(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) {
2004 1989
2005 /* 1990 /*
2006 * Try to see whether we shou 1991 * Try to see whether we should rather test the extent on
2007 * right from ex, or from the 1992 * right from ex, or from the left of ex. This is because
2008 * ext4_find_extent() can ret 1993 * ext4_find_extent() can return either extent on the
2009 * left, or on the right from 1994 * left, or on the right from the searched position. This
2010 * will make merging more eff 1995 * will make merging more effective.
2011 */ 1996 */
2012 if (ex < EXT_LAST_EXTENT(eh) 1997 if (ex < EXT_LAST_EXTENT(eh) &&
2013 (le32_to_cpu(ex->ee_block 1998 (le32_to_cpu(ex->ee_block) +
2014 ext4_ext_get_actual_len(e 1999 ext4_ext_get_actual_len(ex) <
2015 le32_to_cpu(newext->ee_bl 2000 le32_to_cpu(newext->ee_block))) {
2016 ex += 1; 2001 ex += 1;
2017 goto prepend; 2002 goto prepend;
2018 } else if ((ex > EXT_FIRST_EX 2003 } else if ((ex > EXT_FIRST_EXTENT(eh)) &&
2019 (le32_to_cpu(newex 2004 (le32_to_cpu(newext->ee_block) +
2020 ext4_ext_get_actua 2005 ext4_ext_get_actual_len(newext) <
2021 le32_to_cpu(ex->ee 2006 le32_to_cpu(ex->ee_block)))
2022 ex -= 1; 2007 ex -= 1;
2023 2008
2024 /* Try to append newex to the 2009 /* Try to append newex to the ex */
2025 if (ext4_can_extents_be_merge 2010 if (ext4_can_extents_be_merged(inode, ex, newext)) {
2026 ext_debug(inode, "app 2011 ext_debug(inode, "append [%d]%d block to %u:[%d]%d"
2027 "(from %llu 2012 "(from %llu)\n",
2028 ext4_ext_is 2013 ext4_ext_is_unwritten(newext),
2029 ext4_ext_ge 2014 ext4_ext_get_actual_len(newext),
2030 le32_to_cpu 2015 le32_to_cpu(ex->ee_block),
2031 ext4_ext_is 2016 ext4_ext_is_unwritten(ex),
2032 ext4_ext_ge 2017 ext4_ext_get_actual_len(ex),
2033 ext4_ext_pb 2018 ext4_ext_pblock(ex));
2034 err = ext4_ext_get_ac 2019 err = ext4_ext_get_access(handle, inode,
2035 2020 path + depth);
2036 if (err) 2021 if (err)
2037 goto errout; !! 2022 return err;
2038 unwritten = ext4_ext_ 2023 unwritten = ext4_ext_is_unwritten(ex);
2039 ex->ee_len = cpu_to_l 2024 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
2040 + ext 2025 + ext4_ext_get_actual_len(newext));
2041 if (unwritten) 2026 if (unwritten)
2042 ext4_ext_mark 2027 ext4_ext_mark_unwritten(ex);
>> 2028 eh = path[depth].p_hdr;
2043 nearex = ex; 2029 nearex = ex;
2044 goto merge; 2030 goto merge;
2045 } 2031 }
2046 2032
2047 prepend: 2033 prepend:
2048 /* Try to prepend newex to th 2034 /* Try to prepend newex to the ex */
2049 if (ext4_can_extents_be_merge 2035 if (ext4_can_extents_be_merged(inode, newext, ex)) {
2050 ext_debug(inode, "pre 2036 ext_debug(inode, "prepend %u[%d]%d block to %u:[%d]%d"
2051 "(from %llu 2037 "(from %llu)\n",
2052 le32_to_cpu 2038 le32_to_cpu(newext->ee_block),
2053 ext4_ext_is 2039 ext4_ext_is_unwritten(newext),
2054 ext4_ext_ge 2040 ext4_ext_get_actual_len(newext),
2055 le32_to_cpu 2041 le32_to_cpu(ex->ee_block),
2056 ext4_ext_is 2042 ext4_ext_is_unwritten(ex),
2057 ext4_ext_ge 2043 ext4_ext_get_actual_len(ex),
2058 ext4_ext_pb 2044 ext4_ext_pblock(ex));
2059 err = ext4_ext_get_ac 2045 err = ext4_ext_get_access(handle, inode,
2060 2046 path + depth);
2061 if (err) 2047 if (err)
2062 goto errout; !! 2048 return err;
2063 2049
2064 unwritten = ext4_ext_ 2050 unwritten = ext4_ext_is_unwritten(ex);
2065 ex->ee_block = newext 2051 ex->ee_block = newext->ee_block;
2066 ext4_ext_store_pblock 2052 ext4_ext_store_pblock(ex, ext4_ext_pblock(newext));
2067 ex->ee_len = cpu_to_l 2053 ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)
2068 + ext 2054 + ext4_ext_get_actual_len(newext));
2069 if (unwritten) 2055 if (unwritten)
2070 ext4_ext_mark 2056 ext4_ext_mark_unwritten(ex);
>> 2057 eh = path[depth].p_hdr;
2071 nearex = ex; 2058 nearex = ex;
2072 goto merge; 2059 goto merge;
2073 } 2060 }
2074 } 2061 }
2075 2062
2076 depth = ext_depth(inode); 2063 depth = ext_depth(inode);
2077 eh = path[depth].p_hdr; 2064 eh = path[depth].p_hdr;
2078 if (le16_to_cpu(eh->eh_entries) < le1 2065 if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max))
2079 goto has_space; 2066 goto has_space;
2080 2067
2081 /* probably next leaf has space for u 2068 /* probably next leaf has space for us? */
2082 fex = EXT_LAST_EXTENT(eh); 2069 fex = EXT_LAST_EXTENT(eh);
2083 next = EXT_MAX_BLOCKS; 2070 next = EXT_MAX_BLOCKS;
2084 if (le32_to_cpu(newext->ee_block) > l 2071 if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block))
2085 next = ext4_ext_next_leaf_blo 2072 next = ext4_ext_next_leaf_block(path);
2086 if (next != EXT_MAX_BLOCKS) { 2073 if (next != EXT_MAX_BLOCKS) {
2087 struct ext4_ext_path *npath; <<
2088 <<
2089 ext_debug(inode, "next leaf b 2074 ext_debug(inode, "next leaf block - %u\n", next);
>> 2075 BUG_ON(npath != NULL);
2090 npath = ext4_find_extent(inod 2076 npath = ext4_find_extent(inode, next, NULL, gb_flags);
2091 if (IS_ERR(npath)) { !! 2077 if (IS_ERR(npath))
2092 err = PTR_ERR(npath); !! 2078 return PTR_ERR(npath);
2093 goto errout; <<
2094 } <<
2095 BUG_ON(npath->p_depth != path 2079 BUG_ON(npath->p_depth != path->p_depth);
2096 eh = npath[depth].p_hdr; 2080 eh = npath[depth].p_hdr;
2097 if (le16_to_cpu(eh->eh_entrie 2081 if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) {
2098 ext_debug(inode, "nex 2082 ext_debug(inode, "next leaf isn't full(%d)\n",
2099 le16_to_cpu 2083 le16_to_cpu(eh->eh_entries));
2100 ext4_free_ext_path(pa <<
2101 path = npath; 2084 path = npath;
2102 goto has_space; 2085 goto has_space;
2103 } 2086 }
2104 ext_debug(inode, "next leaf h 2087 ext_debug(inode, "next leaf has no free space(%d,%d)\n",
2105 le16_to_cpu(eh->eh_ 2088 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
2106 ext4_free_ext_path(npath); <<
2107 } 2089 }
2108 2090
2109 /* 2091 /*
2110 * There is no free space in the foun 2092 * There is no free space in the found leaf.
2111 * We're gonna add a new leaf in the 2093 * We're gonna add a new leaf in the tree.
2112 */ 2094 */
2113 if (gb_flags & EXT4_GET_BLOCKS_METADA 2095 if (gb_flags & EXT4_GET_BLOCKS_METADATA_NOFAIL)
2114 mb_flags |= EXT4_MB_USE_RESER 2096 mb_flags |= EXT4_MB_USE_RESERVED;
2115 path = ext4_ext_create_new_leaf(handl !! 2097 err = ext4_ext_create_new_leaf(handle, inode, mb_flags, gb_flags,
2116 path, !! 2098 ppath, newext);
2117 if (IS_ERR(path)) !! 2099 if (err)
2118 return path; !! 2100 goto cleanup;
>> 2101 path = *ppath;
2119 depth = ext_depth(inode); 2102 depth = ext_depth(inode);
2120 eh = path[depth].p_hdr; 2103 eh = path[depth].p_hdr;
2121 2104
2122 has_space: 2105 has_space:
2123 nearex = path[depth].p_ext; 2106 nearex = path[depth].p_ext;
2124 2107
2125 err = ext4_ext_get_access(handle, ino 2108 err = ext4_ext_get_access(handle, inode, path + depth);
2126 if (err) 2109 if (err)
2127 goto errout; !! 2110 goto cleanup;
2128 2111
2129 if (!nearex) { 2112 if (!nearex) {
2130 /* there is no extent in this 2113 /* there is no extent in this leaf, create first one */
2131 ext_debug(inode, "first exten 2114 ext_debug(inode, "first extent in the leaf: %u:%llu:[%d]%d\n",
2132 le32_to_cpu(n 2115 le32_to_cpu(newext->ee_block),
2133 ext4_ext_pblo 2116 ext4_ext_pblock(newext),
2134 ext4_ext_is_u 2117 ext4_ext_is_unwritten(newext),
2135 ext4_ext_get_ 2118 ext4_ext_get_actual_len(newext));
2136 nearex = EXT_FIRST_EXTENT(eh) 2119 nearex = EXT_FIRST_EXTENT(eh);
2137 } else { 2120 } else {
2138 if (le32_to_cpu(newext->ee_bl 2121 if (le32_to_cpu(newext->ee_block)
2139 > le32_to_cpu(near 2122 > le32_to_cpu(nearex->ee_block)) {
2140 /* Insert after */ 2123 /* Insert after */
2141 ext_debug(inode, "ins 2124 ext_debug(inode, "insert %u:%llu:[%d]%d before: "
2142 "near 2125 "nearest %p\n",
2143 le32_ 2126 le32_to_cpu(newext->ee_block),
2144 ext4_ 2127 ext4_ext_pblock(newext),
2145 ext4_ 2128 ext4_ext_is_unwritten(newext),
2146 ext4_ 2129 ext4_ext_get_actual_len(newext),
2147 neare 2130 nearex);
2148 nearex++; 2131 nearex++;
2149 } else { 2132 } else {
2150 /* Insert before */ 2133 /* Insert before */
2151 BUG_ON(newext->ee_blo 2134 BUG_ON(newext->ee_block == nearex->ee_block);
2152 ext_debug(inode, "ins 2135 ext_debug(inode, "insert %u:%llu:[%d]%d after: "
2153 "near 2136 "nearest %p\n",
2154 le32_ 2137 le32_to_cpu(newext->ee_block),
2155 ext4_ 2138 ext4_ext_pblock(newext),
2156 ext4_ 2139 ext4_ext_is_unwritten(newext),
2157 ext4_ 2140 ext4_ext_get_actual_len(newext),
2158 neare 2141 nearex);
2159 } 2142 }
2160 len = EXT_LAST_EXTENT(eh) - n 2143 len = EXT_LAST_EXTENT(eh) - nearex + 1;
2161 if (len > 0) { 2144 if (len > 0) {
2162 ext_debug(inode, "ins 2145 ext_debug(inode, "insert %u:%llu:[%d]%d: "
2163 "move 2146 "move %d extents from 0x%p to 0x%p\n",
2164 le32_ 2147 le32_to_cpu(newext->ee_block),
2165 ext4_ 2148 ext4_ext_pblock(newext),
2166 ext4_ 2149 ext4_ext_is_unwritten(newext),
2167 ext4_ 2150 ext4_ext_get_actual_len(newext),
2168 len, 2151 len, nearex, nearex + 1);
2169 memmove(nearex + 1, n 2152 memmove(nearex + 1, nearex,
2170 len * sizeof( 2153 len * sizeof(struct ext4_extent));
2171 } 2154 }
2172 } 2155 }
2173 2156
2174 le16_add_cpu(&eh->eh_entries, 1); 2157 le16_add_cpu(&eh->eh_entries, 1);
2175 path[depth].p_ext = nearex; 2158 path[depth].p_ext = nearex;
2176 nearex->ee_block = newext->ee_block; 2159 nearex->ee_block = newext->ee_block;
2177 ext4_ext_store_pblock(nearex, ext4_ex 2160 ext4_ext_store_pblock(nearex, ext4_ext_pblock(newext));
2178 nearex->ee_len = newext->ee_len; 2161 nearex->ee_len = newext->ee_len;
2179 2162
2180 merge: 2163 merge:
2181 /* try to merge extents */ 2164 /* try to merge extents */
2182 if (!(gb_flags & EXT4_GET_BLOCKS_PRE_ 2165 if (!(gb_flags & EXT4_GET_BLOCKS_PRE_IO))
2183 ext4_ext_try_to_merge(handle, 2166 ext4_ext_try_to_merge(handle, inode, path, nearex);
2184 2167
>> 2168
2185 /* time to correct all indexes above 2169 /* time to correct all indexes above */
2186 err = ext4_ext_correct_indexes(handle 2170 err = ext4_ext_correct_indexes(handle, inode, path);
2187 if (err) 2171 if (err)
2188 goto errout; !! 2172 goto cleanup;
2189 2173
2190 err = ext4_ext_dirty(handle, inode, p 2174 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
2191 if (err) <<
2192 goto errout; <<
2193 <<
2194 return path; <<
2195 2175
2196 errout: !! 2176 cleanup:
2197 ext4_free_ext_path(path); !! 2177 ext4_ext_drop_refs(npath);
2198 return ERR_PTR(err); !! 2178 kfree(npath);
>> 2179 return err;
2199 } 2180 }
2200 2181
2201 static int ext4_fill_es_cache_info(struct ino 2182 static int ext4_fill_es_cache_info(struct inode *inode,
2202 ext4_lblk_ 2183 ext4_lblk_t block, ext4_lblk_t num,
2203 struct fie 2184 struct fiemap_extent_info *fieinfo)
2204 { 2185 {
2205 ext4_lblk_t next, end = block + num - 2186 ext4_lblk_t next, end = block + num - 1;
2206 struct extent_status es; 2187 struct extent_status es;
2207 unsigned char blksize_bits = inode->i 2188 unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
2208 unsigned int flags; 2189 unsigned int flags;
2209 int err; 2190 int err;
2210 2191
2211 while (block <= end) { 2192 while (block <= end) {
2212 next = 0; 2193 next = 0;
2213 flags = 0; 2194 flags = 0;
2214 if (!ext4_es_lookup_extent(in 2195 if (!ext4_es_lookup_extent(inode, block, &next, &es))
2215 break; 2196 break;
2216 if (ext4_es_is_unwritten(&es) 2197 if (ext4_es_is_unwritten(&es))
2217 flags |= FIEMAP_EXTEN 2198 flags |= FIEMAP_EXTENT_UNWRITTEN;
2218 if (ext4_es_is_delayed(&es)) 2199 if (ext4_es_is_delayed(&es))
2219 flags |= (FIEMAP_EXTE 2200 flags |= (FIEMAP_EXTENT_DELALLOC |
2220 FIEMAP_EXTE 2201 FIEMAP_EXTENT_UNKNOWN);
2221 if (ext4_es_is_hole(&es)) 2202 if (ext4_es_is_hole(&es))
2222 flags |= EXT4_FIEMAP_ 2203 flags |= EXT4_FIEMAP_EXTENT_HOLE;
2223 if (next == 0) 2204 if (next == 0)
2224 flags |= FIEMAP_EXTEN 2205 flags |= FIEMAP_EXTENT_LAST;
2225 if (flags & (FIEMAP_EXTENT_DE 2206 if (flags & (FIEMAP_EXTENT_DELALLOC|
2226 EXT4_FIEMAP_EXTE 2207 EXT4_FIEMAP_EXTENT_HOLE))
2227 es.es_pblk = 0; 2208 es.es_pblk = 0;
2228 else 2209 else
2229 es.es_pblk = ext4_es_ 2210 es.es_pblk = ext4_es_pblock(&es);
2230 err = fiemap_fill_next_extent 2211 err = fiemap_fill_next_extent(fieinfo,
2231 (__u64)es.es_ 2212 (__u64)es.es_lblk << blksize_bits,
2232 (__u64)es.es_ 2213 (__u64)es.es_pblk << blksize_bits,
2233 (__u64)es.es_ 2214 (__u64)es.es_len << blksize_bits,
2234 flags); 2215 flags);
2235 if (next == 0) 2216 if (next == 0)
2236 break; 2217 break;
2237 block = next; 2218 block = next;
2238 if (err < 0) 2219 if (err < 0)
2239 return err; 2220 return err;
2240 if (err == 1) 2221 if (err == 1)
2241 return 0; 2222 return 0;
2242 } 2223 }
2243 return 0; 2224 return 0;
2244 } 2225 }
2245 2226
2246 2227
2247 /* 2228 /*
2248 * ext4_ext_find_hole - find hole around give 2229 * ext4_ext_find_hole - find hole around given block according to the given path
2249 * @inode: inode we lookup in 2230 * @inode: inode we lookup in
2250 * @path: path in extent tree to @lblk 2231 * @path: path in extent tree to @lblk
2251 * @lblk: pointer to logical block arou 2232 * @lblk: pointer to logical block around which we want to determine hole
2252 * 2233 *
2253 * Determine hole length (and start if easily 2234 * Determine hole length (and start if easily possible) around given logical
2254 * block. We don't try too hard to find the b 2235 * block. We don't try too hard to find the beginning of the hole but @path
2255 * actually points to extent before @lblk, we 2236 * actually points to extent before @lblk, we provide it.
2256 * 2237 *
2257 * The function returns the length of a hole 2238 * The function returns the length of a hole starting at @lblk. We update @lblk
2258 * to the beginning of the hole if we managed 2239 * to the beginning of the hole if we managed to find it.
2259 */ 2240 */
2260 static ext4_lblk_t ext4_ext_find_hole(struct 2241 static ext4_lblk_t ext4_ext_find_hole(struct inode *inode,
2261 struct 2242 struct ext4_ext_path *path,
2262 ext4_lb 2243 ext4_lblk_t *lblk)
2263 { 2244 {
2264 int depth = ext_depth(inode); 2245 int depth = ext_depth(inode);
2265 struct ext4_extent *ex; 2246 struct ext4_extent *ex;
2266 ext4_lblk_t len; 2247 ext4_lblk_t len;
2267 2248
2268 ex = path[depth].p_ext; 2249 ex = path[depth].p_ext;
2269 if (ex == NULL) { 2250 if (ex == NULL) {
2270 /* there is no extent yet, so 2251 /* there is no extent yet, so gap is [0;-] */
2271 *lblk = 0; 2252 *lblk = 0;
2272 len = EXT_MAX_BLOCKS; 2253 len = EXT_MAX_BLOCKS;
2273 } else if (*lblk < le32_to_cpu(ex->ee 2254 } else if (*lblk < le32_to_cpu(ex->ee_block)) {
2274 len = le32_to_cpu(ex->ee_bloc 2255 len = le32_to_cpu(ex->ee_block) - *lblk;
2275 } else if (*lblk >= le32_to_cpu(ex->e 2256 } else if (*lblk >= le32_to_cpu(ex->ee_block)
2276 + ext4_ext_get_actual 2257 + ext4_ext_get_actual_len(ex)) {
2277 ext4_lblk_t next; 2258 ext4_lblk_t next;
2278 2259
2279 *lblk = le32_to_cpu(ex->ee_bl 2260 *lblk = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex);
2280 next = ext4_ext_next_allocate 2261 next = ext4_ext_next_allocated_block(path);
2281 BUG_ON(next == *lblk); 2262 BUG_ON(next == *lblk);
2282 len = next - *lblk; 2263 len = next - *lblk;
2283 } else { 2264 } else {
2284 BUG(); 2265 BUG();
2285 } 2266 }
2286 return len; 2267 return len;
2287 } 2268 }
2288 2269
2289 /* 2270 /*
2290 * ext4_ext_rm_idx: 2271 * ext4_ext_rm_idx:
2291 * removes index from the index block. 2272 * removes index from the index block.
2292 */ 2273 */
2293 static int ext4_ext_rm_idx(handle_t *handle, 2274 static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
2294 struct ext4_ext_path 2275 struct ext4_ext_path *path, int depth)
2295 { 2276 {
2296 int err; 2277 int err;
2297 ext4_fsblk_t leaf; 2278 ext4_fsblk_t leaf;
2298 int k = depth - 1; <<
2299 2279
2300 /* free index block */ 2280 /* free index block */
2301 leaf = ext4_idx_pblock(path[k].p_idx) !! 2281 depth--;
2302 if (unlikely(path[k].p_hdr->eh_entrie !! 2282 path = path + depth;
2303 EXT4_ERROR_INODE(inode, "path !! 2283 leaf = ext4_idx_pblock(path->p_idx);
>> 2284 if (unlikely(path->p_hdr->eh_entries == 0)) {
>> 2285 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
2304 return -EFSCORRUPTED; 2286 return -EFSCORRUPTED;
2305 } 2287 }
2306 err = ext4_ext_get_access(handle, ino !! 2288 err = ext4_ext_get_access(handle, inode, path);
2307 if (err) 2289 if (err)
2308 return err; 2290 return err;
2309 2291
2310 if (path[k].p_idx != EXT_LAST_INDEX(p !! 2292 if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) {
2311 int len = EXT_LAST_INDEX(path !! 2293 int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx;
2312 len *= sizeof(struct ext4_ext 2294 len *= sizeof(struct ext4_extent_idx);
2313 memmove(path[k].p_idx, path[k !! 2295 memmove(path->p_idx, path->p_idx + 1, len);
2314 } 2296 }
2315 2297
2316 le16_add_cpu(&path[k].p_hdr->eh_entri !! 2298 le16_add_cpu(&path->p_hdr->eh_entries, -1);
2317 err = ext4_ext_dirty(handle, inode, p !! 2299 err = ext4_ext_dirty(handle, inode, path);
2318 if (err) 2300 if (err)
2319 return err; 2301 return err;
2320 ext_debug(inode, "index is empty, rem 2302 ext_debug(inode, "index is empty, remove it, free block %llu\n", leaf);
2321 trace_ext4_ext_rm_idx(inode, leaf); 2303 trace_ext4_ext_rm_idx(inode, leaf);
2322 2304
2323 ext4_free_blocks(handle, inode, NULL, 2305 ext4_free_blocks(handle, inode, NULL, leaf, 1,
2324 EXT4_FREE_BLOCKS_MET 2306 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
2325 2307
2326 while (--k >= 0) { !! 2308 while (--depth >= 0) {
2327 if (path[k + 1].p_idx != EXT_ !! 2309 if (path->p_idx != EXT_FIRST_INDEX(path->p_hdr))
2328 break; 2310 break;
2329 err = ext4_ext_get_access(han !! 2311 path--;
>> 2312 err = ext4_ext_get_access(handle, inode, path);
2330 if (err) 2313 if (err)
2331 goto clean; !! 2314 break;
2332 path[k].p_idx->ei_block = pat !! 2315 path->p_idx->ei_block = (path+1)->p_idx->ei_block;
2333 err = ext4_ext_dirty(handle, !! 2316 err = ext4_ext_dirty(handle, inode, path);
2334 if (err) 2317 if (err)
2335 goto clean; !! 2318 break;
2336 } 2319 }
2337 return 0; <<
2338 <<
2339 clean: <<
2340 /* <<
2341 * The path[k].p_bh is either unmodif <<
2342 * set (see ext4_ext_get_access()). S <<
2343 * of the successfully modified exten <<
2344 * these extents to be checked to avo <<
2345 */ <<
2346 while (++k < depth) <<
2347 clear_buffer_verified(path[k] <<
2348 <<
2349 return err; 2320 return err;
2350 } 2321 }
2351 2322
2352 /* 2323 /*
2353 * ext4_ext_calc_credits_for_single_extent: 2324 * ext4_ext_calc_credits_for_single_extent:
2354 * This routine returns max. credits that nee 2325 * This routine returns max. credits that needed to insert an extent
2355 * to the extent tree. 2326 * to the extent tree.
2356 * When pass the actual path, the caller shou 2327 * When pass the actual path, the caller should calculate credits
2357 * under i_data_sem. 2328 * under i_data_sem.
2358 */ 2329 */
2359 int ext4_ext_calc_credits_for_single_extent(s 2330 int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks,
2360 2331 struct ext4_ext_path *path)
2361 { 2332 {
2362 if (path) { 2333 if (path) {
2363 int depth = ext_depth(inode); 2334 int depth = ext_depth(inode);
2364 int ret = 0; 2335 int ret = 0;
2365 2336
2366 /* probably there is space in 2337 /* probably there is space in leaf? */
2367 if (le16_to_cpu(path[depth].p 2338 if (le16_to_cpu(path[depth].p_hdr->eh_entries)
2368 < le16_to_cpu 2339 < le16_to_cpu(path[depth].p_hdr->eh_max)) {
2369 2340
2370 /* 2341 /*
2371 * There are some sp 2342 * There are some space in the leaf tree, no
2372 * need to account f 2343 * need to account for leaf block credit
2373 * 2344 *
2374 * bitmaps and block 2345 * bitmaps and block group descriptor blocks
2375 * and other metadat 2346 * and other metadata blocks still need to be
2376 * accounted. 2347 * accounted.
2377 */ 2348 */
2378 /* 1 bitmap, 1 block 2349 /* 1 bitmap, 1 block group descriptor */
2379 ret = 2 + EXT4_META_T 2350 ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb);
2380 return ret; 2351 return ret;
2381 } 2352 }
2382 } 2353 }
2383 2354
2384 return ext4_chunk_trans_blocks(inode, 2355 return ext4_chunk_trans_blocks(inode, nrblocks);
2385 } 2356 }
2386 2357
2387 /* 2358 /*
2388 * How many index/leaf blocks need to change/ 2359 * How many index/leaf blocks need to change/allocate to add @extents extents?
2389 * 2360 *
2390 * If we add a single extent, then in the wor 2361 * If we add a single extent, then in the worse case, each tree level
2391 * index/leaf need to be changed in case of t 2362 * index/leaf need to be changed in case of the tree split.
2392 * 2363 *
2393 * If more extents are inserted, they could c 2364 * If more extents are inserted, they could cause the whole tree split more
2394 * than once, but this is really rare. 2365 * than once, but this is really rare.
2395 */ 2366 */
2396 int ext4_ext_index_trans_blocks(struct inode 2367 int ext4_ext_index_trans_blocks(struct inode *inode, int extents)
2397 { 2368 {
2398 int index; 2369 int index;
2399 int depth; 2370 int depth;
2400 2371
2401 /* If we are converting the inline da 2372 /* If we are converting the inline data, only one is needed here. */
2402 if (ext4_has_inline_data(inode)) 2373 if (ext4_has_inline_data(inode))
2403 return 1; 2374 return 1;
2404 2375
2405 depth = ext_depth(inode); 2376 depth = ext_depth(inode);
2406 2377
2407 if (extents <= 1) 2378 if (extents <= 1)
2408 index = depth * 2; 2379 index = depth * 2;
2409 else 2380 else
2410 index = depth * 3; 2381 index = depth * 3;
2411 2382
2412 return index; 2383 return index;
2413 } 2384 }
2414 2385
2415 static inline int get_default_free_blocks_fla 2386 static inline int get_default_free_blocks_flags(struct inode *inode)
2416 { 2387 {
2417 if (S_ISDIR(inode->i_mode) || S_ISLNK 2388 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) ||
2418 ext4_test_inode_flag(inode, EXT4_ 2389 ext4_test_inode_flag(inode, EXT4_INODE_EA_INODE))
2419 return EXT4_FREE_BLOCKS_METAD 2390 return EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET;
2420 else if (ext4_should_journal_data(ino 2391 else if (ext4_should_journal_data(inode))
2421 return EXT4_FREE_BLOCKS_FORGE 2392 return EXT4_FREE_BLOCKS_FORGET;
2422 return 0; 2393 return 0;
2423 } 2394 }
2424 2395
2425 /* 2396 /*
2426 * ext4_rereserve_cluster - increment the res 2397 * ext4_rereserve_cluster - increment the reserved cluster count when
2427 * freeing a cluster 2398 * freeing a cluster with a pending reservation
2428 * 2399 *
2429 * @inode - file containing the cluster 2400 * @inode - file containing the cluster
2430 * @lblk - logical block in cluster to be res 2401 * @lblk - logical block in cluster to be reserved
2431 * 2402 *
2432 * Increments the reserved cluster count and 2403 * Increments the reserved cluster count and adjusts quota in a bigalloc
2433 * file system when freeing a partial cluster 2404 * file system when freeing a partial cluster containing at least one
2434 * delayed and unwritten block. A partial cl 2405 * delayed and unwritten block. A partial cluster meeting that
2435 * requirement will have a pending reservatio 2406 * requirement will have a pending reservation. If so, the
2436 * RERESERVE_CLUSTER flag is used when callin 2407 * RERESERVE_CLUSTER flag is used when calling ext4_free_blocks() to
2437 * defer reserved and allocated space account 2408 * defer reserved and allocated space accounting to a subsequent call
2438 * to this function. 2409 * to this function.
2439 */ 2410 */
2440 static void ext4_rereserve_cluster(struct ino 2411 static void ext4_rereserve_cluster(struct inode *inode, ext4_lblk_t lblk)
2441 { 2412 {
2442 struct ext4_sb_info *sbi = EXT4_SB(in 2413 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2443 struct ext4_inode_info *ei = EXT4_I(i 2414 struct ext4_inode_info *ei = EXT4_I(inode);
2444 2415
2445 dquot_reclaim_block(inode, EXT4_C2B(s 2416 dquot_reclaim_block(inode, EXT4_C2B(sbi, 1));
2446 2417
2447 spin_lock(&ei->i_block_reservation_lo 2418 spin_lock(&ei->i_block_reservation_lock);
2448 ei->i_reserved_data_blocks++; 2419 ei->i_reserved_data_blocks++;
2449 percpu_counter_add(&sbi->s_dirtyclust 2420 percpu_counter_add(&sbi->s_dirtyclusters_counter, 1);
2450 spin_unlock(&ei->i_block_reservation_ 2421 spin_unlock(&ei->i_block_reservation_lock);
2451 2422
2452 percpu_counter_add(&sbi->s_freecluste 2423 percpu_counter_add(&sbi->s_freeclusters_counter, 1);
2453 ext4_remove_pending(inode, lblk); 2424 ext4_remove_pending(inode, lblk);
2454 } 2425 }
2455 2426
2456 static int ext4_remove_blocks(handle_t *handl 2427 static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
2457 struct ext4_ext 2428 struct ext4_extent *ex,
2458 struct partial_ 2429 struct partial_cluster *partial,
2459 ext4_lblk_t fro 2430 ext4_lblk_t from, ext4_lblk_t to)
2460 { 2431 {
2461 struct ext4_sb_info *sbi = EXT4_SB(in 2432 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2462 unsigned short ee_len = ext4_ext_get_ 2433 unsigned short ee_len = ext4_ext_get_actual_len(ex);
2463 ext4_fsblk_t last_pblk, pblk; 2434 ext4_fsblk_t last_pblk, pblk;
2464 ext4_lblk_t num; 2435 ext4_lblk_t num;
2465 int flags; 2436 int flags;
2466 2437
2467 /* only extent tail removal is allowe 2438 /* only extent tail removal is allowed */
2468 if (from < le32_to_cpu(ex->ee_block) 2439 if (from < le32_to_cpu(ex->ee_block) ||
2469 to != le32_to_cpu(ex->ee_block) + 2440 to != le32_to_cpu(ex->ee_block) + ee_len - 1) {
2470 ext4_error(sbi->s_sb, 2441 ext4_error(sbi->s_sb,
2471 "strange request: 2442 "strange request: removal(2) %u-%u from %u:%u",
2472 from, to, le32_to_ 2443 from, to, le32_to_cpu(ex->ee_block), ee_len);
2473 return 0; 2444 return 0;
2474 } 2445 }
2475 2446
2476 #ifdef EXTENTS_STATS 2447 #ifdef EXTENTS_STATS
2477 spin_lock(&sbi->s_ext_stats_lock); 2448 spin_lock(&sbi->s_ext_stats_lock);
2478 sbi->s_ext_blocks += ee_len; 2449 sbi->s_ext_blocks += ee_len;
2479 sbi->s_ext_extents++; 2450 sbi->s_ext_extents++;
2480 if (ee_len < sbi->s_ext_min) 2451 if (ee_len < sbi->s_ext_min)
2481 sbi->s_ext_min = ee_len; 2452 sbi->s_ext_min = ee_len;
2482 if (ee_len > sbi->s_ext_max) 2453 if (ee_len > sbi->s_ext_max)
2483 sbi->s_ext_max = ee_len; 2454 sbi->s_ext_max = ee_len;
2484 if (ext_depth(inode) > sbi->s_depth_m 2455 if (ext_depth(inode) > sbi->s_depth_max)
2485 sbi->s_depth_max = ext_depth( 2456 sbi->s_depth_max = ext_depth(inode);
2486 spin_unlock(&sbi->s_ext_stats_lock); 2457 spin_unlock(&sbi->s_ext_stats_lock);
2487 #endif 2458 #endif
2488 2459
2489 trace_ext4_remove_blocks(inode, ex, f 2460 trace_ext4_remove_blocks(inode, ex, from, to, partial);
2490 2461
2491 /* 2462 /*
2492 * if we have a partial cluster, and 2463 * if we have a partial cluster, and it's different from the
2493 * cluster of the last block in the e 2464 * cluster of the last block in the extent, we free it
2494 */ 2465 */
2495 last_pblk = ext4_ext_pblock(ex) + ee_ 2466 last_pblk = ext4_ext_pblock(ex) + ee_len - 1;
2496 2467
2497 if (partial->state != initial && 2468 if (partial->state != initial &&
2498 partial->pclu != EXT4_B2C(sbi, la 2469 partial->pclu != EXT4_B2C(sbi, last_pblk)) {
2499 if (partial->state == tofree) 2470 if (partial->state == tofree) {
2500 flags = get_default_f 2471 flags = get_default_free_blocks_flags(inode);
2501 if (ext4_is_pending(i 2472 if (ext4_is_pending(inode, partial->lblk))
2502 flags |= EXT4 2473 flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
2503 ext4_free_blocks(hand 2474 ext4_free_blocks(handle, inode, NULL,
2504 EXT4 2475 EXT4_C2B(sbi, partial->pclu),
2505 sbi- 2476 sbi->s_cluster_ratio, flags);
2506 if (flags & EXT4_FREE 2477 if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
2507 ext4_rereserv 2478 ext4_rereserve_cluster(inode, partial->lblk);
2508 } 2479 }
2509 partial->state = initial; 2480 partial->state = initial;
2510 } 2481 }
2511 2482
2512 num = le32_to_cpu(ex->ee_block) + ee_ 2483 num = le32_to_cpu(ex->ee_block) + ee_len - from;
2513 pblk = ext4_ext_pblock(ex) + ee_len - 2484 pblk = ext4_ext_pblock(ex) + ee_len - num;
2514 2485
2515 /* 2486 /*
2516 * We free the partial cluster at the 2487 * We free the partial cluster at the end of the extent (if any),
2517 * unless the cluster is used by anot 2488 * unless the cluster is used by another extent (partial_cluster
2518 * state is nofree). If a partial cl 2489 * state is nofree). If a partial cluster exists here, it must be
2519 * shared with the last block in the 2490 * shared with the last block in the extent.
2520 */ 2491 */
2521 flags = get_default_free_blocks_flags 2492 flags = get_default_free_blocks_flags(inode);
2522 2493
2523 /* partial, left end cluster aligned, 2494 /* partial, left end cluster aligned, right end unaligned */
2524 if ((EXT4_LBLK_COFF(sbi, to) != sbi-> 2495 if ((EXT4_LBLK_COFF(sbi, to) != sbi->s_cluster_ratio - 1) &&
2525 (EXT4_LBLK_CMASK(sbi, to) >= from 2496 (EXT4_LBLK_CMASK(sbi, to) >= from) &&
2526 (partial->state != nofree)) { 2497 (partial->state != nofree)) {
2527 if (ext4_is_pending(inode, to 2498 if (ext4_is_pending(inode, to))
2528 flags |= EXT4_FREE_BL 2499 flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
2529 ext4_free_blocks(handle, inod 2500 ext4_free_blocks(handle, inode, NULL,
2530 EXT4_PBLK_CM 2501 EXT4_PBLK_CMASK(sbi, last_pblk),
2531 sbi->s_clust 2502 sbi->s_cluster_ratio, flags);
2532 if (flags & EXT4_FREE_BLOCKS_ 2503 if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
2533 ext4_rereserve_cluste 2504 ext4_rereserve_cluster(inode, to);
2534 partial->state = initial; 2505 partial->state = initial;
2535 flags = get_default_free_bloc 2506 flags = get_default_free_blocks_flags(inode);
2536 } 2507 }
2537 2508
2538 flags |= EXT4_FREE_BLOCKS_NOFREE_LAST 2509 flags |= EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER;
2539 2510
2540 /* 2511 /*
2541 * For bigalloc file systems, we neve 2512 * For bigalloc file systems, we never free a partial cluster
2542 * at the beginning of the extent. I 2513 * at the beginning of the extent. Instead, we check to see if we
2543 * need to free it on a subsequent ca 2514 * need to free it on a subsequent call to ext4_remove_blocks,
2544 * or at the end of ext4_ext_rm_leaf 2515 * or at the end of ext4_ext_rm_leaf or ext4_ext_remove_space.
2545 */ 2516 */
2546 flags |= EXT4_FREE_BLOCKS_NOFREE_FIRS 2517 flags |= EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER;
2547 ext4_free_blocks(handle, inode, NULL, 2518 ext4_free_blocks(handle, inode, NULL, pblk, num, flags);
2548 2519
2549 /* reset the partial cluster if we've 2520 /* reset the partial cluster if we've freed past it */
2550 if (partial->state != initial && part 2521 if (partial->state != initial && partial->pclu != EXT4_B2C(sbi, pblk))
2551 partial->state = initial; 2522 partial->state = initial;
2552 2523
2553 /* 2524 /*
2554 * If we've freed the entire extent b 2525 * If we've freed the entire extent but the beginning is not left
2555 * cluster aligned and is not marked 2526 * cluster aligned and is not marked as ineligible for freeing we
2556 * record the partial cluster at the 2527 * record the partial cluster at the beginning of the extent. It
2557 * wasn't freed by the preceding ext4 2528 * wasn't freed by the preceding ext4_free_blocks() call, and we
2558 * need to look farther to the left t 2529 * need to look farther to the left to determine if it's to be freed
2559 * (not shared with another extent). 2530 * (not shared with another extent). Else, reset the partial
2560 * cluster - we're either done freei 2531 * cluster - we're either done freeing or the beginning of the
2561 * extent is left cluster aligned. 2532 * extent is left cluster aligned.
2562 */ 2533 */
2563 if (EXT4_LBLK_COFF(sbi, from) && num 2534 if (EXT4_LBLK_COFF(sbi, from) && num == ee_len) {
2564 if (partial->state == initial 2535 if (partial->state == initial) {
2565 partial->pclu = EXT4_ 2536 partial->pclu = EXT4_B2C(sbi, pblk);
2566 partial->lblk = from; 2537 partial->lblk = from;
2567 partial->state = tofr 2538 partial->state = tofree;
2568 } 2539 }
2569 } else { 2540 } else {
2570 partial->state = initial; 2541 partial->state = initial;
2571 } 2542 }
2572 2543
2573 return 0; 2544 return 0;
2574 } 2545 }
2575 2546
2576 /* 2547 /*
2577 * ext4_ext_rm_leaf() Removes the extents ass 2548 * ext4_ext_rm_leaf() Removes the extents associated with the
2578 * blocks appearing between "start" and "end" 2549 * blocks appearing between "start" and "end". Both "start"
2579 * and "end" must appear in the same extent o 2550 * and "end" must appear in the same extent or EIO is returned.
2580 * 2551 *
2581 * @handle: The journal handle 2552 * @handle: The journal handle
2582 * @inode: The files inode 2553 * @inode: The files inode
2583 * @path: The path to the leaf 2554 * @path: The path to the leaf
2584 * @partial_cluster: The cluster which we'll 2555 * @partial_cluster: The cluster which we'll have to free if all extents
2585 * has been released from i 2556 * has been released from it. However, if this value is
2586 * negative, it's a cluster 2557 * negative, it's a cluster just to the right of the
2587 * punched region and it mu 2558 * punched region and it must not be freed.
2588 * @start: The first block to remove 2559 * @start: The first block to remove
2589 * @end: The last block to remove 2560 * @end: The last block to remove
2590 */ 2561 */
2591 static int 2562 static int
2592 ext4_ext_rm_leaf(handle_t *handle, struct ino 2563 ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
2593 struct ext4_ext_path *path, 2564 struct ext4_ext_path *path,
2594 struct partial_cluster *part 2565 struct partial_cluster *partial,
2595 ext4_lblk_t start, ext4_lblk 2566 ext4_lblk_t start, ext4_lblk_t end)
2596 { 2567 {
2597 struct ext4_sb_info *sbi = EXT4_SB(in 2568 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2598 int err = 0, correct_index = 0; 2569 int err = 0, correct_index = 0;
2599 int depth = ext_depth(inode), credits 2570 int depth = ext_depth(inode), credits, revoke_credits;
2600 struct ext4_extent_header *eh; 2571 struct ext4_extent_header *eh;
2601 ext4_lblk_t a, b; 2572 ext4_lblk_t a, b;
2602 unsigned num; 2573 unsigned num;
2603 ext4_lblk_t ex_ee_block; 2574 ext4_lblk_t ex_ee_block;
2604 unsigned short ex_ee_len; 2575 unsigned short ex_ee_len;
2605 unsigned unwritten = 0; 2576 unsigned unwritten = 0;
2606 struct ext4_extent *ex; 2577 struct ext4_extent *ex;
2607 ext4_fsblk_t pblk; 2578 ext4_fsblk_t pblk;
2608 2579
2609 /* the header must be checked already 2580 /* the header must be checked already in ext4_ext_remove_space() */
2610 ext_debug(inode, "truncate since %u i 2581 ext_debug(inode, "truncate since %u in leaf to %u\n", start, end);
2611 if (!path[depth].p_hdr) 2582 if (!path[depth].p_hdr)
2612 path[depth].p_hdr = ext_block 2583 path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);
2613 eh = path[depth].p_hdr; 2584 eh = path[depth].p_hdr;
2614 if (unlikely(path[depth].p_hdr == NUL 2585 if (unlikely(path[depth].p_hdr == NULL)) {
2615 EXT4_ERROR_INODE(inode, "path 2586 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2616 return -EFSCORRUPTED; 2587 return -EFSCORRUPTED;
2617 } 2588 }
2618 /* find where to start removing */ 2589 /* find where to start removing */
2619 ex = path[depth].p_ext; 2590 ex = path[depth].p_ext;
2620 if (!ex) 2591 if (!ex)
2621 ex = EXT_LAST_EXTENT(eh); 2592 ex = EXT_LAST_EXTENT(eh);
2622 2593
2623 ex_ee_block = le32_to_cpu(ex->ee_bloc 2594 ex_ee_block = le32_to_cpu(ex->ee_block);
2624 ex_ee_len = ext4_ext_get_actual_len(e 2595 ex_ee_len = ext4_ext_get_actual_len(ex);
2625 2596
2626 trace_ext4_ext_rm_leaf(inode, start, 2597 trace_ext4_ext_rm_leaf(inode, start, ex, partial);
2627 2598
2628 while (ex >= EXT_FIRST_EXTENT(eh) && 2599 while (ex >= EXT_FIRST_EXTENT(eh) &&
2629 ex_ee_block + ex_ee_l 2600 ex_ee_block + ex_ee_len > start) {
2630 2601
2631 if (ext4_ext_is_unwritten(ex) 2602 if (ext4_ext_is_unwritten(ex))
2632 unwritten = 1; 2603 unwritten = 1;
2633 else 2604 else
2634 unwritten = 0; 2605 unwritten = 0;
2635 2606
2636 ext_debug(inode, "remove ext 2607 ext_debug(inode, "remove ext %u:[%d]%d\n", ex_ee_block,
2637 unwritten, ex_ee_le 2608 unwritten, ex_ee_len);
2638 path[depth].p_ext = ex; 2609 path[depth].p_ext = ex;
2639 2610
2640 a = max(ex_ee_block, start); !! 2611 a = ex_ee_block > start ? ex_ee_block : start;
2641 b = min(ex_ee_block + ex_ee_l !! 2612 b = ex_ee_block+ex_ee_len - 1 < end ?
>> 2613 ex_ee_block+ex_ee_len - 1 : end;
2642 2614
2643 ext_debug(inode, " border %u 2615 ext_debug(inode, " border %u:%u\n", a, b);
2644 2616
2645 /* If this extent is beyond t 2617 /* If this extent is beyond the end of the hole, skip it */
2646 if (end < ex_ee_block) { 2618 if (end < ex_ee_block) {
2647 /* 2619 /*
2648 * We're going to ski 2620 * We're going to skip this extent and move to another,
2649 * so note that its f 2621 * so note that its first cluster is in use to avoid
2650 * freeing it when re 2622 * freeing it when removing blocks. Eventually, the
2651 * right edge of the 2623 * right edge of the truncated/punched region will
2652 * be just to the lef 2624 * be just to the left.
2653 */ 2625 */
2654 if (sbi->s_cluster_ra 2626 if (sbi->s_cluster_ratio > 1) {
2655 pblk = ext4_e 2627 pblk = ext4_ext_pblock(ex);
2656 partial->pclu 2628 partial->pclu = EXT4_B2C(sbi, pblk);
2657 partial->stat 2629 partial->state = nofree;
2658 } 2630 }
2659 ex--; 2631 ex--;
2660 ex_ee_block = le32_to 2632 ex_ee_block = le32_to_cpu(ex->ee_block);
2661 ex_ee_len = ext4_ext_ 2633 ex_ee_len = ext4_ext_get_actual_len(ex);
2662 continue; 2634 continue;
2663 } else if (b != ex_ee_block + 2635 } else if (b != ex_ee_block + ex_ee_len - 1) {
2664 EXT4_ERROR_INODE(inod 2636 EXT4_ERROR_INODE(inode,
2665 "can 2637 "can not handle truncate %u:%u "
2666 "on 2638 "on extent %u:%u",
2667 star 2639 start, end, ex_ee_block,
2668 ex_e 2640 ex_ee_block + ex_ee_len - 1);
2669 err = -EFSCORRUPTED; 2641 err = -EFSCORRUPTED;
2670 goto out; 2642 goto out;
2671 } else if (a != ex_ee_block) 2643 } else if (a != ex_ee_block) {
2672 /* remove tail of the 2644 /* remove tail of the extent */
2673 num = a - ex_ee_block 2645 num = a - ex_ee_block;
2674 } else { 2646 } else {
2675 /* remove whole exten 2647 /* remove whole extent: excellent! */
2676 num = 0; 2648 num = 0;
2677 } 2649 }
2678 /* 2650 /*
2679 * 3 for leaf, sb, and inode 2651 * 3 for leaf, sb, and inode plus 2 (bmap and group
2680 * descriptor) for each block 2652 * descriptor) for each block group; assume two block
2681 * groups plus ex_ee_len/bloc 2653 * groups plus ex_ee_len/blocks_per_block_group for
2682 * the worst case 2654 * the worst case
2683 */ 2655 */
2684 credits = 7 + 2*(ex_ee_len/EX 2656 credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb));
2685 if (ex == EXT_FIRST_EXTENT(eh 2657 if (ex == EXT_FIRST_EXTENT(eh)) {
2686 correct_index = 1; 2658 correct_index = 1;
2687 credits += (ext_depth 2659 credits += (ext_depth(inode)) + 1;
2688 } 2660 }
2689 credits += EXT4_MAXQUOTAS_TRA 2661 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
2690 /* 2662 /*
2691 * We may end up freeing some 2663 * We may end up freeing some index blocks and data from the
2692 * punched range. Note that p 2664 * punched range. Note that partial clusters are accounted for
2693 * by ext4_free_data_revoke_c 2665 * by ext4_free_data_revoke_credits().
2694 */ 2666 */
2695 revoke_credits = 2667 revoke_credits =
2696 ext4_free_metadata_re 2668 ext4_free_metadata_revoke_credits(inode->i_sb,
2697 2669 ext_depth(inode)) +
2698 ext4_free_data_revoke 2670 ext4_free_data_revoke_credits(inode, b - a + 1);
2699 2671
2700 err = ext4_datasem_ensure_cre 2672 err = ext4_datasem_ensure_credits(handle, inode, credits,
2701 2673 credits, revoke_credits);
2702 if (err) { 2674 if (err) {
2703 if (err > 0) 2675 if (err > 0)
2704 err = -EAGAIN 2676 err = -EAGAIN;
2705 goto out; 2677 goto out;
2706 } 2678 }
2707 2679
2708 err = ext4_ext_get_access(han 2680 err = ext4_ext_get_access(handle, inode, path + depth);
2709 if (err) 2681 if (err)
2710 goto out; 2682 goto out;
2711 2683
2712 err = ext4_remove_blocks(hand 2684 err = ext4_remove_blocks(handle, inode, ex, partial, a, b);
2713 if (err) 2685 if (err)
2714 goto out; 2686 goto out;
2715 2687
2716 if (num == 0) 2688 if (num == 0)
2717 /* this extent is rem 2689 /* this extent is removed; mark slot entirely unused */
2718 ext4_ext_store_pblock 2690 ext4_ext_store_pblock(ex, 0);
2719 2691
2720 ex->ee_len = cpu_to_le16(num) 2692 ex->ee_len = cpu_to_le16(num);
2721 /* 2693 /*
2722 * Do not mark unwritten if a 2694 * Do not mark unwritten if all the blocks in the
2723 * extent have been removed. 2695 * extent have been removed.
2724 */ 2696 */
2725 if (unwritten && num) 2697 if (unwritten && num)
2726 ext4_ext_mark_unwritt 2698 ext4_ext_mark_unwritten(ex);
2727 /* 2699 /*
2728 * If the extent was complete 2700 * If the extent was completely released,
2729 * we need to remove it from 2701 * we need to remove it from the leaf
2730 */ 2702 */
2731 if (num == 0) { 2703 if (num == 0) {
2732 if (end != EXT_MAX_BL 2704 if (end != EXT_MAX_BLOCKS - 1) {
2733 /* 2705 /*
2734 * For hole p 2706 * For hole punching, we need to scoot all the
2735 * extents up 2707 * extents up when an extent is removed so that
2736 * we dont ha 2708 * we dont have blank extents in the middle
2737 */ 2709 */
2738 memmove(ex, e 2710 memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) *
2739 sizeo 2711 sizeof(struct ext4_extent));
2740 2712
2741 /* Now get ri 2713 /* Now get rid of the one at the end */
2742 memset(EXT_LA 2714 memset(EXT_LAST_EXTENT(eh), 0,
2743 sizeo 2715 sizeof(struct ext4_extent));
2744 } 2716 }
2745 le16_add_cpu(&eh->eh_ 2717 le16_add_cpu(&eh->eh_entries, -1);
2746 } 2718 }
2747 2719
2748 err = ext4_ext_dirty(handle, 2720 err = ext4_ext_dirty(handle, inode, path + depth);
2749 if (err) 2721 if (err)
2750 goto out; 2722 goto out;
2751 2723
2752 ext_debug(inode, "new extent: 2724 ext_debug(inode, "new extent: %u:%u:%llu\n", ex_ee_block, num,
2753 ext4_ext_pblo 2725 ext4_ext_pblock(ex));
2754 ex--; 2726 ex--;
2755 ex_ee_block = le32_to_cpu(ex- 2727 ex_ee_block = le32_to_cpu(ex->ee_block);
2756 ex_ee_len = ext4_ext_get_actu 2728 ex_ee_len = ext4_ext_get_actual_len(ex);
2757 } 2729 }
2758 2730
2759 if (correct_index && eh->eh_entries) 2731 if (correct_index && eh->eh_entries)
2760 err = ext4_ext_correct_indexe 2732 err = ext4_ext_correct_indexes(handle, inode, path);
2761 2733
2762 /* 2734 /*
2763 * If there's a partial cluster and a 2735 * If there's a partial cluster and at least one extent remains in
2764 * the leaf, free the partial cluster 2736 * the leaf, free the partial cluster if it isn't shared with the
2765 * current extent. If it is shared w 2737 * current extent. If it is shared with the current extent
2766 * we reset the partial cluster becau 2738 * we reset the partial cluster because we've reached the start of the
2767 * truncated/punched region and we're 2739 * truncated/punched region and we're done removing blocks.
2768 */ 2740 */
2769 if (partial->state == tofree && ex >= 2741 if (partial->state == tofree && ex >= EXT_FIRST_EXTENT(eh)) {
2770 pblk = ext4_ext_pblock(ex) + 2742 pblk = ext4_ext_pblock(ex) + ex_ee_len - 1;
2771 if (partial->pclu != EXT4_B2C 2743 if (partial->pclu != EXT4_B2C(sbi, pblk)) {
2772 int flags = get_defau 2744 int flags = get_default_free_blocks_flags(inode);
2773 2745
2774 if (ext4_is_pending(i 2746 if (ext4_is_pending(inode, partial->lblk))
2775 flags |= EXT4 2747 flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
2776 ext4_free_blocks(hand 2748 ext4_free_blocks(handle, inode, NULL,
2777 EXT4 2749 EXT4_C2B(sbi, partial->pclu),
2778 sbi- 2750 sbi->s_cluster_ratio, flags);
2779 if (flags & EXT4_FREE 2751 if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
2780 ext4_rereserv 2752 ext4_rereserve_cluster(inode, partial->lblk);
2781 } 2753 }
2782 partial->state = initial; 2754 partial->state = initial;
2783 } 2755 }
2784 2756
2785 /* if this leaf is free, then we shou 2757 /* if this leaf is free, then we should
2786 * remove it from index block above * 2758 * remove it from index block above */
2787 if (err == 0 && eh->eh_entries == 0 & 2759 if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
2788 err = ext4_ext_rm_idx(handle, 2760 err = ext4_ext_rm_idx(handle, inode, path, depth);
2789 2761
2790 out: 2762 out:
2791 return err; 2763 return err;
2792 } 2764 }
2793 2765
2794 /* 2766 /*
2795 * ext4_ext_more_to_rm: 2767 * ext4_ext_more_to_rm:
2796 * returns 1 if current index has to be freed 2768 * returns 1 if current index has to be freed (even partial)
2797 */ 2769 */
2798 static int 2770 static int
2799 ext4_ext_more_to_rm(struct ext4_ext_path *pat 2771 ext4_ext_more_to_rm(struct ext4_ext_path *path)
2800 { 2772 {
2801 BUG_ON(path->p_idx == NULL); 2773 BUG_ON(path->p_idx == NULL);
2802 2774
2803 if (path->p_idx < EXT_FIRST_INDEX(pat 2775 if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr))
2804 return 0; 2776 return 0;
2805 2777
2806 /* 2778 /*
2807 * if truncate on deeper level happen 2779 * if truncate on deeper level happened, it wasn't partial,
2808 * so we have to consider current ind 2780 * so we have to consider current index for truncation
2809 */ 2781 */
2810 if (le16_to_cpu(path->p_hdr->eh_entri 2782 if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)
2811 return 0; 2783 return 0;
2812 return 1; 2784 return 1;
2813 } 2785 }
2814 2786
2815 int ext4_ext_remove_space(struct inode *inode 2787 int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
2816 ext4_lblk_t end) 2788 ext4_lblk_t end)
2817 { 2789 {
2818 struct ext4_sb_info *sbi = EXT4_SB(in 2790 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2819 int depth = ext_depth(inode); 2791 int depth = ext_depth(inode);
2820 struct ext4_ext_path *path = NULL; 2792 struct ext4_ext_path *path = NULL;
2821 struct partial_cluster partial; 2793 struct partial_cluster partial;
2822 handle_t *handle; 2794 handle_t *handle;
2823 int i = 0, err = 0; 2795 int i = 0, err = 0;
2824 2796
2825 partial.pclu = 0; 2797 partial.pclu = 0;
2826 partial.lblk = 0; 2798 partial.lblk = 0;
2827 partial.state = initial; 2799 partial.state = initial;
2828 2800
2829 ext_debug(inode, "truncate since %u t 2801 ext_debug(inode, "truncate since %u to %u\n", start, end);
2830 2802
2831 /* probably first extent we're gonna 2803 /* probably first extent we're gonna free will be last in block */
2832 handle = ext4_journal_start_with_revo 2804 handle = ext4_journal_start_with_revoke(inode, EXT4_HT_TRUNCATE,
2833 depth + 1, 2805 depth + 1,
2834 ext4_free_metadata_re 2806 ext4_free_metadata_revoke_credits(inode->i_sb, depth));
2835 if (IS_ERR(handle)) 2807 if (IS_ERR(handle))
2836 return PTR_ERR(handle); 2808 return PTR_ERR(handle);
2837 2809
2838 again: 2810 again:
2839 trace_ext4_ext_remove_space(inode, st 2811 trace_ext4_ext_remove_space(inode, start, end, depth);
2840 2812
2841 /* 2813 /*
2842 * Check if we are removing extents i 2814 * Check if we are removing extents inside the extent tree. If that
2843 * is the case, we are going to punch 2815 * is the case, we are going to punch a hole inside the extent tree
2844 * so we have to check whether we nee 2816 * so we have to check whether we need to split the extent covering
2845 * the last block to remove so we can 2817 * the last block to remove so we can easily remove the part of it
2846 * in ext4_ext_rm_leaf(). 2818 * in ext4_ext_rm_leaf().
2847 */ 2819 */
2848 if (end < EXT_MAX_BLOCKS - 1) { 2820 if (end < EXT_MAX_BLOCKS - 1) {
2849 struct ext4_extent *ex; 2821 struct ext4_extent *ex;
2850 ext4_lblk_t ee_block, ex_end, 2822 ext4_lblk_t ee_block, ex_end, lblk;
2851 ext4_fsblk_t pblk; 2823 ext4_fsblk_t pblk;
2852 2824
2853 /* find extent for or closest 2825 /* find extent for or closest extent to this block */
2854 path = ext4_find_extent(inode 2826 path = ext4_find_extent(inode, end, NULL,
2855 EXT4_ 2827 EXT4_EX_NOCACHE | EXT4_EX_NOFAIL);
2856 if (IS_ERR(path)) { 2828 if (IS_ERR(path)) {
2857 ext4_journal_stop(han 2829 ext4_journal_stop(handle);
2858 return PTR_ERR(path); 2830 return PTR_ERR(path);
2859 } 2831 }
2860 depth = ext_depth(inode); 2832 depth = ext_depth(inode);
2861 /* Leaf not may not exist onl 2833 /* Leaf not may not exist only if inode has no blocks at all */
2862 ex = path[depth].p_ext; 2834 ex = path[depth].p_ext;
2863 if (!ex) { 2835 if (!ex) {
2864 if (depth) { 2836 if (depth) {
2865 EXT4_ERROR_IN 2837 EXT4_ERROR_INODE(inode,
2866 2838 "path[%d].p_hdr == NULL",
2867 2839 depth);
2868 err = -EFSCOR 2840 err = -EFSCORRUPTED;
2869 } 2841 }
2870 goto out; 2842 goto out;
2871 } 2843 }
2872 2844
2873 ee_block = le32_to_cpu(ex->ee 2845 ee_block = le32_to_cpu(ex->ee_block);
2874 ex_end = ee_block + ext4_ext_ 2846 ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1;
2875 2847
2876 /* 2848 /*
2877 * See if the last block is i 2849 * See if the last block is inside the extent, if so split
2878 * the extent at 'end' block 2850 * the extent at 'end' block so we can easily remove the
2879 * tail of the first part of 2851 * tail of the first part of the split extent in
2880 * ext4_ext_rm_leaf(). 2852 * ext4_ext_rm_leaf().
2881 */ 2853 */
2882 if (end >= ee_block && end < 2854 if (end >= ee_block && end < ex_end) {
2883 2855
2884 /* 2856 /*
2885 * If we're going to 2857 * If we're going to split the extent, note that
2886 * the cluster contai 2858 * the cluster containing the block after 'end' is
2887 * in use to avoid fr 2859 * in use to avoid freeing it when removing blocks.
2888 */ 2860 */
2889 if (sbi->s_cluster_ra 2861 if (sbi->s_cluster_ratio > 1) {
2890 pblk = ext4_e 2862 pblk = ext4_ext_pblock(ex) + end - ee_block + 1;
2891 partial.pclu 2863 partial.pclu = EXT4_B2C(sbi, pblk);
2892 partial.state 2864 partial.state = nofree;
2893 } 2865 }
2894 2866
2895 /* 2867 /*
2896 * Split the extent i 2868 * Split the extent in two so that 'end' is the last
2897 * block in the first 2869 * block in the first new extent. Also we should not
2898 * fail removing spac 2870 * fail removing space due to ENOSPC so try to use
2899 * reserved block if 2871 * reserved block if that happens.
2900 */ 2872 */
2901 path = ext4_force_spl !! 2873 err = ext4_force_split_extent_at(handle, inode, &path,
2902 !! 2874 end + 1, 1);
2903 if (IS_ERR(path)) { !! 2875 if (err < 0)
2904 err = PTR_ERR <<
2905 goto out; 2876 goto out;
2906 } !! 2877
2907 } else if (sbi->s_cluster_rat 2878 } else if (sbi->s_cluster_ratio > 1 && end >= ex_end &&
2908 partial.state == i 2879 partial.state == initial) {
2909 /* 2880 /*
2910 * If we're punching, 2881 * If we're punching, there's an extent to the right.
2911 * If the partial clu 2882 * If the partial cluster hasn't been set, set it to
2912 * that extent's firs 2883 * that extent's first cluster and its state to nofree
2913 * so it won't be fre 2884 * so it won't be freed should it contain blocks to be
2914 * removed. If it's a 2885 * removed. If it's already set (tofree/nofree), we're
2915 * retrying and keep 2886 * retrying and keep the original partial cluster info
2916 * so a cluster marke 2887 * so a cluster marked tofree as a result of earlier
2917 * extent removal is 2888 * extent removal is not lost.
2918 */ 2889 */
2919 lblk = ex_end + 1; 2890 lblk = ex_end + 1;
2920 err = ext4_ext_search 2891 err = ext4_ext_search_right(inode, path, &lblk, &pblk,
2921 2892 NULL);
2922 if (err < 0) 2893 if (err < 0)
2923 goto out; 2894 goto out;
2924 if (pblk) { 2895 if (pblk) {
2925 partial.pclu 2896 partial.pclu = EXT4_B2C(sbi, pblk);
2926 partial.state 2897 partial.state = nofree;
2927 } 2898 }
2928 } 2899 }
2929 } 2900 }
2930 /* 2901 /*
2931 * We start scanning from right side, 2902 * We start scanning from right side, freeing all the blocks
2932 * after i_size and walking into the 2903 * after i_size and walking into the tree depth-wise.
2933 */ 2904 */
2934 depth = ext_depth(inode); 2905 depth = ext_depth(inode);
2935 if (path) { 2906 if (path) {
2936 int k = i = depth; 2907 int k = i = depth;
2937 while (--k > 0) 2908 while (--k > 0)
2938 path[k].p_block = 2909 path[k].p_block =
2939 le16_to_cpu(p 2910 le16_to_cpu(path[k].p_hdr->eh_entries)+1;
2940 } else { 2911 } else {
2941 path = kcalloc(depth + 1, siz 2912 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
2942 GFP_NOFS | __G 2913 GFP_NOFS | __GFP_NOFAIL);
2943 if (path == NULL) { 2914 if (path == NULL) {
2944 ext4_journal_stop(han 2915 ext4_journal_stop(handle);
2945 return -ENOMEM; 2916 return -ENOMEM;
2946 } 2917 }
2947 path[0].p_maxdepth = path[0]. 2918 path[0].p_maxdepth = path[0].p_depth = depth;
2948 path[0].p_hdr = ext_inode_hdr 2919 path[0].p_hdr = ext_inode_hdr(inode);
2949 i = 0; 2920 i = 0;
2950 2921
2951 if (ext4_ext_check(inode, pat 2922 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
2952 err = -EFSCORRUPTED; 2923 err = -EFSCORRUPTED;
2953 goto out; 2924 goto out;
2954 } 2925 }
2955 } 2926 }
2956 err = 0; 2927 err = 0;
2957 2928
2958 while (i >= 0 && err == 0) { 2929 while (i >= 0 && err == 0) {
2959 if (i == depth) { 2930 if (i == depth) {
2960 /* this is leaf block 2931 /* this is leaf block */
2961 err = ext4_ext_rm_lea 2932 err = ext4_ext_rm_leaf(handle, inode, path,
2962 2933 &partial, start, end);
2963 /* root level has p_b 2934 /* root level has p_bh == NULL, brelse() eats this */
2964 ext4_ext_path_brelse( !! 2935 brelse(path[i].p_bh);
>> 2936 path[i].p_bh = NULL;
2965 i--; 2937 i--;
2966 continue; 2938 continue;
2967 } 2939 }
2968 2940
2969 /* this is index block */ 2941 /* this is index block */
2970 if (!path[i].p_hdr) { 2942 if (!path[i].p_hdr) {
2971 ext_debug(inode, "ini 2943 ext_debug(inode, "initialize header\n");
2972 path[i].p_hdr = ext_b 2944 path[i].p_hdr = ext_block_hdr(path[i].p_bh);
2973 } 2945 }
2974 2946
2975 if (!path[i].p_idx) { 2947 if (!path[i].p_idx) {
2976 /* this level hasn't 2948 /* this level hasn't been touched yet */
2977 path[i].p_idx = EXT_L 2949 path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
2978 path[i].p_block = le1 2950 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
2979 ext_debug(inode, "ini 2951 ext_debug(inode, "init index ptr: hdr 0x%p, num %d\n",
2980 path[i].p_h 2952 path[i].p_hdr,
2981 le16_to_cpu 2953 le16_to_cpu(path[i].p_hdr->eh_entries));
2982 } else { 2954 } else {
2983 /* we were already he 2955 /* we were already here, see at next index */
2984 path[i].p_idx--; 2956 path[i].p_idx--;
2985 } 2957 }
2986 2958
2987 ext_debug(inode, "level %d - 2959 ext_debug(inode, "level %d - index, first 0x%p, cur 0x%p\n",
2988 i, EXT_FIRST_ 2960 i, EXT_FIRST_INDEX(path[i].p_hdr),
2989 path[i].p_idx 2961 path[i].p_idx);
2990 if (ext4_ext_more_to_rm(path 2962 if (ext4_ext_more_to_rm(path + i)) {
2991 struct buffer_head *b 2963 struct buffer_head *bh;
2992 /* go to the next lev 2964 /* go to the next level */
2993 ext_debug(inode, "mov 2965 ext_debug(inode, "move to level %d (block %llu)\n",
2994 i + 1, ext4 2966 i + 1, ext4_idx_pblock(path[i].p_idx));
2995 memset(path + i + 1, 2967 memset(path + i + 1, 0, sizeof(*path));
2996 bh = read_extent_tree 2968 bh = read_extent_tree_block(inode, path[i].p_idx,
2997 2969 depth - i - 1,
2998 2970 EXT4_EX_NOCACHE);
2999 if (IS_ERR(bh)) { 2971 if (IS_ERR(bh)) {
3000 /* should we 2972 /* should we reset i_size? */
3001 err = PTR_ERR 2973 err = PTR_ERR(bh);
3002 break; 2974 break;
3003 } 2975 }
3004 /* Yield here to deal 2976 /* Yield here to deal with large extent trees.
3005 * Should be a no-op 2977 * Should be a no-op if we did IO above. */
3006 cond_resched(); 2978 cond_resched();
3007 if (WARN_ON(i + 1 > d 2979 if (WARN_ON(i + 1 > depth)) {
3008 err = -EFSCOR 2980 err = -EFSCORRUPTED;
3009 break; 2981 break;
3010 } 2982 }
3011 path[i + 1].p_bh = bh 2983 path[i + 1].p_bh = bh;
3012 2984
3013 /* save actual number 2985 /* save actual number of indexes since this
3014 * number is changed 2986 * number is changed at the next iteration */
3015 path[i].p_block = le1 2987 path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
3016 i++; 2988 i++;
3017 } else { 2989 } else {
3018 /* we finished proces 2990 /* we finished processing this index, go up */
3019 if (path[i].p_hdr->eh 2991 if (path[i].p_hdr->eh_entries == 0 && i > 0) {
3020 /* index is e 2992 /* index is empty, remove it;
3021 * handle mus 2993 * handle must be already prepared by the
3022 * truncatei_ 2994 * truncatei_leaf() */
3023 err = ext4_ex 2995 err = ext4_ext_rm_idx(handle, inode, path, i);
3024 } 2996 }
3025 /* root level has p_b 2997 /* root level has p_bh == NULL, brelse() eats this */
3026 ext4_ext_path_brelse( !! 2998 brelse(path[i].p_bh);
>> 2999 path[i].p_bh = NULL;
3027 i--; 3000 i--;
3028 ext_debug(inode, "ret 3001 ext_debug(inode, "return to level %d\n", i);
3029 } 3002 }
3030 } 3003 }
3031 3004
3032 trace_ext4_ext_remove_space_done(inod 3005 trace_ext4_ext_remove_space_done(inode, start, end, depth, &partial,
3033 path 3006 path->p_hdr->eh_entries);
3034 3007
3035 /* 3008 /*
3036 * if there's a partial cluster and w 3009 * if there's a partial cluster and we have removed the first extent
3037 * in the file, then we also free the 3010 * in the file, then we also free the partial cluster, if any
3038 */ 3011 */
3039 if (partial.state == tofree && err == 3012 if (partial.state == tofree && err == 0) {
3040 int flags = get_default_free_ 3013 int flags = get_default_free_blocks_flags(inode);
3041 3014
3042 if (ext4_is_pending(inode, pa 3015 if (ext4_is_pending(inode, partial.lblk))
3043 flags |= EXT4_FREE_BL 3016 flags |= EXT4_FREE_BLOCKS_RERESERVE_CLUSTER;
3044 ext4_free_blocks(handle, inod 3017 ext4_free_blocks(handle, inode, NULL,
3045 EXT4_C2B(sbi 3018 EXT4_C2B(sbi, partial.pclu),
3046 sbi->s_clust 3019 sbi->s_cluster_ratio, flags);
3047 if (flags & EXT4_FREE_BLOCKS_ 3020 if (flags & EXT4_FREE_BLOCKS_RERESERVE_CLUSTER)
3048 ext4_rereserve_cluste 3021 ext4_rereserve_cluster(inode, partial.lblk);
3049 partial.state = initial; 3022 partial.state = initial;
3050 } 3023 }
3051 3024
3052 /* TODO: flexible tree reduction shou 3025 /* TODO: flexible tree reduction should be here */
3053 if (path->p_hdr->eh_entries == 0) { 3026 if (path->p_hdr->eh_entries == 0) {
3054 /* 3027 /*
3055 * truncate to zero freed all 3028 * truncate to zero freed all the tree,
3056 * so we need to correct eh_d 3029 * so we need to correct eh_depth
3057 */ 3030 */
3058 err = ext4_ext_get_access(han 3031 err = ext4_ext_get_access(handle, inode, path);
3059 if (err == 0) { 3032 if (err == 0) {
3060 ext_inode_hdr(inode)- 3033 ext_inode_hdr(inode)->eh_depth = 0;
3061 ext_inode_hdr(inode)- 3034 ext_inode_hdr(inode)->eh_max =
3062 cpu_to_le16(e 3035 cpu_to_le16(ext4_ext_space_root(inode, 0));
3063 err = ext4_ext_dirty( 3036 err = ext4_ext_dirty(handle, inode, path);
3064 } 3037 }
3065 } 3038 }
3066 out: 3039 out:
3067 ext4_free_ext_path(path); !! 3040 ext4_ext_drop_refs(path);
>> 3041 kfree(path);
3068 path = NULL; 3042 path = NULL;
3069 if (err == -EAGAIN) 3043 if (err == -EAGAIN)
3070 goto again; 3044 goto again;
3071 ext4_journal_stop(handle); 3045 ext4_journal_stop(handle);
3072 3046
3073 return err; 3047 return err;
3074 } 3048 }
3075 3049
3076 /* 3050 /*
3077 * called at mount time 3051 * called at mount time
3078 */ 3052 */
3079 void ext4_ext_init(struct super_block *sb) 3053 void ext4_ext_init(struct super_block *sb)
3080 { 3054 {
3081 /* 3055 /*
3082 * possible initialization would be h 3056 * possible initialization would be here
3083 */ 3057 */
3084 3058
3085 if (ext4_has_feature_extents(sb)) { 3059 if (ext4_has_feature_extents(sb)) {
3086 #if defined(AGGRESSIVE_TEST) || defined(CHECK 3060 #if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS)
3087 printk(KERN_INFO "EXT4-fs: fi 3061 printk(KERN_INFO "EXT4-fs: file extents enabled"
3088 #ifdef AGGRESSIVE_TEST 3062 #ifdef AGGRESSIVE_TEST
3089 ", aggressive tests" 3063 ", aggressive tests"
3090 #endif 3064 #endif
3091 #ifdef CHECK_BINSEARCH 3065 #ifdef CHECK_BINSEARCH
3092 ", check binsearch" 3066 ", check binsearch"
3093 #endif 3067 #endif
3094 #ifdef EXTENTS_STATS 3068 #ifdef EXTENTS_STATS
3095 ", stats" 3069 ", stats"
3096 #endif 3070 #endif
3097 "\n"); 3071 "\n");
3098 #endif 3072 #endif
3099 #ifdef EXTENTS_STATS 3073 #ifdef EXTENTS_STATS
3100 spin_lock_init(&EXT4_SB(sb)-> 3074 spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock);
3101 EXT4_SB(sb)->s_ext_min = 1 << 3075 EXT4_SB(sb)->s_ext_min = 1 << 30;
3102 EXT4_SB(sb)->s_ext_max = 0; 3076 EXT4_SB(sb)->s_ext_max = 0;
3103 #endif 3077 #endif
3104 } 3078 }
3105 } 3079 }
3106 3080
3107 /* 3081 /*
3108 * called at umount time 3082 * called at umount time
3109 */ 3083 */
3110 void ext4_ext_release(struct super_block *sb) 3084 void ext4_ext_release(struct super_block *sb)
3111 { 3085 {
3112 if (!ext4_has_feature_extents(sb)) 3086 if (!ext4_has_feature_extents(sb))
3113 return; 3087 return;
3114 3088
3115 #ifdef EXTENTS_STATS 3089 #ifdef EXTENTS_STATS
3116 if (EXT4_SB(sb)->s_ext_blocks && EXT4 3090 if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) {
3117 struct ext4_sb_info *sbi = EX 3091 struct ext4_sb_info *sbi = EXT4_SB(sb);
3118 printk(KERN_ERR "EXT4-fs: %lu 3092 printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave)\n",
3119 sbi->s_ext_blocks, sb 3093 sbi->s_ext_blocks, sbi->s_ext_extents,
3120 sbi->s_ext_blocks / s 3094 sbi->s_ext_blocks / sbi->s_ext_extents);
3121 printk(KERN_ERR "EXT4-fs: ext 3095 printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n",
3122 sbi->s_ext_min, sbi-> 3096 sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max);
3123 } 3097 }
3124 #endif 3098 #endif
3125 } 3099 }
3126 3100
3127 static void ext4_zeroout_es(struct inode *ino !! 3101 static int ext4_zeroout_es(struct inode *inode, struct ext4_extent *ex)
3128 { 3102 {
3129 ext4_lblk_t ee_block; 3103 ext4_lblk_t ee_block;
3130 ext4_fsblk_t ee_pblock; 3104 ext4_fsblk_t ee_pblock;
3131 unsigned int ee_len; 3105 unsigned int ee_len;
3132 3106
3133 ee_block = le32_to_cpu(ex->ee_block) 3107 ee_block = le32_to_cpu(ex->ee_block);
3134 ee_len = ext4_ext_get_actual_len(e 3108 ee_len = ext4_ext_get_actual_len(ex);
3135 ee_pblock = ext4_ext_pblock(ex); 3109 ee_pblock = ext4_ext_pblock(ex);
3136 3110
3137 if (ee_len == 0) 3111 if (ee_len == 0)
3138 return; !! 3112 return 0;
3139 3113
3140 ext4_es_insert_extent(inode, ee_block 3114 ext4_es_insert_extent(inode, ee_block, ee_len, ee_pblock,
3141 EXTENT_STATUS_W !! 3115 EXTENT_STATUS_WRITTEN);
>> 3116 return 0;
3142 } 3117 }
3143 3118
3144 /* FIXME!! we need to try to merge to left or 3119 /* FIXME!! we need to try to merge to left or right after zero-out */
3145 static int ext4_ext_zeroout(struct inode *ino 3120 static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
3146 { 3121 {
3147 ext4_fsblk_t ee_pblock; 3122 ext4_fsblk_t ee_pblock;
3148 unsigned int ee_len; 3123 unsigned int ee_len;
3149 3124
3150 ee_len = ext4_ext_get_actual_len(e 3125 ee_len = ext4_ext_get_actual_len(ex);
3151 ee_pblock = ext4_ext_pblock(ex); 3126 ee_pblock = ext4_ext_pblock(ex);
3152 return ext4_issue_zeroout(inode, le32 3127 return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,
3153 ee_len); 3128 ee_len);
3154 } 3129 }
3155 3130
3156 /* 3131 /*
3157 * ext4_split_extent_at() splits an extent at 3132 * ext4_split_extent_at() splits an extent at given block.
3158 * 3133 *
3159 * @handle: the journal handle 3134 * @handle: the journal handle
3160 * @inode: the file inode 3135 * @inode: the file inode
3161 * @path: the path to the extent 3136 * @path: the path to the extent
3162 * @split: the logical block where the extent 3137 * @split: the logical block where the extent is splitted.
3163 * @split_flags: indicates if the extent coul 3138 * @split_flags: indicates if the extent could be zeroout if split fails, and
3164 * the states(init or unwritten 3139 * the states(init or unwritten) of new extents.
3165 * @flags: flags used to insert new extent to 3140 * @flags: flags used to insert new extent to extent tree.
3166 * 3141 *
3167 * 3142 *
3168 * Splits extent [a, b] into two extents [a, 3143 * Splits extent [a, b] into two extents [a, @split) and [@split, b], states
3169 * of which are determined by split_flag. 3144 * of which are determined by split_flag.
3170 * 3145 *
3171 * There are two cases: 3146 * There are two cases:
3172 * a> the extent are splitted into two exten 3147 * a> the extent are splitted into two extent.
3173 * b> split is not needed, and just mark the 3148 * b> split is not needed, and just mark the extent.
3174 * 3149 *
3175 * Return an extent path pointer on success, !! 3150 * return 0 on success.
3176 */ 3151 */
3177 static struct ext4_ext_path *ext4_split_exten !! 3152 static int ext4_split_extent_at(handle_t *handle,
3178 !! 3153 struct inode *inode,
3179 !! 3154 struct ext4_ext_path **ppath,
3180 !! 3155 ext4_lblk_t split,
3181 !! 3156 int split_flag,
>> 3157 int flags)
3182 { 3158 {
>> 3159 struct ext4_ext_path *path = *ppath;
3183 ext4_fsblk_t newblock; 3160 ext4_fsblk_t newblock;
3184 ext4_lblk_t ee_block; 3161 ext4_lblk_t ee_block;
3185 struct ext4_extent *ex, newex, orig_e 3162 struct ext4_extent *ex, newex, orig_ex, zero_ex;
3186 struct ext4_extent *ex2 = NULL; 3163 struct ext4_extent *ex2 = NULL;
3187 unsigned int ee_len, depth; 3164 unsigned int ee_len, depth;
3188 int err = 0; 3165 int err = 0;
3189 3166
3190 BUG_ON((split_flag & (EXT4_EXT_DATA_V 3167 BUG_ON((split_flag & (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2)) ==
3191 (EXT4_EXT_DATA_VALID1 | EXT4_E 3168 (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2));
3192 3169
3193 ext_debug(inode, "logical block %llu\ 3170 ext_debug(inode, "logical block %llu\n", (unsigned long long)split);
3194 3171
3195 ext4_ext_show_leaf(inode, path); 3172 ext4_ext_show_leaf(inode, path);
3196 3173
3197 depth = ext_depth(inode); 3174 depth = ext_depth(inode);
3198 ex = path[depth].p_ext; 3175 ex = path[depth].p_ext;
3199 ee_block = le32_to_cpu(ex->ee_block); 3176 ee_block = le32_to_cpu(ex->ee_block);
3200 ee_len = ext4_ext_get_actual_len(ex); 3177 ee_len = ext4_ext_get_actual_len(ex);
3201 newblock = split - ee_block + ext4_ex 3178 newblock = split - ee_block + ext4_ext_pblock(ex);
3202 3179
3203 BUG_ON(split < ee_block || split >= ( 3180 BUG_ON(split < ee_block || split >= (ee_block + ee_len));
3204 BUG_ON(!ext4_ext_is_unwritten(ex) && 3181 BUG_ON(!ext4_ext_is_unwritten(ex) &&
3205 split_flag & (EXT4_EXT_MAY_ZER 3182 split_flag & (EXT4_EXT_MAY_ZEROOUT |
3206 EXT4_EXT_MARK_UN 3183 EXT4_EXT_MARK_UNWRIT1 |
3207 EXT4_EXT_MARK_UN 3184 EXT4_EXT_MARK_UNWRIT2));
3208 3185
3209 err = ext4_ext_get_access(handle, ino 3186 err = ext4_ext_get_access(handle, inode, path + depth);
3210 if (err) 3187 if (err)
3211 goto out; 3188 goto out;
3212 3189
3213 if (split == ee_block) { 3190 if (split == ee_block) {
3214 /* 3191 /*
3215 * case b: block @split is th 3192 * case b: block @split is the block that the extent begins with
3216 * then we just change the st 3193 * then we just change the state of the extent, and splitting
3217 * is not needed. 3194 * is not needed.
3218 */ 3195 */
3219 if (split_flag & EXT4_EXT_MAR 3196 if (split_flag & EXT4_EXT_MARK_UNWRIT2)
3220 ext4_ext_mark_unwritt 3197 ext4_ext_mark_unwritten(ex);
3221 else 3198 else
3222 ext4_ext_mark_initial 3199 ext4_ext_mark_initialized(ex);
3223 3200
3224 if (!(flags & EXT4_GET_BLOCKS 3201 if (!(flags & EXT4_GET_BLOCKS_PRE_IO))
3225 ext4_ext_try_to_merge 3202 ext4_ext_try_to_merge(handle, inode, path, ex);
3226 3203
3227 err = ext4_ext_dirty(handle, 3204 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3228 goto out; 3205 goto out;
3229 } 3206 }
3230 3207
3231 /* case a */ 3208 /* case a */
3232 memcpy(&orig_ex, ex, sizeof(orig_ex)) 3209 memcpy(&orig_ex, ex, sizeof(orig_ex));
3233 ex->ee_len = cpu_to_le16(split - ee_b 3210 ex->ee_len = cpu_to_le16(split - ee_block);
3234 if (split_flag & EXT4_EXT_MARK_UNWRIT 3211 if (split_flag & EXT4_EXT_MARK_UNWRIT1)
3235 ext4_ext_mark_unwritten(ex); 3212 ext4_ext_mark_unwritten(ex);
3236 3213
3237 /* 3214 /*
3238 * path may lead to new leaf, not to 3215 * path may lead to new leaf, not to original leaf any more
3239 * after ext4_ext_insert_extent() ret 3216 * after ext4_ext_insert_extent() returns,
3240 */ 3217 */
3241 err = ext4_ext_dirty(handle, inode, p 3218 err = ext4_ext_dirty(handle, inode, path + depth);
3242 if (err) 3219 if (err)
3243 goto fix_extent_len; 3220 goto fix_extent_len;
3244 3221
3245 ex2 = &newex; 3222 ex2 = &newex;
3246 ex2->ee_block = cpu_to_le32(split); 3223 ex2->ee_block = cpu_to_le32(split);
3247 ex2->ee_len = cpu_to_le16(ee_len - 3224 ex2->ee_len = cpu_to_le16(ee_len - (split - ee_block));
3248 ext4_ext_store_pblock(ex2, newblock); 3225 ext4_ext_store_pblock(ex2, newblock);
3249 if (split_flag & EXT4_EXT_MARK_UNWRIT 3226 if (split_flag & EXT4_EXT_MARK_UNWRIT2)
3250 ext4_ext_mark_unwritten(ex2); 3227 ext4_ext_mark_unwritten(ex2);
3251 3228
3252 path = ext4_ext_insert_extent(handle, !! 3229 err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags);
3253 if (!IS_ERR(path)) <<
3254 goto out; <<
3255 <<
3256 err = PTR_ERR(path); <<
3257 if (err != -ENOSPC && err != -EDQUOT 3230 if (err != -ENOSPC && err != -EDQUOT && err != -ENOMEM)
3258 return path; !! 3231 goto out;
3259 3232
3260 /* 3233 /*
3261 * Get a new path to try to zeroout o !! 3234 * Update path is required because previous ext4_ext_insert_extent()
3262 * Using EXT4_EX_NOFAIL guarantees th !! 3235 * may have freed or reallocated the path. Using EXT4_EX_NOFAIL
3263 * will not return -ENOMEM, otherwise !! 3236 * guarantees that ext4_find_extent() will not return -ENOMEM,
3264 * retry in do_writepages(), and a WA !! 3237 * otherwise -ENOMEM will cause a retry in do_writepages(), and a
3265 * in ext4_da_update_reserve_space() !! 3238 * WARN_ON may be triggered in ext4_da_update_reserve_space() due to
3266 * ee_len causing the i_reserved_data !! 3239 * an incorrect ee_len causing the i_reserved_data_blocks exception.
3267 */ 3240 */
3268 path = ext4_find_extent(inode, ee_blo !! 3241 path = ext4_find_extent(inode, ee_block, ppath,
>> 3242 flags | EXT4_EX_NOFAIL);
3269 if (IS_ERR(path)) { 3243 if (IS_ERR(path)) {
3270 EXT4_ERROR_INODE(inode, "Fail 3244 EXT4_ERROR_INODE(inode, "Failed split extent on %u, err %ld",
3271 split, PTR_E 3245 split, PTR_ERR(path));
3272 return path; !! 3246 return PTR_ERR(path);
3273 } 3247 }
3274 depth = ext_depth(inode); 3248 depth = ext_depth(inode);
3275 ex = path[depth].p_ext; 3249 ex = path[depth].p_ext;
3276 3250
3277 if (EXT4_EXT_MAY_ZEROOUT & split_flag 3251 if (EXT4_EXT_MAY_ZEROOUT & split_flag) {
3278 if (split_flag & (EXT4_EXT_DA 3252 if (split_flag & (EXT4_EXT_DATA_VALID1|EXT4_EXT_DATA_VALID2)) {
3279 if (split_flag & EXT4 3253 if (split_flag & EXT4_EXT_DATA_VALID1) {
3280 err = ext4_ex 3254 err = ext4_ext_zeroout(inode, ex2);
3281 zero_ex.ee_bl 3255 zero_ex.ee_block = ex2->ee_block;
3282 zero_ex.ee_le 3256 zero_ex.ee_len = cpu_to_le16(
3283 3257 ext4_ext_get_actual_len(ex2));
3284 ext4_ext_stor 3258 ext4_ext_store_pblock(&zero_ex,
3285 3259 ext4_ext_pblock(ex2));
3286 } else { 3260 } else {
3287 err = ext4_ex 3261 err = ext4_ext_zeroout(inode, ex);
3288 zero_ex.ee_bl 3262 zero_ex.ee_block = ex->ee_block;
3289 zero_ex.ee_le 3263 zero_ex.ee_len = cpu_to_le16(
3290 3264 ext4_ext_get_actual_len(ex));
3291 ext4_ext_stor 3265 ext4_ext_store_pblock(&zero_ex,
3292 3266 ext4_ext_pblock(ex));
3293 } 3267 }
3294 } else { 3268 } else {
3295 err = ext4_ext_zeroou 3269 err = ext4_ext_zeroout(inode, &orig_ex);
3296 zero_ex.ee_block = or 3270 zero_ex.ee_block = orig_ex.ee_block;
3297 zero_ex.ee_len = cpu_ 3271 zero_ex.ee_len = cpu_to_le16(
3298 3272 ext4_ext_get_actual_len(&orig_ex));
3299 ext4_ext_store_pblock 3273 ext4_ext_store_pblock(&zero_ex,
3300 3274 ext4_ext_pblock(&orig_ex));
3301 } 3275 }
3302 3276
3303 if (!err) { 3277 if (!err) {
3304 /* update the extent 3278 /* update the extent length and mark as initialized */
3305 ex->ee_len = cpu_to_l 3279 ex->ee_len = cpu_to_le16(ee_len);
3306 ext4_ext_try_to_merge 3280 ext4_ext_try_to_merge(handle, inode, path, ex);
3307 err = ext4_ext_dirty( 3281 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3308 if (!err) 3282 if (!err)
3309 /* update ext 3283 /* update extent status tree */
3310 ext4_zeroout_ !! 3284 err = ext4_zeroout_es(inode, &zero_ex);
3311 /* If we failed at th 3285 /* If we failed at this point, we don't know in which
3312 * state the extent t 3286 * state the extent tree exactly is so don't try to fix
3313 * length of the orig 3287 * length of the original extent as it may do even more
3314 * damage. 3288 * damage.
3315 */ 3289 */
3316 goto out; 3290 goto out;
3317 } 3291 }
3318 } 3292 }
3319 3293
3320 fix_extent_len: 3294 fix_extent_len:
3321 ex->ee_len = orig_ex.ee_len; 3295 ex->ee_len = orig_ex.ee_len;
3322 /* 3296 /*
3323 * Ignore ext4_ext_dirty return value 3297 * Ignore ext4_ext_dirty return value since we are already in error path
3324 * and err is a non-zero error code. 3298 * and err is a non-zero error code.
3325 */ 3299 */
3326 ext4_ext_dirty(handle, inode, path + 3300 ext4_ext_dirty(handle, inode, path + path->p_depth);
>> 3301 return err;
3327 out: 3302 out:
3328 if (err) { !! 3303 ext4_ext_show_leaf(inode, *ppath);
3329 ext4_free_ext_path(path); !! 3304 return err;
3330 path = ERR_PTR(err); <<
3331 } <<
3332 ext4_ext_show_leaf(inode, path); <<
3333 return path; <<
3334 } 3305 }
3335 3306
3336 /* 3307 /*
3337 * ext4_split_extent() splits an extent and m 3308 * ext4_split_extent() splits an extent and mark extent which is covered
3338 * by @map as split_flags indicates 3309 * by @map as split_flags indicates
3339 * 3310 *
3340 * It may result in splitting the extent into 3311 * It may result in splitting the extent into multiple extents (up to three)
3341 * There are three possibilities: 3312 * There are three possibilities:
3342 * a> There is no split required 3313 * a> There is no split required
3343 * b> Splits in two extents: Split is happe 3314 * b> Splits in two extents: Split is happening at either end of the extent
3344 * c> Splits in three extents: Somone is sp 3315 * c> Splits in three extents: Somone is splitting in middle of the extent
3345 * 3316 *
3346 */ 3317 */
3347 static struct ext4_ext_path *ext4_split_exten !! 3318 static int ext4_split_extent(handle_t *handle,
3348 !! 3319 struct inode *inode,
3349 !! 3320 struct ext4_ext_path **ppath,
3350 !! 3321 struct ext4_map_blocks *map,
3351 !! 3322 int split_flag,
3352 !! 3323 int flags)
3353 { 3324 {
>> 3325 struct ext4_ext_path *path = *ppath;
3354 ext4_lblk_t ee_block; 3326 ext4_lblk_t ee_block;
3355 struct ext4_extent *ex; 3327 struct ext4_extent *ex;
3356 unsigned int ee_len, depth; 3328 unsigned int ee_len, depth;
>> 3329 int err = 0;
3357 int unwritten; 3330 int unwritten;
3358 int split_flag1, flags1; 3331 int split_flag1, flags1;
>> 3332 int allocated = map->m_len;
3359 3333
3360 depth = ext_depth(inode); 3334 depth = ext_depth(inode);
3361 ex = path[depth].p_ext; 3335 ex = path[depth].p_ext;
3362 ee_block = le32_to_cpu(ex->ee_block); 3336 ee_block = le32_to_cpu(ex->ee_block);
3363 ee_len = ext4_ext_get_actual_len(ex); 3337 ee_len = ext4_ext_get_actual_len(ex);
3364 unwritten = ext4_ext_is_unwritten(ex) 3338 unwritten = ext4_ext_is_unwritten(ex);
3365 3339
3366 if (map->m_lblk + map->m_len < ee_blo 3340 if (map->m_lblk + map->m_len < ee_block + ee_len) {
3367 split_flag1 = split_flag & EX 3341 split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT;
3368 flags1 = flags | EXT4_GET_BLO 3342 flags1 = flags | EXT4_GET_BLOCKS_PRE_IO;
3369 if (unwritten) 3343 if (unwritten)
3370 split_flag1 |= EXT4_E 3344 split_flag1 |= EXT4_EXT_MARK_UNWRIT1 |
3371 EXT4_E 3345 EXT4_EXT_MARK_UNWRIT2;
3372 if (split_flag & EXT4_EXT_DAT 3346 if (split_flag & EXT4_EXT_DATA_VALID2)
3373 split_flag1 |= EXT4_E 3347 split_flag1 |= EXT4_EXT_DATA_VALID1;
3374 path = ext4_split_extent_at(h !! 3348 err = ext4_split_extent_at(handle, inode, ppath,
3375 map->m_lblk + 3349 map->m_lblk + map->m_len, split_flag1, flags1);
3376 if (IS_ERR(path)) !! 3350 if (err)
3377 return path; !! 3351 goto out;
3378 /* !! 3352 } else {
3379 * Update path is required be !! 3353 allocated = ee_len - (map->m_lblk - ee_block);
3380 * may result in split of ori !! 3354 }
3381 */ !! 3355 /*
3382 path = ext4_find_extent(inode !! 3356 * Update path is required because previous ext4_split_extent_at() may
3383 if (IS_ERR(path)) !! 3357 * result in split of original leaf or extent zeroout.
3384 return path; !! 3358 */
3385 depth = ext_depth(inode); !! 3359 path = ext4_find_extent(inode, map->m_lblk, ppath, flags);
3386 ex = path[depth].p_ext; !! 3360 if (IS_ERR(path))
3387 if (!ex) { !! 3361 return PTR_ERR(path);
3388 EXT4_ERROR_INODE(inod !! 3362 depth = ext_depth(inode);
3389 (unsi !! 3363 ex = path[depth].p_ext;
3390 ext4_free_ext_path(pa !! 3364 if (!ex) {
3391 return ERR_PTR(-EFSCO !! 3365 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3392 } !! 3366 (unsigned long) map->m_lblk);
3393 unwritten = ext4_ext_is_unwri !! 3367 return -EFSCORRUPTED;
3394 } 3368 }
>> 3369 unwritten = ext4_ext_is_unwritten(ex);
>> 3370 split_flag1 = 0;
3395 3371
3396 if (map->m_lblk >= ee_block) { 3372 if (map->m_lblk >= ee_block) {
3397 split_flag1 = split_flag & EX 3373 split_flag1 = split_flag & EXT4_EXT_DATA_VALID2;
3398 if (unwritten) { 3374 if (unwritten) {
3399 split_flag1 |= EXT4_E 3375 split_flag1 |= EXT4_EXT_MARK_UNWRIT1;
3400 split_flag1 |= split_ 3376 split_flag1 |= split_flag & (EXT4_EXT_MAY_ZEROOUT |
3401 3377 EXT4_EXT_MARK_UNWRIT2);
3402 } 3378 }
3403 path = ext4_split_extent_at(h !! 3379 err = ext4_split_extent_at(handle, inode, ppath,
3404 map->m_lblk, 3380 map->m_lblk, split_flag1, flags);
3405 if (IS_ERR(path)) !! 3381 if (err)
3406 return path; !! 3382 goto out;
3407 } 3383 }
3408 3384
3409 if (allocated) { !! 3385 ext4_ext_show_leaf(inode, *ppath);
3410 if (map->m_lblk + map->m_len !! 3386 out:
3411 *allocated = ee_len - !! 3387 return err ? err : allocated;
3412 else <<
3413 *allocated = map->m_l <<
3414 } <<
3415 ext4_ext_show_leaf(inode, path); <<
3416 return path; <<
3417 } 3388 }
3418 3389
3419 /* 3390 /*
3420 * This function is called by ext4_ext_map_bl 3391 * This function is called by ext4_ext_map_blocks() if someone tries to write
3421 * to an unwritten extent. It may result in s 3392 * to an unwritten extent. It may result in splitting the unwritten
3422 * extent into multiple extents (up to three 3393 * extent into multiple extents (up to three - one initialized and two
3423 * unwritten). 3394 * unwritten).
3424 * There are three possibilities: 3395 * There are three possibilities:
3425 * a> There is no split required: Entire ex 3396 * a> There is no split required: Entire extent should be initialized
3426 * b> Splits in two extents: Write is happe 3397 * b> Splits in two extents: Write is happening at either end of the extent
3427 * c> Splits in three extents: Somone is wr 3398 * c> Splits in three extents: Somone is writing in middle of the extent
3428 * 3399 *
3429 * Pre-conditions: 3400 * Pre-conditions:
3430 * - The extent pointed to by 'path' is unwr 3401 * - The extent pointed to by 'path' is unwritten.
3431 * - The extent pointed to by 'path' contain 3402 * - The extent pointed to by 'path' contains a superset
3432 * of the logical span [map->m_lblk, map-> 3403 * of the logical span [map->m_lblk, map->m_lblk + map->m_len).
3433 * 3404 *
3434 * Post-conditions on success: 3405 * Post-conditions on success:
3435 * - the returned value is the number of blo 3406 * - the returned value is the number of blocks beyond map->l_lblk
3436 * that are allocated and initialized. 3407 * that are allocated and initialized.
3437 * It is guaranteed to be >= map->m_len. 3408 * It is guaranteed to be >= map->m_len.
3438 */ 3409 */
3439 static struct ext4_ext_path * !! 3410 static int ext4_ext_convert_to_initialized(handle_t *handle,
3440 ext4_ext_convert_to_initialized(handle_t *han !! 3411 struct inode *inode,
3441 struct ext4_map_block !! 3412 struct ext4_map_blocks *map,
3442 int flags, unsigned i !! 3413 struct ext4_ext_path **ppath,
>> 3414 int flags)
3443 { 3415 {
>> 3416 struct ext4_ext_path *path = *ppath;
3444 struct ext4_sb_info *sbi; 3417 struct ext4_sb_info *sbi;
3445 struct ext4_extent_header *eh; 3418 struct ext4_extent_header *eh;
3446 struct ext4_map_blocks split_map; 3419 struct ext4_map_blocks split_map;
3447 struct ext4_extent zero_ex1, zero_ex2 3420 struct ext4_extent zero_ex1, zero_ex2;
3448 struct ext4_extent *ex, *abut_ex; 3421 struct ext4_extent *ex, *abut_ex;
3449 ext4_lblk_t ee_block, eof_block; 3422 ext4_lblk_t ee_block, eof_block;
3450 unsigned int ee_len, depth, map_len = 3423 unsigned int ee_len, depth, map_len = map->m_len;
3451 int err = 0; 3424 int err = 0;
3452 int split_flag = EXT4_EXT_DATA_VALID2 3425 int split_flag = EXT4_EXT_DATA_VALID2;
>> 3426 int allocated = 0;
3453 unsigned int max_zeroout = 0; 3427 unsigned int max_zeroout = 0;
3454 3428
3455 ext_debug(inode, "logical block %llu, 3429 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3456 (unsigned long long)map->m_ 3430 (unsigned long long)map->m_lblk, map_len);
3457 3431
3458 sbi = EXT4_SB(inode->i_sb); 3432 sbi = EXT4_SB(inode->i_sb);
3459 eof_block = (EXT4_I(inode)->i_disksiz 3433 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3460 >> inode->i_sb->s_blo 3434 >> inode->i_sb->s_blocksize_bits;
3461 if (eof_block < map->m_lblk + map_len 3435 if (eof_block < map->m_lblk + map_len)
3462 eof_block = map->m_lblk + map 3436 eof_block = map->m_lblk + map_len;
3463 3437
3464 depth = ext_depth(inode); 3438 depth = ext_depth(inode);
3465 eh = path[depth].p_hdr; 3439 eh = path[depth].p_hdr;
3466 ex = path[depth].p_ext; 3440 ex = path[depth].p_ext;
3467 ee_block = le32_to_cpu(ex->ee_block); 3441 ee_block = le32_to_cpu(ex->ee_block);
3468 ee_len = ext4_ext_get_actual_len(ex); 3442 ee_len = ext4_ext_get_actual_len(ex);
3469 zero_ex1.ee_len = 0; 3443 zero_ex1.ee_len = 0;
3470 zero_ex2.ee_len = 0; 3444 zero_ex2.ee_len = 0;
3471 3445
3472 trace_ext4_ext_convert_to_initialized 3446 trace_ext4_ext_convert_to_initialized_enter(inode, map, ex);
3473 3447
3474 /* Pre-conditions */ 3448 /* Pre-conditions */
3475 BUG_ON(!ext4_ext_is_unwritten(ex)); 3449 BUG_ON(!ext4_ext_is_unwritten(ex));
3476 BUG_ON(!in_range(map->m_lblk, ee_bloc 3450 BUG_ON(!in_range(map->m_lblk, ee_block, ee_len));
3477 3451
3478 /* 3452 /*
3479 * Attempt to transfer newly initiali 3453 * Attempt to transfer newly initialized blocks from the currently
3480 * unwritten extent to its neighbor. 3454 * unwritten extent to its neighbor. This is much cheaper
3481 * than an insertion followed by a me 3455 * than an insertion followed by a merge as those involve costly
3482 * memmove() calls. Transferring to t 3456 * memmove() calls. Transferring to the left is the common case in
3483 * steady state for workloads doing f 3457 * steady state for workloads doing fallocate(FALLOC_FL_KEEP_SIZE)
3484 * followed by append writes. 3458 * followed by append writes.
3485 * 3459 *
3486 * Limitations of the current logic: 3460 * Limitations of the current logic:
3487 * - L1: we do not deal with writes 3461 * - L1: we do not deal with writes covering the whole extent.
3488 * This would require removing the 3462 * This would require removing the extent if the transfer
3489 * is possible. 3463 * is possible.
3490 * - L2: we only attempt to merge wi 3464 * - L2: we only attempt to merge with an extent stored in the
3491 * same extent tree node. 3465 * same extent tree node.
3492 */ 3466 */
3493 *allocated = 0; <<
3494 if ((map->m_lblk == ee_block) && 3467 if ((map->m_lblk == ee_block) &&
3495 /* See if we can merge left * 3468 /* See if we can merge left */
3496 (map_len < ee_len) && 3469 (map_len < ee_len) && /*L1*/
3497 (ex > EXT_FIRST_EXTENT(eh))) 3470 (ex > EXT_FIRST_EXTENT(eh))) { /*L2*/
3498 ext4_lblk_t prev_lblk; 3471 ext4_lblk_t prev_lblk;
3499 ext4_fsblk_t prev_pblk, ee_pb 3472 ext4_fsblk_t prev_pblk, ee_pblk;
3500 unsigned int prev_len; 3473 unsigned int prev_len;
3501 3474
3502 abut_ex = ex - 1; 3475 abut_ex = ex - 1;
3503 prev_lblk = le32_to_cpu(abut_ 3476 prev_lblk = le32_to_cpu(abut_ex->ee_block);
3504 prev_len = ext4_ext_get_actua 3477 prev_len = ext4_ext_get_actual_len(abut_ex);
3505 prev_pblk = ext4_ext_pblock(a 3478 prev_pblk = ext4_ext_pblock(abut_ex);
3506 ee_pblk = ext4_ext_pblock(ex) 3479 ee_pblk = ext4_ext_pblock(ex);
3507 3480
3508 /* 3481 /*
3509 * A transfer of blocks from 3482 * A transfer of blocks from 'ex' to 'abut_ex' is allowed
3510 * upon those conditions: 3483 * upon those conditions:
3511 * - C1: abut_ex is initializ 3484 * - C1: abut_ex is initialized,
3512 * - C2: abut_ex is logically 3485 * - C2: abut_ex is logically abutting ex,
3513 * - C3: abut_ex is physicall 3486 * - C3: abut_ex is physically abutting ex,
3514 * - C4: abut_ex can receive 3487 * - C4: abut_ex can receive the additional blocks without
3515 * overflowing the (initial 3488 * overflowing the (initialized) length limit.
3516 */ 3489 */
3517 if ((!ext4_ext_is_unwritten(a 3490 if ((!ext4_ext_is_unwritten(abut_ex)) && /*C1*/
3518 ((prev_lblk + prev_le 3491 ((prev_lblk + prev_len) == ee_block) && /*C2*/
3519 ((prev_pblk + prev_le 3492 ((prev_pblk + prev_len) == ee_pblk) && /*C3*/
3520 (prev_len < (EXT_INIT 3493 (prev_len < (EXT_INIT_MAX_LEN - map_len))) { /*C4*/
3521 err = ext4_ext_get_ac 3494 err = ext4_ext_get_access(handle, inode, path + depth);
3522 if (err) 3495 if (err)
3523 goto errout; !! 3496 goto out;
3524 3497
3525 trace_ext4_ext_conver 3498 trace_ext4_ext_convert_to_initialized_fastpath(inode,
3526 map, ex, abut 3499 map, ex, abut_ex);
3527 3500
3528 /* Shift the start of 3501 /* Shift the start of ex by 'map_len' blocks */
3529 ex->ee_block = cpu_to 3502 ex->ee_block = cpu_to_le32(ee_block + map_len);
3530 ext4_ext_store_pblock 3503 ext4_ext_store_pblock(ex, ee_pblk + map_len);
3531 ex->ee_len = cpu_to_l 3504 ex->ee_len = cpu_to_le16(ee_len - map_len);
3532 ext4_ext_mark_unwritt 3505 ext4_ext_mark_unwritten(ex); /* Restore the flag */
3533 3506
3534 /* Extend abut_ex by 3507 /* Extend abut_ex by 'map_len' blocks */
3535 abut_ex->ee_len = cpu 3508 abut_ex->ee_len = cpu_to_le16(prev_len + map_len);
3536 3509
3537 /* Result: number of 3510 /* Result: number of initialized blocks past m_lblk */
3538 *allocated = map_len; !! 3511 allocated = map_len;
3539 } 3512 }
3540 } else if (((map->m_lblk + map_len) = 3513 } else if (((map->m_lblk + map_len) == (ee_block + ee_len)) &&
3541 (map_len < ee_len) && 3514 (map_len < ee_len) && /*L1*/
3542 ex < EXT_LAST_EXTENT(eh)) 3515 ex < EXT_LAST_EXTENT(eh)) { /*L2*/
3543 /* See if we can merge right 3516 /* See if we can merge right */
3544 ext4_lblk_t next_lblk; 3517 ext4_lblk_t next_lblk;
3545 ext4_fsblk_t next_pblk, ee_pb 3518 ext4_fsblk_t next_pblk, ee_pblk;
3546 unsigned int next_len; 3519 unsigned int next_len;
3547 3520
3548 abut_ex = ex + 1; 3521 abut_ex = ex + 1;
3549 next_lblk = le32_to_cpu(abut_ 3522 next_lblk = le32_to_cpu(abut_ex->ee_block);
3550 next_len = ext4_ext_get_actua 3523 next_len = ext4_ext_get_actual_len(abut_ex);
3551 next_pblk = ext4_ext_pblock(a 3524 next_pblk = ext4_ext_pblock(abut_ex);
3552 ee_pblk = ext4_ext_pblock(ex) 3525 ee_pblk = ext4_ext_pblock(ex);
3553 3526
3554 /* 3527 /*
3555 * A transfer of blocks from 3528 * A transfer of blocks from 'ex' to 'abut_ex' is allowed
3556 * upon those conditions: 3529 * upon those conditions:
3557 * - C1: abut_ex is initializ 3530 * - C1: abut_ex is initialized,
3558 * - C2: abut_ex is logically 3531 * - C2: abut_ex is logically abutting ex,
3559 * - C3: abut_ex is physicall 3532 * - C3: abut_ex is physically abutting ex,
3560 * - C4: abut_ex can receive 3533 * - C4: abut_ex can receive the additional blocks without
3561 * overflowing the (initial 3534 * overflowing the (initialized) length limit.
3562 */ 3535 */
3563 if ((!ext4_ext_is_unwritten(a 3536 if ((!ext4_ext_is_unwritten(abut_ex)) && /*C1*/
3564 ((map->m_lblk + map_len) 3537 ((map->m_lblk + map_len) == next_lblk) && /*C2*/
3565 ((ee_pblk + ee_len) == ne 3538 ((ee_pblk + ee_len) == next_pblk) && /*C3*/
3566 (next_len < (EXT_INIT_MAX 3539 (next_len < (EXT_INIT_MAX_LEN - map_len))) { /*C4*/
3567 err = ext4_ext_get_ac 3540 err = ext4_ext_get_access(handle, inode, path + depth);
3568 if (err) 3541 if (err)
3569 goto errout; !! 3542 goto out;
3570 3543
3571 trace_ext4_ext_conver 3544 trace_ext4_ext_convert_to_initialized_fastpath(inode,
3572 map, ex, abut 3545 map, ex, abut_ex);
3573 3546
3574 /* Shift the start of 3547 /* Shift the start of abut_ex by 'map_len' blocks */
3575 abut_ex->ee_block = c 3548 abut_ex->ee_block = cpu_to_le32(next_lblk - map_len);
3576 ext4_ext_store_pblock 3549 ext4_ext_store_pblock(abut_ex, next_pblk - map_len);
3577 ex->ee_len = cpu_to_l 3550 ex->ee_len = cpu_to_le16(ee_len - map_len);
3578 ext4_ext_mark_unwritt 3551 ext4_ext_mark_unwritten(ex); /* Restore the flag */
3579 3552
3580 /* Extend abut_ex by 3553 /* Extend abut_ex by 'map_len' blocks */
3581 abut_ex->ee_len = cpu 3554 abut_ex->ee_len = cpu_to_le16(next_len + map_len);
3582 3555
3583 /* Result: number of 3556 /* Result: number of initialized blocks past m_lblk */
3584 *allocated = map_len; !! 3557 allocated = map_len;
3585 } 3558 }
3586 } 3559 }
3587 if (*allocated) { !! 3560 if (allocated) {
3588 /* Mark the block containing 3561 /* Mark the block containing both extents as dirty */
3589 err = ext4_ext_dirty(handle, 3562 err = ext4_ext_dirty(handle, inode, path + depth);
3590 3563
3591 /* Update path to point to th 3564 /* Update path to point to the right extent */
3592 path[depth].p_ext = abut_ex; 3565 path[depth].p_ext = abut_ex;
3593 if (err) <<
3594 goto errout; <<
3595 goto out; 3566 goto out;
3596 } else 3567 } else
3597 *allocated = ee_len - (map->m !! 3568 allocated = ee_len - (map->m_lblk - ee_block);
3598 3569
3599 WARN_ON(map->m_lblk < ee_block); 3570 WARN_ON(map->m_lblk < ee_block);
3600 /* 3571 /*
3601 * It is safe to convert extent to in 3572 * It is safe to convert extent to initialized via explicit
3602 * zeroout only if extent is fully in 3573 * zeroout only if extent is fully inside i_size or new_size.
3603 */ 3574 */
3604 split_flag |= ee_block + ee_len <= eo 3575 split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0;
3605 3576
3606 if (EXT4_EXT_MAY_ZEROOUT & split_flag 3577 if (EXT4_EXT_MAY_ZEROOUT & split_flag)
3607 max_zeroout = sbi->s_extent_m 3578 max_zeroout = sbi->s_extent_max_zeroout_kb >>
3608 (inode->i_sb->s_block 3579 (inode->i_sb->s_blocksize_bits - 10);
3609 3580
3610 /* 3581 /*
3611 * five cases: 3582 * five cases:
3612 * 1. split the extent into three ext 3583 * 1. split the extent into three extents.
3613 * 2. split the extent into two exten 3584 * 2. split the extent into two extents, zeroout the head of the first
3614 * extent. 3585 * extent.
3615 * 3. split the extent into two exten 3586 * 3. split the extent into two extents, zeroout the tail of the second
3616 * extent. 3587 * extent.
3617 * 4. split the extent into two exten 3588 * 4. split the extent into two extents with out zeroout.
3618 * 5. no splitting needed, just possi 3589 * 5. no splitting needed, just possibly zeroout the head and / or the
3619 * tail of the extent. 3590 * tail of the extent.
3620 */ 3591 */
3621 split_map.m_lblk = map->m_lblk; 3592 split_map.m_lblk = map->m_lblk;
3622 split_map.m_len = map->m_len; 3593 split_map.m_len = map->m_len;
3623 3594
3624 if (max_zeroout && (*allocated > spli !! 3595 if (max_zeroout && (allocated > split_map.m_len)) {
3625 if (*allocated <= max_zeroout !! 3596 if (allocated <= max_zeroout) {
3626 /* case 3 or 5 */ 3597 /* case 3 or 5 */
3627 zero_ex1.ee_block = 3598 zero_ex1.ee_block =
3628 cpu_to_le32( 3599 cpu_to_le32(split_map.m_lblk +
3629 3600 split_map.m_len);
3630 zero_ex1.ee_len = 3601 zero_ex1.ee_len =
3631 cpu_to_le16(* !! 3602 cpu_to_le16(allocated - split_map.m_len);
3632 ext4_ext_store_pblock 3603 ext4_ext_store_pblock(&zero_ex1,
3633 ext4_ext_pblo 3604 ext4_ext_pblock(ex) + split_map.m_lblk +
3634 split_map.m_l 3605 split_map.m_len - ee_block);
3635 err = ext4_ext_zeroou 3606 err = ext4_ext_zeroout(inode, &zero_ex1);
3636 if (err) 3607 if (err)
3637 goto fallback !! 3608 goto out;
3638 split_map.m_len = *al !! 3609 split_map.m_len = allocated;
3639 } 3610 }
3640 if (split_map.m_lblk - ee_blo 3611 if (split_map.m_lblk - ee_block + split_map.m_len <
3641 3612 max_zeroout) {
3642 /* case 2 or 5 */ 3613 /* case 2 or 5 */
3643 if (split_map.m_lblk 3614 if (split_map.m_lblk != ee_block) {
3644 zero_ex2.ee_b 3615 zero_ex2.ee_block = ex->ee_block;
3645 zero_ex2.ee_l 3616 zero_ex2.ee_len = cpu_to_le16(split_map.m_lblk -
3646 3617 ee_block);
3647 ext4_ext_stor 3618 ext4_ext_store_pblock(&zero_ex2,
3648 3619 ext4_ext_pblock(ex));
3649 err = ext4_ex 3620 err = ext4_ext_zeroout(inode, &zero_ex2);
3650 if (err) 3621 if (err)
3651 goto !! 3622 goto out;
3652 } 3623 }
3653 3624
3654 split_map.m_len += sp 3625 split_map.m_len += split_map.m_lblk - ee_block;
3655 split_map.m_lblk = ee 3626 split_map.m_lblk = ee_block;
3656 *allocated = map->m_l !! 3627 allocated = map->m_len;
3657 } 3628 }
3658 } 3629 }
3659 3630
3660 fallback: !! 3631 err = ext4_split_extent(handle, inode, ppath, &split_map, split_flag,
3661 path = ext4_split_extent(handle, inod !! 3632 flags);
3662 flags, NULL) !! 3633 if (err > 0)
3663 if (IS_ERR(path)) !! 3634 err = 0;
3664 return path; <<
3665 out: 3635 out:
3666 /* If we have gotten a failure, don't 3636 /* If we have gotten a failure, don't zero out status tree */
3667 ext4_zeroout_es(inode, &zero_ex1); !! 3637 if (!err) {
3668 ext4_zeroout_es(inode, &zero_ex2); !! 3638 err = ext4_zeroout_es(inode, &zero_ex1);
3669 return path; !! 3639 if (!err)
3670 !! 3640 err = ext4_zeroout_es(inode, &zero_ex2);
3671 errout: !! 3641 }
3672 ext4_free_ext_path(path); !! 3642 return err ? err : allocated;
3673 return ERR_PTR(err); <<
3674 } 3643 }
3675 3644
3676 /* 3645 /*
3677 * This function is called by ext4_ext_map_bl 3646 * This function is called by ext4_ext_map_blocks() from
3678 * ext4_get_blocks_dio_write() when DIO to wr 3647 * ext4_get_blocks_dio_write() when DIO to write
3679 * to an unwritten extent. 3648 * to an unwritten extent.
3680 * 3649 *
3681 * Writing to an unwritten extent may result 3650 * Writing to an unwritten extent may result in splitting the unwritten
3682 * extent into multiple initialized/unwritten 3651 * extent into multiple initialized/unwritten extents (up to three)
3683 * There are three possibilities: 3652 * There are three possibilities:
3684 * a> There is no split required: Entire ex 3653 * a> There is no split required: Entire extent should be unwritten
3685 * b> Splits in two extents: Write is happe 3654 * b> Splits in two extents: Write is happening at either end of the extent
3686 * c> Splits in three extents: Somone is wr 3655 * c> Splits in three extents: Somone is writing in middle of the extent
3687 * 3656 *
3688 * This works the same way in the case of ini 3657 * This works the same way in the case of initialized -> unwritten conversion.
3689 * 3658 *
3690 * One of more index blocks maybe needed if t 3659 * One of more index blocks maybe needed if the extent tree grow after
3691 * the unwritten extent split. To prevent ENO 3660 * the unwritten extent split. To prevent ENOSPC occur at the IO
3692 * complete, we need to split the unwritten e 3661 * complete, we need to split the unwritten extent before DIO submit
3693 * the IO. The unwritten extent called at thi 3662 * the IO. The unwritten extent called at this time will be split
3694 * into three unwritten extent(at most). Afte 3663 * into three unwritten extent(at most). After IO complete, the part
3695 * being filled will be convert to initialize 3664 * being filled will be convert to initialized by the end_io callback function
3696 * via ext4_convert_unwritten_extents(). 3665 * via ext4_convert_unwritten_extents().
3697 * 3666 *
3698 * The size of unwritten extent to be written !! 3667 * Returns the size of unwritten extent to be written on success.
3699 * allocated pointer. Return an extent path p <<
3700 * pointer on failure. <<
3701 */ 3668 */
3702 static struct ext4_ext_path *ext4_split_conve !! 3669 static int ext4_split_convert_extents(handle_t *handle,
3703 struc 3670 struct inode *inode,
3704 struc 3671 struct ext4_map_blocks *map,
3705 struc !! 3672 struct ext4_ext_path **ppath,
3706 int f !! 3673 int flags)
3707 { 3674 {
>> 3675 struct ext4_ext_path *path = *ppath;
3708 ext4_lblk_t eof_block; 3676 ext4_lblk_t eof_block;
3709 ext4_lblk_t ee_block; 3677 ext4_lblk_t ee_block;
3710 struct ext4_extent *ex; 3678 struct ext4_extent *ex;
3711 unsigned int ee_len; 3679 unsigned int ee_len;
3712 int split_flag = 0, depth; 3680 int split_flag = 0, depth;
3713 3681
3714 ext_debug(inode, "logical block %llu, 3682 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3715 (unsigned long long)map->m_ 3683 (unsigned long long)map->m_lblk, map->m_len);
3716 3684
3717 eof_block = (EXT4_I(inode)->i_disksiz 3685 eof_block = (EXT4_I(inode)->i_disksize + inode->i_sb->s_blocksize - 1)
3718 >> inode->i_sb->s_blo 3686 >> inode->i_sb->s_blocksize_bits;
3719 if (eof_block < map->m_lblk + map->m_ 3687 if (eof_block < map->m_lblk + map->m_len)
3720 eof_block = map->m_lblk + map 3688 eof_block = map->m_lblk + map->m_len;
3721 /* 3689 /*
3722 * It is safe to convert extent to in 3690 * It is safe to convert extent to initialized via explicit
3723 * zeroout only if extent is fully in 3691 * zeroout only if extent is fully inside i_size or new_size.
3724 */ 3692 */
3725 depth = ext_depth(inode); 3693 depth = ext_depth(inode);
3726 ex = path[depth].p_ext; 3694 ex = path[depth].p_ext;
3727 ee_block = le32_to_cpu(ex->ee_block); 3695 ee_block = le32_to_cpu(ex->ee_block);
3728 ee_len = ext4_ext_get_actual_len(ex); 3696 ee_len = ext4_ext_get_actual_len(ex);
3729 3697
3730 /* Convert to unwritten */ 3698 /* Convert to unwritten */
3731 if (flags & EXT4_GET_BLOCKS_CONVERT_U 3699 if (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN) {
3732 split_flag |= EXT4_EXT_DATA_V 3700 split_flag |= EXT4_EXT_DATA_VALID1;
3733 /* Convert to initialized */ 3701 /* Convert to initialized */
3734 } else if (flags & EXT4_GET_BLOCKS_CO 3702 } else if (flags & EXT4_GET_BLOCKS_CONVERT) {
3735 split_flag |= ee_block + ee_l 3703 split_flag |= ee_block + ee_len <= eof_block ?
3736 EXT4_EXT_MAY_ZE 3704 EXT4_EXT_MAY_ZEROOUT : 0;
3737 split_flag |= (EXT4_EXT_MARK_ 3705 split_flag |= (EXT4_EXT_MARK_UNWRIT2 | EXT4_EXT_DATA_VALID2);
3738 } 3706 }
3739 flags |= EXT4_GET_BLOCKS_PRE_IO; 3707 flags |= EXT4_GET_BLOCKS_PRE_IO;
3740 return ext4_split_extent(handle, inod !! 3708 return ext4_split_extent(handle, inode, ppath, map, split_flag, flags);
3741 allocated); <<
3742 } 3709 }
3743 3710
3744 static struct ext4_ext_path * !! 3711 static int ext4_convert_unwritten_extents_endio(handle_t *handle,
3745 ext4_convert_unwritten_extents_endio(handle_t !! 3712 struct inode *inode,
3746 struct e !! 3713 struct ext4_map_blocks *map,
3747 struct e !! 3714 struct ext4_ext_path **ppath)
3748 { 3715 {
>> 3716 struct ext4_ext_path *path = *ppath;
3749 struct ext4_extent *ex; 3717 struct ext4_extent *ex;
3750 ext4_lblk_t ee_block; 3718 ext4_lblk_t ee_block;
3751 unsigned int ee_len; 3719 unsigned int ee_len;
3752 int depth; 3720 int depth;
3753 int err = 0; 3721 int err = 0;
3754 3722
3755 depth = ext_depth(inode); 3723 depth = ext_depth(inode);
3756 ex = path[depth].p_ext; 3724 ex = path[depth].p_ext;
3757 ee_block = le32_to_cpu(ex->ee_block); 3725 ee_block = le32_to_cpu(ex->ee_block);
3758 ee_len = ext4_ext_get_actual_len(ex); 3726 ee_len = ext4_ext_get_actual_len(ex);
3759 3727
3760 ext_debug(inode, "logical block %llu, 3728 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3761 (unsigned long long)ee_bloc 3729 (unsigned long long)ee_block, ee_len);
3762 3730
3763 /* If extent is larger than requested 3731 /* If extent is larger than requested it is a clear sign that we still
3764 * have some extent state machine iss 3732 * have some extent state machine issues left. So extent_split is still
3765 * required. 3733 * required.
3766 * TODO: Once all related issues will 3734 * TODO: Once all related issues will be fixed this situation should be
3767 * illegal. 3735 * illegal.
3768 */ 3736 */
3769 if (ee_block != map->m_lblk || ee_len 3737 if (ee_block != map->m_lblk || ee_len > map->m_len) {
3770 #ifdef CONFIG_EXT4_DEBUG 3738 #ifdef CONFIG_EXT4_DEBUG
3771 ext4_warning(inode->i_sb, "In 3739 ext4_warning(inode->i_sb, "Inode (%ld) finished: extent logical block %llu,"
3772 " len %u; IO log 3740 " len %u; IO logical block %llu, len %u",
3773 inode->i_ino, (u 3741 inode->i_ino, (unsigned long long)ee_block, ee_len,
3774 (unsigned long l 3742 (unsigned long long)map->m_lblk, map->m_len);
3775 #endif 3743 #endif
3776 path = ext4_split_convert_ext !! 3744 err = ext4_split_convert_extents(handle, inode, map, ppath,
3777 !! 3745 EXT4_GET_BLOCKS_CONVERT);
3778 if (IS_ERR(path)) !! 3746 if (err < 0)
3779 return path; !! 3747 return err;
3780 !! 3748 path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3781 path = ext4_find_extent(inode <<
3782 if (IS_ERR(path)) 3749 if (IS_ERR(path))
3783 return path; !! 3750 return PTR_ERR(path);
3784 depth = ext_depth(inode); 3751 depth = ext_depth(inode);
3785 ex = path[depth].p_ext; 3752 ex = path[depth].p_ext;
3786 } 3753 }
3787 3754
3788 err = ext4_ext_get_access(handle, ino 3755 err = ext4_ext_get_access(handle, inode, path + depth);
3789 if (err) 3756 if (err)
3790 goto errout; !! 3757 goto out;
3791 /* first mark the extent as initializ 3758 /* first mark the extent as initialized */
3792 ext4_ext_mark_initialized(ex); 3759 ext4_ext_mark_initialized(ex);
3793 3760
3794 /* note: ext4_ext_correct_indexes() i 3761 /* note: ext4_ext_correct_indexes() isn't needed here because
3795 * borders are not changed 3762 * borders are not changed
3796 */ 3763 */
3797 ext4_ext_try_to_merge(handle, inode, 3764 ext4_ext_try_to_merge(handle, inode, path, ex);
3798 3765
3799 /* Mark modified extent as dirty */ 3766 /* Mark modified extent as dirty */
3800 err = ext4_ext_dirty(handle, inode, p 3767 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3801 if (err) !! 3768 out:
3802 goto errout; <<
3803 <<
3804 ext4_ext_show_leaf(inode, path); 3769 ext4_ext_show_leaf(inode, path);
3805 return path; !! 3770 return err;
3806 <<
3807 errout: <<
3808 ext4_free_ext_path(path); <<
3809 return ERR_PTR(err); <<
3810 } 3771 }
3811 3772
3812 static struct ext4_ext_path * !! 3773 static int
3813 convert_initialized_extent(handle_t *handle, 3774 convert_initialized_extent(handle_t *handle, struct inode *inode,
3814 struct ext4_map_bl 3775 struct ext4_map_blocks *map,
3815 struct ext4_ext_pa !! 3776 struct ext4_ext_path **ppath,
3816 unsigned int *allo 3777 unsigned int *allocated)
3817 { 3778 {
>> 3779 struct ext4_ext_path *path = *ppath;
3818 struct ext4_extent *ex; 3780 struct ext4_extent *ex;
3819 ext4_lblk_t ee_block; 3781 ext4_lblk_t ee_block;
3820 unsigned int ee_len; 3782 unsigned int ee_len;
3821 int depth; 3783 int depth;
3822 int err = 0; 3784 int err = 0;
3823 3785
3824 /* 3786 /*
3825 * Make sure that the extent is no bi 3787 * Make sure that the extent is no bigger than we support with
3826 * unwritten extent 3788 * unwritten extent
3827 */ 3789 */
3828 if (map->m_len > EXT_UNWRITTEN_MAX_LE 3790 if (map->m_len > EXT_UNWRITTEN_MAX_LEN)
3829 map->m_len = EXT_UNWRITTEN_MA 3791 map->m_len = EXT_UNWRITTEN_MAX_LEN / 2;
3830 3792
3831 depth = ext_depth(inode); 3793 depth = ext_depth(inode);
3832 ex = path[depth].p_ext; 3794 ex = path[depth].p_ext;
3833 ee_block = le32_to_cpu(ex->ee_block); 3795 ee_block = le32_to_cpu(ex->ee_block);
3834 ee_len = ext4_ext_get_actual_len(ex); 3796 ee_len = ext4_ext_get_actual_len(ex);
3835 3797
3836 ext_debug(inode, "logical block %llu, 3798 ext_debug(inode, "logical block %llu, max_blocks %u\n",
3837 (unsigned long long)ee_bloc 3799 (unsigned long long)ee_block, ee_len);
3838 3800
3839 if (ee_block != map->m_lblk || ee_len 3801 if (ee_block != map->m_lblk || ee_len > map->m_len) {
3840 path = ext4_split_convert_ext !! 3802 err = ext4_split_convert_extents(handle, inode, map, ppath,
3841 EXT4_GET_BLOC !! 3803 EXT4_GET_BLOCKS_CONVERT_UNWRITTEN);
3842 if (IS_ERR(path)) !! 3804 if (err < 0)
3843 return path; !! 3805 return err;
3844 !! 3806 path = ext4_find_extent(inode, map->m_lblk, ppath, 0);
3845 path = ext4_find_extent(inode <<
3846 if (IS_ERR(path)) 3807 if (IS_ERR(path))
3847 return path; !! 3808 return PTR_ERR(path);
3848 depth = ext_depth(inode); 3809 depth = ext_depth(inode);
3849 ex = path[depth].p_ext; 3810 ex = path[depth].p_ext;
3850 if (!ex) { 3811 if (!ex) {
3851 EXT4_ERROR_INODE(inod 3812 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3852 (uns 3813 (unsigned long) map->m_lblk);
3853 err = -EFSCORRUPTED; !! 3814 return -EFSCORRUPTED;
3854 goto errout; <<
3855 } 3815 }
3856 } 3816 }
3857 3817
3858 err = ext4_ext_get_access(handle, ino 3818 err = ext4_ext_get_access(handle, inode, path + depth);
3859 if (err) 3819 if (err)
3860 goto errout; !! 3820 return err;
3861 /* first mark the extent as unwritten 3821 /* first mark the extent as unwritten */
3862 ext4_ext_mark_unwritten(ex); 3822 ext4_ext_mark_unwritten(ex);
3863 3823
3864 /* note: ext4_ext_correct_indexes() i 3824 /* note: ext4_ext_correct_indexes() isn't needed here because
3865 * borders are not changed 3825 * borders are not changed
3866 */ 3826 */
3867 ext4_ext_try_to_merge(handle, inode, 3827 ext4_ext_try_to_merge(handle, inode, path, ex);
3868 3828
3869 /* Mark modified extent as dirty */ 3829 /* Mark modified extent as dirty */
3870 err = ext4_ext_dirty(handle, inode, p 3830 err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3871 if (err) 3831 if (err)
3872 goto errout; !! 3832 return err;
3873 ext4_ext_show_leaf(inode, path); 3833 ext4_ext_show_leaf(inode, path);
3874 3834
3875 ext4_update_inode_fsync_trans(handle, 3835 ext4_update_inode_fsync_trans(handle, inode, 1);
3876 3836
3877 map->m_flags |= EXT4_MAP_UNWRITTEN; 3837 map->m_flags |= EXT4_MAP_UNWRITTEN;
3878 if (*allocated > map->m_len) 3838 if (*allocated > map->m_len)
3879 *allocated = map->m_len; 3839 *allocated = map->m_len;
3880 map->m_len = *allocated; 3840 map->m_len = *allocated;
3881 return path; !! 3841 return 0;
3882 <<
3883 errout: <<
3884 ext4_free_ext_path(path); <<
3885 return ERR_PTR(err); <<
3886 } 3842 }
3887 3843
3888 static struct ext4_ext_path * !! 3844 static int
3889 ext4_ext_handle_unwritten_extents(handle_t *h 3845 ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode,
3890 struct ext4_map_block 3846 struct ext4_map_blocks *map,
3891 struct ext4_ext_path !! 3847 struct ext4_ext_path **ppath, int flags,
3892 unsigned int *allocat !! 3848 unsigned int allocated, ext4_fsblk_t newblock)
3893 { 3849 {
>> 3850 int ret = 0;
3894 int err = 0; 3851 int err = 0;
3895 3852
3896 ext_debug(inode, "logical block %llu, 3853 ext_debug(inode, "logical block %llu, max_blocks %u, flags 0x%x, allocated %u\n",
3897 (unsigned long long)map->m_ 3854 (unsigned long long)map->m_lblk, map->m_len, flags,
3898 *allocated); !! 3855 allocated);
3899 ext4_ext_show_leaf(inode, path); !! 3856 ext4_ext_show_leaf(inode, *ppath);
3900 3857
3901 /* 3858 /*
3902 * When writing into unwritten space, 3859 * When writing into unwritten space, we should not fail to
3903 * allocate metadata blocks for the n 3860 * allocate metadata blocks for the new extent block if needed.
3904 */ 3861 */
3905 flags |= EXT4_GET_BLOCKS_METADATA_NOF 3862 flags |= EXT4_GET_BLOCKS_METADATA_NOFAIL;
3906 3863
3907 trace_ext4_ext_handle_unwritten_exten 3864 trace_ext4_ext_handle_unwritten_extents(inode, map, flags,
3908 !! 3865 allocated, newblock);
3909 3866
3910 /* get_block() before submitting IO, 3867 /* get_block() before submitting IO, split the extent */
3911 if (flags & EXT4_GET_BLOCKS_PRE_IO) { 3868 if (flags & EXT4_GET_BLOCKS_PRE_IO) {
3912 path = ext4_split_convert_ext !! 3869 ret = ext4_split_convert_extents(handle, inode, map, ppath,
3913 flags | EXT4_ !! 3870 flags | EXT4_GET_BLOCKS_CONVERT);
3914 if (IS_ERR(path)) !! 3871 if (ret < 0) {
3915 return path; !! 3872 err = ret;
>> 3873 goto out2;
>> 3874 }
3916 /* 3875 /*
3917 * shouldn't get a 0 allocate !! 3876 * shouldn't get a 0 return when splitting an extent unless
3918 * m_len is 0 (bug) or extent 3877 * m_len is 0 (bug) or extent has been corrupted
3919 */ 3878 */
3920 if (unlikely(*allocated == 0) !! 3879 if (unlikely(ret == 0)) {
3921 EXT4_ERROR_INODE(inod 3880 EXT4_ERROR_INODE(inode,
3922 "une !! 3881 "unexpected ret == 0, m_len = %u",
3923 map- 3882 map->m_len);
3924 err = -EFSCORRUPTED; 3883 err = -EFSCORRUPTED;
3925 goto errout; !! 3884 goto out2;
3926 } 3885 }
3927 map->m_flags |= EXT4_MAP_UNWR 3886 map->m_flags |= EXT4_MAP_UNWRITTEN;
3928 goto out; 3887 goto out;
3929 } 3888 }
3930 /* IO end_io complete, convert the fi 3889 /* IO end_io complete, convert the filled extent to written */
3931 if (flags & EXT4_GET_BLOCKS_CONVERT) 3890 if (flags & EXT4_GET_BLOCKS_CONVERT) {
3932 path = ext4_convert_unwritten !! 3891 err = ext4_convert_unwritten_extents_endio(handle, inode, map,
3933 !! 3892 ppath);
3934 if (IS_ERR(path)) !! 3893 if (err < 0)
3935 return path; !! 3894 goto out2;
3936 ext4_update_inode_fsync_trans 3895 ext4_update_inode_fsync_trans(handle, inode, 1);
3937 goto map_out; 3896 goto map_out;
3938 } 3897 }
3939 /* buffered IO cases */ 3898 /* buffered IO cases */
3940 /* 3899 /*
3941 * repeat fallocate creation request 3900 * repeat fallocate creation request
3942 * we already have an unwritten exten 3901 * we already have an unwritten extent
3943 */ 3902 */
3944 if (flags & EXT4_GET_BLOCKS_UNWRIT_EX 3903 if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT) {
3945 map->m_flags |= EXT4_MAP_UNWR 3904 map->m_flags |= EXT4_MAP_UNWRITTEN;
3946 goto map_out; 3905 goto map_out;
3947 } 3906 }
3948 3907
3949 /* buffered READ or buffered write_be 3908 /* buffered READ or buffered write_begin() lookup */
3950 if ((flags & EXT4_GET_BLOCKS_CREATE) 3909 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
3951 /* 3910 /*
3952 * We have blocks reserved al 3911 * We have blocks reserved already. We
3953 * return allocated blocks so 3912 * return allocated blocks so that delalloc
3954 * won't do block reservation 3913 * won't do block reservation for us. But
3955 * the buffer head will be un 3914 * the buffer head will be unmapped so that
3956 * a read from the block retu 3915 * a read from the block returns 0s.
3957 */ 3916 */
3958 map->m_flags |= EXT4_MAP_UNWR 3917 map->m_flags |= EXT4_MAP_UNWRITTEN;
3959 goto out1; 3918 goto out1;
3960 } 3919 }
3961 3920
3962 /* 3921 /*
3963 * Default case when (flags & EXT4_GE 3922 * Default case when (flags & EXT4_GET_BLOCKS_CREATE) == 1.
3964 * For buffered writes, at writepage 3923 * For buffered writes, at writepage time, etc. Convert a
3965 * discovered unwritten extent to wri 3924 * discovered unwritten extent to written.
3966 */ 3925 */
3967 path = ext4_ext_convert_to_initialize !! 3926 ret = ext4_ext_convert_to_initialized(handle, inode, map, ppath, flags);
3968 !! 3927 if (ret < 0) {
3969 if (IS_ERR(path)) !! 3928 err = ret;
3970 return path; !! 3929 goto out2;
>> 3930 }
3971 ext4_update_inode_fsync_trans(handle, 3931 ext4_update_inode_fsync_trans(handle, inode, 1);
3972 /* 3932 /*
3973 * shouldn't get a 0 allocated when c !! 3933 * shouldn't get a 0 return when converting an unwritten extent
3974 * unless m_len is 0 (bug) or extent 3934 * unless m_len is 0 (bug) or extent has been corrupted
3975 */ 3935 */
3976 if (unlikely(*allocated == 0)) { !! 3936 if (unlikely(ret == 0)) {
3977 EXT4_ERROR_INODE(inode, "unex !! 3937 EXT4_ERROR_INODE(inode, "unexpected ret == 0, m_len = %u",
3978 map->m_len); 3938 map->m_len);
3979 err = -EFSCORRUPTED; 3939 err = -EFSCORRUPTED;
3980 goto errout; !! 3940 goto out2;
3981 } 3941 }
3982 3942
3983 out: 3943 out:
>> 3944 allocated = ret;
3984 map->m_flags |= EXT4_MAP_NEW; 3945 map->m_flags |= EXT4_MAP_NEW;
3985 map_out: 3946 map_out:
3986 map->m_flags |= EXT4_MAP_MAPPED; 3947 map->m_flags |= EXT4_MAP_MAPPED;
3987 out1: 3948 out1:
3988 map->m_pblk = newblock; 3949 map->m_pblk = newblock;
3989 if (*allocated > map->m_len) !! 3950 if (allocated > map->m_len)
3990 *allocated = map->m_len; !! 3951 allocated = map->m_len;
3991 map->m_len = *allocated; !! 3952 map->m_len = allocated;
3992 ext4_ext_show_leaf(inode, path); !! 3953 ext4_ext_show_leaf(inode, *ppath);
3993 return path; !! 3954 out2:
3994 !! 3955 return err ? err : allocated;
3995 errout: <<
3996 ext4_free_ext_path(path); <<
3997 return ERR_PTR(err); <<
3998 } 3956 }
3999 3957
4000 /* 3958 /*
4001 * get_implied_cluster_alloc - check to see i 3959 * get_implied_cluster_alloc - check to see if the requested
4002 * allocation (in the map structure) overlaps 3960 * allocation (in the map structure) overlaps with a cluster already
4003 * allocated in an extent. 3961 * allocated in an extent.
4004 * @sb The filesystem superblock str 3962 * @sb The filesystem superblock structure
4005 * @map The requested lblk->pblk mapp 3963 * @map The requested lblk->pblk mapping
4006 * @ex The extent structure which mi 3964 * @ex The extent structure which might contain an implied
4007 * cluster allocation 3965 * cluster allocation
4008 * 3966 *
4009 * This function is called by ext4_ext_map_bl 3967 * This function is called by ext4_ext_map_blocks() after we failed to
4010 * find blocks that were already in the inode 3968 * find blocks that were already in the inode's extent tree. Hence,
4011 * we know that the beginning of the requeste 3969 * we know that the beginning of the requested region cannot overlap
4012 * the extent from the inode's extent tree. 3970 * the extent from the inode's extent tree. There are three cases we
4013 * want to catch. The first is this case: 3971 * want to catch. The first is this case:
4014 * 3972 *
4015 * |--- cluster # N--| 3973 * |--- cluster # N--|
4016 * |--- extent ---| |---- requested regio 3974 * |--- extent ---| |---- requested region ---|
4017 * |==========| 3975 * |==========|
4018 * 3976 *
4019 * The second case that we need to test for i 3977 * The second case that we need to test for is this one:
4020 * 3978 *
4021 * |--------- cluster # N ----------------| 3979 * |--------- cluster # N ----------------|
4022 * |--- requested region --| |----- 3980 * |--- requested region --| |------- extent ----|
4023 * |=======================| 3981 * |=======================|
4024 * 3982 *
4025 * The third case is when the requested regio 3983 * The third case is when the requested region lies between two extents
4026 * within the same cluster: 3984 * within the same cluster:
4027 * |------------- cluster # N------- 3985 * |------------- cluster # N-------------|
4028 * |----- ex -----| |---- ex 3986 * |----- ex -----| |---- ex_right ----|
4029 * |------ requested region 3987 * |------ requested region ------|
4030 * |================| 3988 * |================|
4031 * 3989 *
4032 * In each of the above cases, we need to set 3990 * In each of the above cases, we need to set the map->m_pblk and
4033 * map->m_len so it corresponds to the return 3991 * map->m_len so it corresponds to the return the extent labelled as
4034 * "|====|" from cluster #N, since it is alre 3992 * "|====|" from cluster #N, since it is already in use for data in
4035 * cluster EXT4_B2C(sbi, map->m_lblk). We wi 3993 * cluster EXT4_B2C(sbi, map->m_lblk). We will then return 1 to
4036 * signal to ext4_ext_map_blocks() that map-> 3994 * signal to ext4_ext_map_blocks() that map->m_pblk should be treated
4037 * as a new "allocated" block region. Otherw 3995 * as a new "allocated" block region. Otherwise, we will return 0 and
4038 * ext4_ext_map_blocks() will then allocate o 3996 * ext4_ext_map_blocks() will then allocate one or more new clusters
4039 * by calling ext4_mb_new_blocks(). 3997 * by calling ext4_mb_new_blocks().
4040 */ 3998 */
4041 static int get_implied_cluster_alloc(struct s 3999 static int get_implied_cluster_alloc(struct super_block *sb,
4042 struct e 4000 struct ext4_map_blocks *map,
4043 struct e 4001 struct ext4_extent *ex,
4044 struct e 4002 struct ext4_ext_path *path)
4045 { 4003 {
4046 struct ext4_sb_info *sbi = EXT4_SB(sb 4004 struct ext4_sb_info *sbi = EXT4_SB(sb);
4047 ext4_lblk_t c_offset = EXT4_LBLK_COFF 4005 ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
4048 ext4_lblk_t ex_cluster_start, ex_clus 4006 ext4_lblk_t ex_cluster_start, ex_cluster_end;
4049 ext4_lblk_t rr_cluster_start; 4007 ext4_lblk_t rr_cluster_start;
4050 ext4_lblk_t ee_block = le32_to_cpu(ex 4008 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
4051 ext4_fsblk_t ee_start = ext4_ext_pblo 4009 ext4_fsblk_t ee_start = ext4_ext_pblock(ex);
4052 unsigned short ee_len = ext4_ext_get_ 4010 unsigned short ee_len = ext4_ext_get_actual_len(ex);
4053 4011
4054 /* The extent passed in that we are t 4012 /* The extent passed in that we are trying to match */
4055 ex_cluster_start = EXT4_B2C(sbi, ee_b 4013 ex_cluster_start = EXT4_B2C(sbi, ee_block);
4056 ex_cluster_end = EXT4_B2C(sbi, ee_blo 4014 ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1);
4057 4015
4058 /* The requested region passed into e 4016 /* The requested region passed into ext4_map_blocks() */
4059 rr_cluster_start = EXT4_B2C(sbi, map- 4017 rr_cluster_start = EXT4_B2C(sbi, map->m_lblk);
4060 4018
4061 if ((rr_cluster_start == ex_cluster_e 4019 if ((rr_cluster_start == ex_cluster_end) ||
4062 (rr_cluster_start == ex_cluster_s 4020 (rr_cluster_start == ex_cluster_start)) {
4063 if (rr_cluster_start == ex_cl 4021 if (rr_cluster_start == ex_cluster_end)
4064 ee_start += ee_len - 4022 ee_start += ee_len - 1;
4065 map->m_pblk = EXT4_PBLK_CMASK 4023 map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset;
4066 map->m_len = min(map->m_len, 4024 map->m_len = min(map->m_len,
4067 (unsigned) s 4025 (unsigned) sbi->s_cluster_ratio - c_offset);
4068 /* 4026 /*
4069 * Check for and handle this 4027 * Check for and handle this case:
4070 * 4028 *
4071 * |--------- cluster # N-- 4029 * |--------- cluster # N-------------|
4072 * |----- 4030 * |------- extent ----|
4073 * |--- requested reg 4031 * |--- requested region ---|
4074 * |===========| 4032 * |===========|
4075 */ 4033 */
4076 4034
4077 if (map->m_lblk < ee_block) 4035 if (map->m_lblk < ee_block)
4078 map->m_len = min(map- 4036 map->m_len = min(map->m_len, ee_block - map->m_lblk);
4079 4037
4080 /* 4038 /*
4081 * Check for the case where t 4039 * Check for the case where there is already another allocated
4082 * block to the right of 'ex' 4040 * block to the right of 'ex' but before the end of the cluster.
4083 * 4041 *
4084 * |------------- cl 4042 * |------------- cluster # N-------------|
4085 * |----- ex -----| 4043 * |----- ex -----| |---- ex_right ----|
4086 * |------ r 4044 * |------ requested region ------|
4087 * |======== 4045 * |================|
4088 */ 4046 */
4089 if (map->m_lblk > ee_block) { 4047 if (map->m_lblk > ee_block) {
4090 ext4_lblk_t next = ex 4048 ext4_lblk_t next = ext4_ext_next_allocated_block(path);
4091 map->m_len = min(map- 4049 map->m_len = min(map->m_len, next - map->m_lblk);
4092 } 4050 }
4093 4051
4094 trace_ext4_get_implied_cluste 4052 trace_ext4_get_implied_cluster_alloc_exit(sb, map, 1);
4095 return 1; 4053 return 1;
4096 } 4054 }
4097 4055
4098 trace_ext4_get_implied_cluster_alloc_ 4056 trace_ext4_get_implied_cluster_alloc_exit(sb, map, 0);
4099 return 0; 4057 return 0;
4100 } 4058 }
4101 4059
4102 /* 4060 /*
4103 * Determine hole length around the given log 4061 * Determine hole length around the given logical block, first try to
4104 * locate and expand the hole from the given 4062 * locate and expand the hole from the given @path, and then adjust it
4105 * if it's partially or completely converted 4063 * if it's partially or completely converted to delayed extents, insert
4106 * it into the extent cache tree if it's inde 4064 * it into the extent cache tree if it's indeed a hole, finally return
4107 * the length of the determined extent. 4065 * the length of the determined extent.
4108 */ 4066 */
4109 static ext4_lblk_t ext4_ext_determine_insert_ 4067 static ext4_lblk_t ext4_ext_determine_insert_hole(struct inode *inode,
4110 4068 struct ext4_ext_path *path,
4111 4069 ext4_lblk_t lblk)
4112 { 4070 {
4113 ext4_lblk_t hole_start, len; 4071 ext4_lblk_t hole_start, len;
4114 struct extent_status es; 4072 struct extent_status es;
4115 4073
4116 hole_start = lblk; 4074 hole_start = lblk;
4117 len = ext4_ext_find_hole(inode, path, 4075 len = ext4_ext_find_hole(inode, path, &hole_start);
4118 again: 4076 again:
4119 ext4_es_find_extent_range(inode, &ext 4077 ext4_es_find_extent_range(inode, &ext4_es_is_delayed, hole_start,
4120 hole_start 4078 hole_start + len - 1, &es);
4121 if (!es.es_len) 4079 if (!es.es_len)
4122 goto insert_hole; 4080 goto insert_hole;
4123 4081
4124 /* 4082 /*
4125 * There's a delalloc extent in the h 4083 * There's a delalloc extent in the hole, handle it if the delalloc
4126 * extent is in front of, behind and 4084 * extent is in front of, behind and straddle the queried range.
4127 */ 4085 */
4128 if (lblk >= es.es_lblk + es.es_len) { 4086 if (lblk >= es.es_lblk + es.es_len) {
4129 /* 4087 /*
4130 * The delalloc extent is in 4088 * The delalloc extent is in front of the queried range,
4131 * find again from the querie 4089 * find again from the queried start block.
4132 */ 4090 */
4133 len -= lblk - hole_start; 4091 len -= lblk - hole_start;
4134 hole_start = lblk; 4092 hole_start = lblk;
4135 goto again; 4093 goto again;
4136 } else if (in_range(lblk, es.es_lblk, 4094 } else if (in_range(lblk, es.es_lblk, es.es_len)) {
4137 /* 4095 /*
4138 * The delalloc extent contai 4096 * The delalloc extent containing lblk, it must have been
4139 * added after ext4_map_block 4097 * added after ext4_map_blocks() checked the extent status
4140 * tree so we are not holding !! 4098 * tree, adjust the length to the delalloc extent's after
4141 * only stabilized by i_data_ !! 4099 * lblk.
4142 * soon. Don't modify the ext <<
4143 * extent as a hole, just adj <<
4144 * extent's after lblk. <<
4145 */ 4100 */
4146 len = es.es_lblk + es.es_len 4101 len = es.es_lblk + es.es_len - lblk;
4147 return len; 4102 return len;
4148 } else { 4103 } else {
4149 /* 4104 /*
4150 * The delalloc extent is par 4105 * The delalloc extent is partially or completely behind
4151 * the queried range, update 4106 * the queried range, update hole length until the
4152 * beginning of the delalloc 4107 * beginning of the delalloc extent.
4153 */ 4108 */
4154 len = min(es.es_lblk - hole_s 4109 len = min(es.es_lblk - hole_start, len);
4155 } 4110 }
4156 4111
4157 insert_hole: 4112 insert_hole:
4158 /* Put just found gap into cache to s 4113 /* Put just found gap into cache to speed up subsequent requests */
4159 ext_debug(inode, " -> %u:%u\n", hole_ 4114 ext_debug(inode, " -> %u:%u\n", hole_start, len);
4160 ext4_es_insert_extent(inode, hole_sta !! 4115 ext4_es_insert_extent(inode, hole_start, len, ~0, EXTENT_STATUS_HOLE);
4161 EXTENT_STATUS_H <<
4162 4116
4163 /* Update hole_len to reflect hole si 4117 /* Update hole_len to reflect hole size after lblk */
4164 if (hole_start != lblk) 4118 if (hole_start != lblk)
4165 len -= lblk - hole_start; 4119 len -= lblk - hole_start;
4166 4120
4167 return len; 4121 return len;
4168 } 4122 }
4169 4123
4170 /* 4124 /*
4171 * Block allocation/map/preallocation routine 4125 * Block allocation/map/preallocation routine for extents based files
4172 * 4126 *
4173 * 4127 *
4174 * Need to be called with 4128 * Need to be called with
4175 * down_read(&EXT4_I(inode)->i_data_sem) if n 4129 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
4176 * (ie, flags is zero). Otherwise down_write( !! 4130 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
4177 * 4131 *
4178 * return > 0, number of blocks already mappe 4132 * return > 0, number of blocks already mapped/allocated
4179 * if flags doesn't contain EXT4_GET !! 4133 * if create == 0 and these are pre-allocated blocks
4180 * buffer head is unmapped 4134 * buffer head is unmapped
4181 * otherwise blocks are mapped 4135 * otherwise blocks are mapped
4182 * 4136 *
4183 * return = 0, if plain look up failed (block 4137 * return = 0, if plain look up failed (blocks have not been allocated)
4184 * buffer head is unmapped 4138 * buffer head is unmapped
4185 * 4139 *
4186 * return < 0, error case. 4140 * return < 0, error case.
4187 */ 4141 */
4188 int ext4_ext_map_blocks(handle_t *handle, str 4142 int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
4189 struct ext4_map_block 4143 struct ext4_map_blocks *map, int flags)
4190 { 4144 {
4191 struct ext4_ext_path *path = NULL; 4145 struct ext4_ext_path *path = NULL;
4192 struct ext4_extent newex, *ex, ex2; 4146 struct ext4_extent newex, *ex, ex2;
4193 struct ext4_sb_info *sbi = EXT4_SB(in 4147 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4194 ext4_fsblk_t newblock = 0, pblk; 4148 ext4_fsblk_t newblock = 0, pblk;
4195 int err = 0, depth; !! 4149 int err = 0, depth, ret;
4196 unsigned int allocated = 0, offset = 4150 unsigned int allocated = 0, offset = 0;
4197 unsigned int allocated_clusters = 0; 4151 unsigned int allocated_clusters = 0;
4198 struct ext4_allocation_request ar; 4152 struct ext4_allocation_request ar;
4199 ext4_lblk_t cluster_offset; 4153 ext4_lblk_t cluster_offset;
4200 4154
4201 ext_debug(inode, "blocks %u/%u reques 4155 ext_debug(inode, "blocks %u/%u requested\n", map->m_lblk, map->m_len);
4202 trace_ext4_ext_map_blocks_enter(inode 4156 trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags);
4203 4157
4204 /* find extent for this block */ 4158 /* find extent for this block */
4205 path = ext4_find_extent(inode, map->m 4159 path = ext4_find_extent(inode, map->m_lblk, NULL, 0);
4206 if (IS_ERR(path)) { 4160 if (IS_ERR(path)) {
4207 err = PTR_ERR(path); 4161 err = PTR_ERR(path);
>> 4162 path = NULL;
4208 goto out; 4163 goto out;
4209 } 4164 }
4210 4165
4211 depth = ext_depth(inode); 4166 depth = ext_depth(inode);
4212 4167
4213 /* 4168 /*
4214 * consistent leaf must not be empty; 4169 * consistent leaf must not be empty;
4215 * this situation is possible, though 4170 * this situation is possible, though, _during_ tree modification;
4216 * this is why assert can't be put in 4171 * this is why assert can't be put in ext4_find_extent()
4217 */ 4172 */
4218 if (unlikely(path[depth].p_ext == NUL 4173 if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
4219 EXT4_ERROR_INODE(inode, "bad 4174 EXT4_ERROR_INODE(inode, "bad extent address "
4220 "lblock: %lu 4175 "lblock: %lu, depth: %d pblock %lld",
4221 (unsigned lo 4176 (unsigned long) map->m_lblk, depth,
4222 path[depth]. 4177 path[depth].p_block);
4223 err = -EFSCORRUPTED; 4178 err = -EFSCORRUPTED;
4224 goto out; 4179 goto out;
4225 } 4180 }
4226 4181
4227 ex = path[depth].p_ext; 4182 ex = path[depth].p_ext;
4228 if (ex) { 4183 if (ex) {
4229 ext4_lblk_t ee_block = le32_t 4184 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
4230 ext4_fsblk_t ee_start = ext4_ 4185 ext4_fsblk_t ee_start = ext4_ext_pblock(ex);
4231 unsigned short ee_len; 4186 unsigned short ee_len;
4232 4187
4233 4188
4234 /* 4189 /*
4235 * unwritten extents are trea 4190 * unwritten extents are treated as holes, except that
4236 * we split out initialized p 4191 * we split out initialized portions during a write.
4237 */ 4192 */
4238 ee_len = ext4_ext_get_actual_ 4193 ee_len = ext4_ext_get_actual_len(ex);
4239 4194
4240 trace_ext4_ext_show_extent(in 4195 trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len);
4241 4196
4242 /* if found extent covers blo 4197 /* if found extent covers block, simply return it */
4243 if (in_range(map->m_lblk, ee_ 4198 if (in_range(map->m_lblk, ee_block, ee_len)) {
4244 newblock = map->m_lbl 4199 newblock = map->m_lblk - ee_block + ee_start;
4245 /* number of remainin 4200 /* number of remaining blocks in the extent */
4246 allocated = ee_len - 4201 allocated = ee_len - (map->m_lblk - ee_block);
4247 ext_debug(inode, "%u 4202 ext_debug(inode, "%u fit into %u:%d -> %llu\n",
4248 map->m_lblk 4203 map->m_lblk, ee_block, ee_len, newblock);
4249 4204
4250 /* 4205 /*
4251 * If the extent is i 4206 * If the extent is initialized check whether the
4252 * caller wants to co 4207 * caller wants to convert it to unwritten.
4253 */ 4208 */
4254 if ((!ext4_ext_is_unw 4209 if ((!ext4_ext_is_unwritten(ex)) &&
4255 (flags & EXT4_GET 4210 (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN)) {
4256 path = conver !! 4211 err = convert_initialized_extent(handle,
4257 inode !! 4212 inode, map, &path, &allocated);
4258 if (IS_ERR(pa <<
4259 err = <<
4260 goto out; 4213 goto out;
4261 } else if (!ext4_ext_ 4214 } else if (!ext4_ext_is_unwritten(ex)) {
4262 map->m_flags 4215 map->m_flags |= EXT4_MAP_MAPPED;
4263 map->m_pblk = 4216 map->m_pblk = newblock;
4264 if (allocated 4217 if (allocated > map->m_len)
4265 alloc 4218 allocated = map->m_len;
4266 map->m_len = 4219 map->m_len = allocated;
4267 ext4_ext_show 4220 ext4_ext_show_leaf(inode, path);
4268 goto out; 4221 goto out;
4269 } 4222 }
4270 4223
4271 path = ext4_ext_handl !! 4224 ret = ext4_ext_handle_unwritten_extents(
4272 handle, inode !! 4225 handle, inode, map, &path, flags,
4273 &allocated, n !! 4226 allocated, newblock);
4274 if (IS_ERR(path)) !! 4227 if (ret < 0)
4275 err = PTR_ERR !! 4228 err = ret;
>> 4229 else
>> 4230 allocated = ret;
4276 goto out; 4231 goto out;
4277 } 4232 }
4278 } 4233 }
4279 4234
4280 /* 4235 /*
4281 * requested block isn't allocated ye 4236 * requested block isn't allocated yet;
4282 * we couldn't try to create block if !! 4237 * we couldn't try to create block if create flag is zero
4283 */ 4238 */
4284 if ((flags & EXT4_GET_BLOCKS_CREATE) 4239 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
4285 ext4_lblk_t len; 4240 ext4_lblk_t len;
4286 4241
4287 len = ext4_ext_determine_inse 4242 len = ext4_ext_determine_insert_hole(inode, path, map->m_lblk);
4288 4243
4289 map->m_pblk = 0; 4244 map->m_pblk = 0;
4290 map->m_len = min_t(unsigned i 4245 map->m_len = min_t(unsigned int, map->m_len, len);
4291 goto out; 4246 goto out;
4292 } 4247 }
4293 4248
4294 /* 4249 /*
4295 * Okay, we need to do block allocati 4250 * Okay, we need to do block allocation.
4296 */ 4251 */
4297 newex.ee_block = cpu_to_le32(map->m_l 4252 newex.ee_block = cpu_to_le32(map->m_lblk);
4298 cluster_offset = EXT4_LBLK_COFF(sbi, 4253 cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
4299 4254
4300 /* 4255 /*
4301 * If we are doing bigalloc, check to 4256 * If we are doing bigalloc, check to see if the extent returned
4302 * by ext4_find_extent() implies a cl 4257 * by ext4_find_extent() implies a cluster we can use.
4303 */ 4258 */
4304 if (cluster_offset && ex && 4259 if (cluster_offset && ex &&
4305 get_implied_cluster_alloc(inode-> 4260 get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {
4306 ar.len = allocated = map->m_l 4261 ar.len = allocated = map->m_len;
4307 newblock = map->m_pblk; 4262 newblock = map->m_pblk;
4308 goto got_allocated_blocks; 4263 goto got_allocated_blocks;
4309 } 4264 }
4310 4265
4311 /* find neighbour allocated blocks */ 4266 /* find neighbour allocated blocks */
4312 ar.lleft = map->m_lblk; 4267 ar.lleft = map->m_lblk;
4313 err = ext4_ext_search_left(inode, pat 4268 err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
4314 if (err) 4269 if (err)
4315 goto out; 4270 goto out;
4316 ar.lright = map->m_lblk; 4271 ar.lright = map->m_lblk;
4317 err = ext4_ext_search_right(inode, pa 4272 err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2);
4318 if (err < 0) 4273 if (err < 0)
4319 goto out; 4274 goto out;
4320 4275
4321 /* Check if the extent after searchin 4276 /* Check if the extent after searching to the right implies a
4322 * cluster we can use. */ 4277 * cluster we can use. */
4323 if ((sbi->s_cluster_ratio > 1) && err 4278 if ((sbi->s_cluster_ratio > 1) && err &&
4324 get_implied_cluster_alloc(inode-> 4279 get_implied_cluster_alloc(inode->i_sb, map, &ex2, path)) {
4325 ar.len = allocated = map->m_l 4280 ar.len = allocated = map->m_len;
4326 newblock = map->m_pblk; 4281 newblock = map->m_pblk;
4327 err = 0; <<
4328 goto got_allocated_blocks; 4282 goto got_allocated_blocks;
4329 } 4283 }
4330 4284
4331 /* 4285 /*
4332 * See if request is beyond maximum n 4286 * See if request is beyond maximum number of blocks we can have in
4333 * a single extent. For an initialize 4287 * a single extent. For an initialized extent this limit is
4334 * EXT_INIT_MAX_LEN and for an unwrit 4288 * EXT_INIT_MAX_LEN and for an unwritten extent this limit is
4335 * EXT_UNWRITTEN_MAX_LEN. 4289 * EXT_UNWRITTEN_MAX_LEN.
4336 */ 4290 */
4337 if (map->m_len > EXT_INIT_MAX_LEN && 4291 if (map->m_len > EXT_INIT_MAX_LEN &&
4338 !(flags & EXT4_GET_BLOCKS_UNWRIT_ 4292 !(flags & EXT4_GET_BLOCKS_UNWRIT_EXT))
4339 map->m_len = EXT_INIT_MAX_LEN 4293 map->m_len = EXT_INIT_MAX_LEN;
4340 else if (map->m_len > EXT_UNWRITTEN_M 4294 else if (map->m_len > EXT_UNWRITTEN_MAX_LEN &&
4341 (flags & EXT4_GET_BLOCKS_UNW 4295 (flags & EXT4_GET_BLOCKS_UNWRIT_EXT))
4342 map->m_len = EXT_UNWRITTEN_MA 4296 map->m_len = EXT_UNWRITTEN_MAX_LEN;
4343 4297
4344 /* Check if we can really insert (m_l 4298 /* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */
4345 newex.ee_len = cpu_to_le16(map->m_len 4299 newex.ee_len = cpu_to_le16(map->m_len);
4346 err = ext4_ext_check_overlap(sbi, ino 4300 err = ext4_ext_check_overlap(sbi, inode, &newex, path);
4347 if (err) 4301 if (err)
4348 allocated = ext4_ext_get_actu 4302 allocated = ext4_ext_get_actual_len(&newex);
4349 else 4303 else
4350 allocated = map->m_len; 4304 allocated = map->m_len;
4351 4305
4352 /* allocate new block */ 4306 /* allocate new block */
4353 ar.inode = inode; 4307 ar.inode = inode;
4354 ar.goal = ext4_ext_find_goal(inode, p 4308 ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk);
4355 ar.logical = map->m_lblk; 4309 ar.logical = map->m_lblk;
4356 /* 4310 /*
4357 * We calculate the offset from the b 4311 * We calculate the offset from the beginning of the cluster
4358 * for the logical block number, sinc 4312 * for the logical block number, since when we allocate a
4359 * physical cluster, the physical blo 4313 * physical cluster, the physical block should start at the
4360 * same offset from the beginning of 4314 * same offset from the beginning of the cluster. This is
4361 * needed so that future calls to get 4315 * needed so that future calls to get_implied_cluster_alloc()
4362 * work correctly. 4316 * work correctly.
4363 */ 4317 */
4364 offset = EXT4_LBLK_COFF(sbi, map->m_l 4318 offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
4365 ar.len = EXT4_NUM_B2C(sbi, offset+all 4319 ar.len = EXT4_NUM_B2C(sbi, offset+allocated);
4366 ar.goal -= offset; 4320 ar.goal -= offset;
4367 ar.logical -= offset; 4321 ar.logical -= offset;
4368 if (S_ISREG(inode->i_mode)) 4322 if (S_ISREG(inode->i_mode))
4369 ar.flags = EXT4_MB_HINT_DATA; 4323 ar.flags = EXT4_MB_HINT_DATA;
4370 else 4324 else
4371 /* disable in-core preallocat 4325 /* disable in-core preallocation for non-regular files */
4372 ar.flags = 0; 4326 ar.flags = 0;
4373 if (flags & EXT4_GET_BLOCKS_NO_NORMAL 4327 if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE)
4374 ar.flags |= EXT4_MB_HINT_NOPR 4328 ar.flags |= EXT4_MB_HINT_NOPREALLOC;
4375 if (flags & EXT4_GET_BLOCKS_DELALLOC_ 4329 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
4376 ar.flags |= EXT4_MB_DELALLOC_ 4330 ar.flags |= EXT4_MB_DELALLOC_RESERVED;
4377 if (flags & EXT4_GET_BLOCKS_METADATA_ 4331 if (flags & EXT4_GET_BLOCKS_METADATA_NOFAIL)
4378 ar.flags |= EXT4_MB_USE_RESER 4332 ar.flags |= EXT4_MB_USE_RESERVED;
4379 newblock = ext4_mb_new_blocks(handle, 4333 newblock = ext4_mb_new_blocks(handle, &ar, &err);
4380 if (!newblock) 4334 if (!newblock)
4381 goto out; 4335 goto out;
4382 allocated_clusters = ar.len; 4336 allocated_clusters = ar.len;
4383 ar.len = EXT4_C2B(sbi, ar.len) - offs 4337 ar.len = EXT4_C2B(sbi, ar.len) - offset;
4384 ext_debug(inode, "allocate new block: 4338 ext_debug(inode, "allocate new block: goal %llu, found %llu/%u, requested %u\n",
4385 ar.goal, newblock, ar.len, 4339 ar.goal, newblock, ar.len, allocated);
4386 if (ar.len > allocated) 4340 if (ar.len > allocated)
4387 ar.len = allocated; 4341 ar.len = allocated;
4388 4342
4389 got_allocated_blocks: 4343 got_allocated_blocks:
4390 /* try to insert new extent into foun 4344 /* try to insert new extent into found leaf and return */
4391 pblk = newblock + offset; 4345 pblk = newblock + offset;
4392 ext4_ext_store_pblock(&newex, pblk); 4346 ext4_ext_store_pblock(&newex, pblk);
4393 newex.ee_len = cpu_to_le16(ar.len); 4347 newex.ee_len = cpu_to_le16(ar.len);
4394 /* Mark unwritten */ 4348 /* Mark unwritten */
4395 if (flags & EXT4_GET_BLOCKS_UNWRIT_EX 4349 if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT) {
4396 ext4_ext_mark_unwritten(&newe 4350 ext4_ext_mark_unwritten(&newex);
4397 map->m_flags |= EXT4_MAP_UNWR 4351 map->m_flags |= EXT4_MAP_UNWRITTEN;
4398 } 4352 }
4399 4353
4400 path = ext4_ext_insert_extent(handle, !! 4354 err = ext4_ext_insert_extent(handle, inode, &path, &newex, flags);
4401 if (IS_ERR(path)) { !! 4355 if (err) {
4402 err = PTR_ERR(path); <<
4403 if (allocated_clusters) { 4356 if (allocated_clusters) {
4404 int fb_flags = 0; 4357 int fb_flags = 0;
4405 4358
4406 /* 4359 /*
4407 * free data blocks w 4360 * free data blocks we just allocated.
4408 * not a good idea to 4361 * not a good idea to call discard here directly,
4409 * but otherwise we'd 4362 * but otherwise we'd need to call it every free().
4410 */ 4363 */
4411 ext4_discard_prealloc !! 4364 ext4_discard_preallocations(inode, 0);
4412 if (flags & EXT4_GET_ 4365 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
4413 fb_flags = EX 4366 fb_flags = EXT4_FREE_BLOCKS_NO_QUOT_UPDATE;
4414 ext4_free_blocks(hand 4367 ext4_free_blocks(handle, inode, NULL, newblock,
4415 EXT4 4368 EXT4_C2B(sbi, allocated_clusters),
4416 fb_f 4369 fb_flags);
4417 } 4370 }
4418 goto out; 4371 goto out;
4419 } 4372 }
4420 4373
4421 /* 4374 /*
>> 4375 * Reduce the reserved cluster count to reflect successful deferred
>> 4376 * allocation of delayed allocated clusters or direct allocation of
>> 4377 * clusters discovered to be delayed allocated. Once allocated, a
>> 4378 * cluster is not included in the reserved count.
>> 4379 */
>> 4380 if (test_opt(inode->i_sb, DELALLOC) && allocated_clusters) {
>> 4381 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
>> 4382 /*
>> 4383 * When allocating delayed allocated clusters, simply
>> 4384 * reduce the reserved cluster count and claim quota
>> 4385 */
>> 4386 ext4_da_update_reserve_space(inode, allocated_clusters,
>> 4387 1);
>> 4388 } else {
>> 4389 ext4_lblk_t lblk, len;
>> 4390 unsigned int n;
>> 4391
>> 4392 /*
>> 4393 * When allocating non-delayed allocated clusters
>> 4394 * (from fallocate, filemap, DIO, or clusters
>> 4395 * allocated when delalloc has been disabled by
>> 4396 * ext4_nonda_switch), reduce the reserved cluster
>> 4397 * count by the number of allocated clusters that
>> 4398 * have previously been delayed allocated. Quota
>> 4399 * has been claimed by ext4_mb_new_blocks() above,
>> 4400 * so release the quota reservations made for any
>> 4401 * previously delayed allocated clusters.
>> 4402 */
>> 4403 lblk = EXT4_LBLK_CMASK(sbi, map->m_lblk);
>> 4404 len = allocated_clusters << sbi->s_cluster_bits;
>> 4405 n = ext4_es_delayed_clu(inode, lblk, len);
>> 4406 if (n > 0)
>> 4407 ext4_da_update_reserve_space(inode, (int) n, 0);
>> 4408 }
>> 4409 }
>> 4410
>> 4411 /*
4422 * Cache the extent and update transa 4412 * Cache the extent and update transaction to commit on fdatasync only
4423 * when it is _not_ an unwritten exte 4413 * when it is _not_ an unwritten extent.
4424 */ 4414 */
4425 if ((flags & EXT4_GET_BLOCKS_UNWRIT_E 4415 if ((flags & EXT4_GET_BLOCKS_UNWRIT_EXT) == 0)
4426 ext4_update_inode_fsync_trans 4416 ext4_update_inode_fsync_trans(handle, inode, 1);
4427 else 4417 else
4428 ext4_update_inode_fsync_trans 4418 ext4_update_inode_fsync_trans(handle, inode, 0);
4429 4419
4430 map->m_flags |= (EXT4_MAP_NEW | EXT4_ 4420 map->m_flags |= (EXT4_MAP_NEW | EXT4_MAP_MAPPED);
4431 map->m_pblk = pblk; 4421 map->m_pblk = pblk;
4432 map->m_len = ar.len; 4422 map->m_len = ar.len;
4433 allocated = map->m_len; 4423 allocated = map->m_len;
4434 ext4_ext_show_leaf(inode, path); 4424 ext4_ext_show_leaf(inode, path);
4435 out: 4425 out:
4436 ext4_free_ext_path(path); !! 4426 ext4_ext_drop_refs(path);
>> 4427 kfree(path);
4437 4428
4438 trace_ext4_ext_map_blocks_exit(inode, 4429 trace_ext4_ext_map_blocks_exit(inode, flags, map,
4439 err ? 4430 err ? err : allocated);
4440 return err ? err : allocated; 4431 return err ? err : allocated;
4441 } 4432 }
4442 4433
4443 int ext4_ext_truncate(handle_t *handle, struc 4434 int ext4_ext_truncate(handle_t *handle, struct inode *inode)
4444 { 4435 {
4445 struct super_block *sb = inode->i_sb; 4436 struct super_block *sb = inode->i_sb;
4446 ext4_lblk_t last_block; 4437 ext4_lblk_t last_block;
4447 int err = 0; 4438 int err = 0;
4448 4439
4449 /* 4440 /*
4450 * TODO: optimization is possible her 4441 * TODO: optimization is possible here.
4451 * Probably we need not scan at all, 4442 * Probably we need not scan at all,
4452 * because page truncation is enough. 4443 * because page truncation is enough.
4453 */ 4444 */
4454 4445
4455 /* we have to know where to truncate 4446 /* we have to know where to truncate from in crash case */
4456 EXT4_I(inode)->i_disksize = inode->i_ 4447 EXT4_I(inode)->i_disksize = inode->i_size;
4457 err = ext4_mark_inode_dirty(handle, i 4448 err = ext4_mark_inode_dirty(handle, inode);
4458 if (err) 4449 if (err)
4459 return err; 4450 return err;
4460 4451
4461 last_block = (inode->i_size + sb->s_b 4452 last_block = (inode->i_size + sb->s_blocksize - 1)
4462 >> EXT4_BLOCK_SIZE_BI 4453 >> EXT4_BLOCK_SIZE_BITS(sb);
4463 ext4_es_remove_extent(inode, last_blo !! 4454 retry:
4464 !! 4455 err = ext4_es_remove_extent(inode, last_block,
>> 4456 EXT_MAX_BLOCKS - last_block);
>> 4457 if (err == -ENOMEM) {
>> 4458 cond_resched();
>> 4459 congestion_wait(BLK_RW_ASYNC, HZ/50);
>> 4460 goto retry;
>> 4461 }
>> 4462 if (err)
>> 4463 return err;
4465 retry_remove_space: 4464 retry_remove_space:
4466 err = ext4_ext_remove_space(inode, la 4465 err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1);
4467 if (err == -ENOMEM) { 4466 if (err == -ENOMEM) {
4468 memalloc_retry_wait(GFP_ATOMI !! 4467 cond_resched();
>> 4468 congestion_wait(BLK_RW_ASYNC, HZ/50);
4469 goto retry_remove_space; 4469 goto retry_remove_space;
4470 } 4470 }
4471 return err; 4471 return err;
4472 } 4472 }
4473 4473
4474 static int ext4_alloc_file_blocks(struct file 4474 static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset,
4475 ext4_lblk_t 4475 ext4_lblk_t len, loff_t new_size,
4476 int flags) 4476 int flags)
4477 { 4477 {
4478 struct inode *inode = file_inode(file 4478 struct inode *inode = file_inode(file);
4479 handle_t *handle; 4479 handle_t *handle;
4480 int ret = 0, ret2 = 0, ret3 = 0; !! 4480 int ret = 0;
>> 4481 int ret2 = 0, ret3 = 0;
4481 int retries = 0; 4482 int retries = 0;
4482 int depth = 0; 4483 int depth = 0;
4483 struct ext4_map_blocks map; 4484 struct ext4_map_blocks map;
4484 unsigned int credits; 4485 unsigned int credits;
4485 loff_t epos; 4486 loff_t epos;
4486 4487
4487 BUG_ON(!ext4_test_inode_flag(inode, E 4488 BUG_ON(!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS));
4488 map.m_lblk = offset; 4489 map.m_lblk = offset;
4489 map.m_len = len; 4490 map.m_len = len;
4490 /* 4491 /*
4491 * Don't normalize the request if it 4492 * Don't normalize the request if it can fit in one extent so
4492 * that it doesn't get unnecessarily 4493 * that it doesn't get unnecessarily split into multiple
4493 * extents. 4494 * extents.
4494 */ 4495 */
4495 if (len <= EXT_UNWRITTEN_MAX_LEN) 4496 if (len <= EXT_UNWRITTEN_MAX_LEN)
4496 flags |= EXT4_GET_BLOCKS_NO_N 4497 flags |= EXT4_GET_BLOCKS_NO_NORMALIZE;
4497 4498
4498 /* 4499 /*
4499 * credits to insert 1 extent into ex 4500 * credits to insert 1 extent into extent tree
4500 */ 4501 */
4501 credits = ext4_chunk_trans_blocks(ino 4502 credits = ext4_chunk_trans_blocks(inode, len);
4502 depth = ext_depth(inode); 4503 depth = ext_depth(inode);
4503 4504
4504 retry: 4505 retry:
4505 while (len) { !! 4506 while (ret >= 0 && len) {
4506 /* 4507 /*
4507 * Recalculate credits when e 4508 * Recalculate credits when extent tree depth changes.
4508 */ 4509 */
4509 if (depth != ext_depth(inode) 4510 if (depth != ext_depth(inode)) {
4510 credits = ext4_chunk_ 4511 credits = ext4_chunk_trans_blocks(inode, len);
4511 depth = ext_depth(ino 4512 depth = ext_depth(inode);
4512 } 4513 }
4513 4514
4514 handle = ext4_journal_start(i 4515 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
4515 c 4516 credits);
4516 if (IS_ERR(handle)) { 4517 if (IS_ERR(handle)) {
4517 ret = PTR_ERR(handle) 4518 ret = PTR_ERR(handle);
4518 break; 4519 break;
4519 } 4520 }
4520 ret = ext4_map_blocks(handle, 4521 ret = ext4_map_blocks(handle, inode, &map, flags);
4521 if (ret <= 0) { 4522 if (ret <= 0) {
4522 ext4_debug("inode #%l 4523 ext4_debug("inode #%lu: block %u: len %u: "
4523 "ext4_ext_ 4524 "ext4_ext_map_blocks returned %d",
4524 inode->i_i 4525 inode->i_ino, map.m_lblk,
4525 map.m_len, 4526 map.m_len, ret);
4526 ext4_mark_inode_dirty 4527 ext4_mark_inode_dirty(handle, inode);
4527 ext4_journal_stop(han !! 4528 ret2 = ext4_journal_stop(handle);
4528 break; 4529 break;
4529 } 4530 }
4530 /* <<
4531 * allow a full retry cycle f <<
4532 */ <<
4533 retries = 0; <<
4534 map.m_lblk += ret; 4531 map.m_lblk += ret;
4535 map.m_len = len = len - ret; 4532 map.m_len = len = len - ret;
4536 epos = (loff_t)map.m_lblk << 4533 epos = (loff_t)map.m_lblk << inode->i_blkbits;
4537 inode_set_ctime_current(inode !! 4534 inode->i_ctime = current_time(inode);
4538 if (new_size) { 4535 if (new_size) {
4539 if (epos > new_size) 4536 if (epos > new_size)
4540 epos = new_si 4537 epos = new_size;
4541 if (ext4_update_inode 4538 if (ext4_update_inode_size(inode, epos) & 0x1)
4542 inode_set_mti !! 4539 inode->i_mtime = inode->i_ctime;
4543 <<
4544 } 4540 }
4545 ret2 = ext4_mark_inode_dirty( 4541 ret2 = ext4_mark_inode_dirty(handle, inode);
4546 ext4_update_inode_fsync_trans 4542 ext4_update_inode_fsync_trans(handle, inode, 1);
4547 ret3 = ext4_journal_stop(hand 4543 ret3 = ext4_journal_stop(handle);
4548 ret2 = ret3 ? ret3 : ret2; 4544 ret2 = ret3 ? ret3 : ret2;
4549 if (unlikely(ret2)) 4545 if (unlikely(ret2))
4550 break; 4546 break;
4551 } 4547 }
4552 if (ret == -ENOSPC && ext4_should_ret !! 4548 if (ret == -ENOSPC &&
>> 4549 ext4_should_retry_alloc(inode->i_sb, &retries)) {
>> 4550 ret = 0;
4553 goto retry; 4551 goto retry;
>> 4552 }
4554 4553
4555 return ret > 0 ? ret2 : ret; 4554 return ret > 0 ? ret2 : ret;
4556 } 4555 }
4557 4556
4558 static int ext4_collapse_range(struct file *f 4557 static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len);
4559 4558
4560 static int ext4_insert_range(struct file *fil 4559 static int ext4_insert_range(struct file *file, loff_t offset, loff_t len);
4561 4560
4562 static long ext4_zero_range(struct file *file 4561 static long ext4_zero_range(struct file *file, loff_t offset,
4563 loff_t len, int m 4562 loff_t len, int mode)
4564 { 4563 {
4565 struct inode *inode = file_inode(file 4564 struct inode *inode = file_inode(file);
4566 struct address_space *mapping = file- <<
4567 handle_t *handle = NULL; 4565 handle_t *handle = NULL;
4568 unsigned int max_blocks; 4566 unsigned int max_blocks;
4569 loff_t new_size = 0; 4567 loff_t new_size = 0;
4570 int ret = 0; 4568 int ret = 0;
4571 int flags; 4569 int flags;
4572 int credits; 4570 int credits;
4573 int partial_begin, partial_end; 4571 int partial_begin, partial_end;
4574 loff_t start, end; 4572 loff_t start, end;
4575 ext4_lblk_t lblk; 4573 ext4_lblk_t lblk;
4576 unsigned int blkbits = inode->i_blkbi 4574 unsigned int blkbits = inode->i_blkbits;
4577 4575
4578 trace_ext4_zero_range(inode, offset, 4576 trace_ext4_zero_range(inode, offset, len, mode);
4579 4577
>> 4578 /* Call ext4_force_commit to flush all data in case of data=journal. */
>> 4579 if (ext4_should_journal_data(inode)) {
>> 4580 ret = ext4_force_commit(inode->i_sb);
>> 4581 if (ret)
>> 4582 return ret;
>> 4583 }
>> 4584
4580 /* 4585 /*
4581 * Round up offset. This is not fallo 4586 * Round up offset. This is not fallocate, we need to zero out
4582 * blocks, so convert interior block 4587 * blocks, so convert interior block aligned part of the range to
4583 * unwritten and possibly manually ze 4588 * unwritten and possibly manually zero out unaligned parts of the
4584 * range. Here, start and partial_beg !! 4589 * range.
4585 * partial_end are exclusive. <<
4586 */ 4590 */
4587 start = round_up(offset, 1 << blkbits 4591 start = round_up(offset, 1 << blkbits);
4588 end = round_down((offset + len), 1 << 4592 end = round_down((offset + len), 1 << blkbits);
4589 4593
4590 if (start < offset || end > offset + 4594 if (start < offset || end > offset + len)
4591 return -EINVAL; 4595 return -EINVAL;
4592 partial_begin = offset & ((1 << blkbi 4596 partial_begin = offset & ((1 << blkbits) - 1);
4593 partial_end = (offset + len) & ((1 << 4597 partial_end = (offset + len) & ((1 << blkbits) - 1);
4594 4598
4595 lblk = start >> blkbits; 4599 lblk = start >> blkbits;
4596 max_blocks = (end >> blkbits); 4600 max_blocks = (end >> blkbits);
4597 if (max_blocks < lblk) 4601 if (max_blocks < lblk)
4598 max_blocks = 0; 4602 max_blocks = 0;
4599 else 4603 else
4600 max_blocks -= lblk; 4604 max_blocks -= lblk;
4601 4605
4602 inode_lock(inode); 4606 inode_lock(inode);
4603 4607
4604 /* 4608 /*
4605 * Indirect files do not support unwr 4609 * Indirect files do not support unwritten extents
4606 */ 4610 */
4607 if (!(ext4_test_inode_flag(inode, EXT 4611 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4608 ret = -EOPNOTSUPP; 4612 ret = -EOPNOTSUPP;
4609 goto out_mutex; 4613 goto out_mutex;
4610 } 4614 }
4611 4615
4612 if (!(mode & FALLOC_FL_KEEP_SIZE) && 4616 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
4613 (offset + len > inode->i_size || 4617 (offset + len > inode->i_size ||
4614 offset + len > EXT4_I(inode)->i_ 4618 offset + len > EXT4_I(inode)->i_disksize)) {
4615 new_size = offset + len; 4619 new_size = offset + len;
4616 ret = inode_newsize_ok(inode, 4620 ret = inode_newsize_ok(inode, new_size);
4617 if (ret) 4621 if (ret)
4618 goto out_mutex; 4622 goto out_mutex;
4619 } 4623 }
4620 4624
4621 flags = EXT4_GET_BLOCKS_CREATE_UNWRIT 4625 flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
4622 4626
4623 /* Wait all existing dio workers, new !! 4627 /* Wait all existing dio workers, newcomers will block on i_mutex */
4624 inode_dio_wait(inode); 4628 inode_dio_wait(inode);
4625 4629
4626 ret = file_modified(file); 4630 ret = file_modified(file);
4627 if (ret) 4631 if (ret)
4628 goto out_mutex; 4632 goto out_mutex;
4629 4633
4630 /* Preallocate the range including th 4634 /* Preallocate the range including the unaligned edges */
4631 if (partial_begin || partial_end) { 4635 if (partial_begin || partial_end) {
4632 ret = ext4_alloc_file_blocks( 4636 ret = ext4_alloc_file_blocks(file,
4633 round_down(of 4637 round_down(offset, 1 << blkbits) >> blkbits,
4634 (round_up((of 4638 (round_up((offset + len), 1 << blkbits) -
4635 round_down(o 4639 round_down(offset, 1 << blkbits)) >> blkbits,
4636 new_size, fla 4640 new_size, flags);
4637 if (ret) 4641 if (ret)
4638 goto out_mutex; 4642 goto out_mutex;
4639 4643
4640 } 4644 }
4641 4645
4642 /* Zero range excluding the unaligned 4646 /* Zero range excluding the unaligned edges */
4643 if (max_blocks > 0) { 4647 if (max_blocks > 0) {
4644 flags |= (EXT4_GET_BLOCKS_CON 4648 flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
4645 EXT4_EX_NOCACHE); 4649 EXT4_EX_NOCACHE);
4646 4650
4647 /* 4651 /*
4648 * Prevent page faults from r 4652 * Prevent page faults from reinstantiating pages we have
4649 * released from page cache. 4653 * released from page cache.
4650 */ 4654 */
4651 filemap_invalidate_lock(mappi !! 4655 down_write(&EXT4_I(inode)->i_mmap_sem);
4652 4656
4653 ret = ext4_break_layouts(inod 4657 ret = ext4_break_layouts(inode);
4654 if (ret) { 4658 if (ret) {
4655 filemap_invalidate_un !! 4659 up_write(&EXT4_I(inode)->i_mmap_sem);
4656 goto out_mutex; 4660 goto out_mutex;
4657 } 4661 }
4658 4662
4659 ret = ext4_update_disksize_be 4663 ret = ext4_update_disksize_before_punch(inode, offset, len);
4660 if (ret) { 4664 if (ret) {
4661 filemap_invalidate_un !! 4665 up_write(&EXT4_I(inode)->i_mmap_sem);
4662 goto out_mutex; 4666 goto out_mutex;
4663 } 4667 }
4664 <<
4665 /* <<
4666 * For journalled data we nee <<
4667 * before discarding page cac <<
4668 * disk in case of crash befo <<
4669 */ <<
4670 if (ext4_should_journal_data( <<
4671 ret = filemap_write_a <<
4672 <<
4673 if (ret) { <<
4674 filemap_inval <<
4675 goto out_mute <<
4676 } <<
4677 } <<
4678 <<
4679 /* Now release the pages and 4668 /* Now release the pages and zero block aligned part of pages */
4680 truncate_pagecache_range(inod 4669 truncate_pagecache_range(inode, start, end - 1);
4681 inode_set_mtime_to_ts(inode, !! 4670 inode->i_mtime = inode->i_ctime = current_time(inode);
4682 4671
4683 ret = ext4_alloc_file_blocks( 4672 ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
4684 4673 flags);
4685 filemap_invalidate_unlock(map !! 4674 up_write(&EXT4_I(inode)->i_mmap_sem);
4686 if (ret) 4675 if (ret)
4687 goto out_mutex; 4676 goto out_mutex;
4688 } 4677 }
4689 if (!partial_begin && !partial_end) 4678 if (!partial_begin && !partial_end)
4690 goto out_mutex; 4679 goto out_mutex;
4691 4680
4692 /* 4681 /*
4693 * In worst case we have to writeout 4682 * In worst case we have to writeout two nonadjacent unwritten
4694 * blocks and update the inode 4683 * blocks and update the inode
4695 */ 4684 */
4696 credits = (2 * ext4_ext_index_trans_b 4685 credits = (2 * ext4_ext_index_trans_blocks(inode, 2)) + 1;
4697 if (ext4_should_journal_data(inode)) 4686 if (ext4_should_journal_data(inode))
4698 credits += 2; 4687 credits += 2;
4699 handle = ext4_journal_start(inode, EX 4688 handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
4700 if (IS_ERR(handle)) { 4689 if (IS_ERR(handle)) {
4701 ret = PTR_ERR(handle); 4690 ret = PTR_ERR(handle);
4702 ext4_std_error(inode->i_sb, r 4691 ext4_std_error(inode->i_sb, ret);
4703 goto out_mutex; 4692 goto out_mutex;
4704 } 4693 }
4705 4694
4706 inode_set_mtime_to_ts(inode, inode_se !! 4695 inode->i_mtime = inode->i_ctime = current_time(inode);
4707 if (new_size) 4696 if (new_size)
4708 ext4_update_inode_size(inode, 4697 ext4_update_inode_size(inode, new_size);
4709 ret = ext4_mark_inode_dirty(handle, i 4698 ret = ext4_mark_inode_dirty(handle, inode);
4710 if (unlikely(ret)) 4699 if (unlikely(ret))
4711 goto out_handle; 4700 goto out_handle;
4712 /* Zero out partial block at the edge 4701 /* Zero out partial block at the edges of the range */
4713 ret = ext4_zero_partial_blocks(handle 4702 ret = ext4_zero_partial_blocks(handle, inode, offset, len);
4714 if (ret >= 0) 4703 if (ret >= 0)
4715 ext4_update_inode_fsync_trans 4704 ext4_update_inode_fsync_trans(handle, inode, 1);
4716 4705
4717 if (file->f_flags & O_SYNC) 4706 if (file->f_flags & O_SYNC)
4718 ext4_handle_sync(handle); 4707 ext4_handle_sync(handle);
4719 4708
4720 out_handle: 4709 out_handle:
4721 ext4_journal_stop(handle); 4710 ext4_journal_stop(handle);
4722 out_mutex: 4711 out_mutex:
4723 inode_unlock(inode); 4712 inode_unlock(inode);
4724 return ret; 4713 return ret;
4725 } 4714 }
4726 4715
4727 /* 4716 /*
4728 * preallocate space for a file. This impleme 4717 * preallocate space for a file. This implements ext4's fallocate file
4729 * operation, which gets called from sys_fall 4718 * operation, which gets called from sys_fallocate system call.
4730 * For block-mapped files, posix_fallocate sh 4719 * For block-mapped files, posix_fallocate should fall back to the method
4731 * of writing zeroes to the required new bloc 4720 * of writing zeroes to the required new blocks (the same behavior which is
4732 * expected for file systems which do not sup 4721 * expected for file systems which do not support fallocate() system call).
4733 */ 4722 */
4734 long ext4_fallocate(struct file *file, int mo 4723 long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
4735 { 4724 {
4736 struct inode *inode = file_inode(file 4725 struct inode *inode = file_inode(file);
4737 loff_t new_size = 0; 4726 loff_t new_size = 0;
4738 unsigned int max_blocks; 4727 unsigned int max_blocks;
4739 int ret = 0; 4728 int ret = 0;
4740 int flags; 4729 int flags;
4741 ext4_lblk_t lblk; 4730 ext4_lblk_t lblk;
4742 unsigned int blkbits = inode->i_blkbi 4731 unsigned int blkbits = inode->i_blkbits;
4743 4732
4744 /* 4733 /*
4745 * Encrypted inodes can't handle coll 4734 * Encrypted inodes can't handle collapse range or insert
4746 * range since we would need to re-en 4735 * range since we would need to re-encrypt blocks with a
4747 * different IV or XTS tweak (which a 4736 * different IV or XTS tweak (which are based on the logical
4748 * block number). 4737 * block number).
4749 */ 4738 */
4750 if (IS_ENCRYPTED(inode) && 4739 if (IS_ENCRYPTED(inode) &&
4751 (mode & (FALLOC_FL_COLLAPSE_RANGE 4740 (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)))
4752 return -EOPNOTSUPP; 4741 return -EOPNOTSUPP;
4753 4742
4754 /* Return error if mode is not suppor 4743 /* Return error if mode is not supported */
4755 if (mode & ~(FALLOC_FL_KEEP_SIZE | FA 4744 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
4756 FALLOC_FL_COLLAPSE_RANGE 4745 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |
4757 FALLOC_FL_INSERT_RANGE)) 4746 FALLOC_FL_INSERT_RANGE))
4758 return -EOPNOTSUPP; 4747 return -EOPNOTSUPP;
4759 4748
4760 inode_lock(inode); 4749 inode_lock(inode);
4761 ret = ext4_convert_inline_data(inode) 4750 ret = ext4_convert_inline_data(inode);
4762 inode_unlock(inode); 4751 inode_unlock(inode);
4763 if (ret) 4752 if (ret)
4764 goto exit; 4753 goto exit;
4765 4754
4766 if (mode & FALLOC_FL_PUNCH_HOLE) { 4755 if (mode & FALLOC_FL_PUNCH_HOLE) {
4767 ret = ext4_punch_hole(file, o 4756 ret = ext4_punch_hole(file, offset, len);
4768 goto exit; 4757 goto exit;
4769 } 4758 }
4770 4759
4771 if (mode & FALLOC_FL_COLLAPSE_RANGE) 4760 if (mode & FALLOC_FL_COLLAPSE_RANGE) {
4772 ret = ext4_collapse_range(fil 4761 ret = ext4_collapse_range(file, offset, len);
4773 goto exit; 4762 goto exit;
4774 } 4763 }
4775 4764
4776 if (mode & FALLOC_FL_INSERT_RANGE) { 4765 if (mode & FALLOC_FL_INSERT_RANGE) {
4777 ret = ext4_insert_range(file, 4766 ret = ext4_insert_range(file, offset, len);
4778 goto exit; 4767 goto exit;
4779 } 4768 }
4780 4769
4781 if (mode & FALLOC_FL_ZERO_RANGE) { 4770 if (mode & FALLOC_FL_ZERO_RANGE) {
4782 ret = ext4_zero_range(file, o 4771 ret = ext4_zero_range(file, offset, len, mode);
4783 goto exit; 4772 goto exit;
4784 } 4773 }
4785 trace_ext4_fallocate_enter(inode, off 4774 trace_ext4_fallocate_enter(inode, offset, len, mode);
4786 lblk = offset >> blkbits; 4775 lblk = offset >> blkbits;
4787 4776
4788 max_blocks = EXT4_MAX_BLOCKS(len, off 4777 max_blocks = EXT4_MAX_BLOCKS(len, offset, blkbits);
4789 flags = EXT4_GET_BLOCKS_CREATE_UNWRIT 4778 flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT;
4790 4779
4791 inode_lock(inode); 4780 inode_lock(inode);
4792 4781
4793 /* 4782 /*
4794 * We only support preallocation for 4783 * We only support preallocation for extent-based files only
4795 */ 4784 */
4796 if (!(ext4_test_inode_flag(inode, EXT 4785 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4797 ret = -EOPNOTSUPP; 4786 ret = -EOPNOTSUPP;
4798 goto out; 4787 goto out;
4799 } 4788 }
4800 4789
4801 if (!(mode & FALLOC_FL_KEEP_SIZE) && 4790 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
4802 (offset + len > inode->i_size || 4791 (offset + len > inode->i_size ||
4803 offset + len > EXT4_I(inode)->i_ 4792 offset + len > EXT4_I(inode)->i_disksize)) {
4804 new_size = offset + len; 4793 new_size = offset + len;
4805 ret = inode_newsize_ok(inode, 4794 ret = inode_newsize_ok(inode, new_size);
4806 if (ret) 4795 if (ret)
4807 goto out; 4796 goto out;
4808 } 4797 }
4809 4798
4810 /* Wait all existing dio workers, new !! 4799 /* Wait all existing dio workers, newcomers will block on i_mutex */
4811 inode_dio_wait(inode); 4800 inode_dio_wait(inode);
4812 4801
4813 ret = file_modified(file); 4802 ret = file_modified(file);
4814 if (ret) 4803 if (ret)
4815 goto out; 4804 goto out;
4816 4805
4817 ret = ext4_alloc_file_blocks(file, lb 4806 ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, flags);
4818 if (ret) 4807 if (ret)
4819 goto out; 4808 goto out;
4820 4809
4821 if (file->f_flags & O_SYNC && EXT4_SB 4810 if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) {
4822 ret = ext4_fc_commit(EXT4_SB( 4811 ret = ext4_fc_commit(EXT4_SB(inode->i_sb)->s_journal,
4823 EXT4_ 4812 EXT4_I(inode)->i_sync_tid);
4824 } 4813 }
4825 out: 4814 out:
4826 inode_unlock(inode); 4815 inode_unlock(inode);
4827 trace_ext4_fallocate_exit(inode, offs 4816 trace_ext4_fallocate_exit(inode, offset, max_blocks, ret);
4828 exit: 4817 exit:
4829 return ret; 4818 return ret;
4830 } 4819 }
4831 4820
4832 /* 4821 /*
4833 * This function convert a range of blocks to 4822 * This function convert a range of blocks to written extents
4834 * The caller of this function will pass the 4823 * The caller of this function will pass the start offset and the size.
4835 * all unwritten extents within this range wi 4824 * all unwritten extents within this range will be converted to
4836 * written extents. 4825 * written extents.
4837 * 4826 *
4838 * This function is called from the direct IO 4827 * This function is called from the direct IO end io call back
4839 * function, to convert the fallocated extent 4828 * function, to convert the fallocated extents after IO is completed.
4840 * Returns 0 on success. 4829 * Returns 0 on success.
4841 */ 4830 */
4842 int ext4_convert_unwritten_extents(handle_t * 4831 int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
4843 loff_t off 4832 loff_t offset, ssize_t len)
4844 { 4833 {
4845 unsigned int max_blocks; 4834 unsigned int max_blocks;
4846 int ret = 0, ret2 = 0, ret3 = 0; 4835 int ret = 0, ret2 = 0, ret3 = 0;
4847 struct ext4_map_blocks map; 4836 struct ext4_map_blocks map;
4848 unsigned int blkbits = inode->i_blkbi 4837 unsigned int blkbits = inode->i_blkbits;
4849 unsigned int credits = 0; 4838 unsigned int credits = 0;
4850 4839
4851 map.m_lblk = offset >> blkbits; 4840 map.m_lblk = offset >> blkbits;
4852 max_blocks = EXT4_MAX_BLOCKS(len, off 4841 max_blocks = EXT4_MAX_BLOCKS(len, offset, blkbits);
4853 4842
4854 if (!handle) { 4843 if (!handle) {
4855 /* 4844 /*
4856 * credits to insert 1 extent 4845 * credits to insert 1 extent into extent tree
4857 */ 4846 */
4858 credits = ext4_chunk_trans_bl 4847 credits = ext4_chunk_trans_blocks(inode, max_blocks);
4859 } 4848 }
4860 while (ret >= 0 && ret < max_blocks) 4849 while (ret >= 0 && ret < max_blocks) {
4861 map.m_lblk += ret; 4850 map.m_lblk += ret;
4862 map.m_len = (max_blocks -= re 4851 map.m_len = (max_blocks -= ret);
4863 if (credits) { 4852 if (credits) {
4864 handle = ext4_journal 4853 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
4865 4854 credits);
4866 if (IS_ERR(handle)) { 4855 if (IS_ERR(handle)) {
4867 ret = PTR_ERR 4856 ret = PTR_ERR(handle);
4868 break; 4857 break;
4869 } 4858 }
4870 } 4859 }
4871 ret = ext4_map_blocks(handle, 4860 ret = ext4_map_blocks(handle, inode, &map,
4872 EXT4_GE 4861 EXT4_GET_BLOCKS_IO_CONVERT_EXT);
4873 if (ret <= 0) 4862 if (ret <= 0)
4874 ext4_warning(inode->i 4863 ext4_warning(inode->i_sb,
4875 "inode # 4864 "inode #%lu: block %u: len %u: "
4876 "ext4_ex 4865 "ext4_ext_map_blocks returned %d",
4877 inode->i 4866 inode->i_ino, map.m_lblk,
4878 map.m_le 4867 map.m_len, ret);
4879 ret2 = ext4_mark_inode_dirty( 4868 ret2 = ext4_mark_inode_dirty(handle, inode);
4880 if (credits) { 4869 if (credits) {
4881 ret3 = ext4_journal_s 4870 ret3 = ext4_journal_stop(handle);
4882 if (unlikely(ret3)) 4871 if (unlikely(ret3))
4883 ret2 = ret3; 4872 ret2 = ret3;
4884 } 4873 }
4885 4874
4886 if (ret <= 0 || ret2) 4875 if (ret <= 0 || ret2)
4887 break; 4876 break;
4888 } 4877 }
4889 return ret > 0 ? ret2 : ret; 4878 return ret > 0 ? ret2 : ret;
4890 } 4879 }
4891 4880
4892 int ext4_convert_unwritten_io_end_vec(handle_ 4881 int ext4_convert_unwritten_io_end_vec(handle_t *handle, ext4_io_end_t *io_end)
4893 { 4882 {
4894 int ret = 0, err = 0; 4883 int ret = 0, err = 0;
4895 struct ext4_io_end_vec *io_end_vec; 4884 struct ext4_io_end_vec *io_end_vec;
4896 4885
4897 /* 4886 /*
4898 * This is somewhat ugly but the idea 4887 * This is somewhat ugly but the idea is clear: When transaction is
4899 * reserved, everything goes into it. 4888 * reserved, everything goes into it. Otherwise we rather start several
4900 * smaller transactions for conversio 4889 * smaller transactions for conversion of each extent separately.
4901 */ 4890 */
4902 if (handle) { 4891 if (handle) {
4903 handle = ext4_journal_start_r 4892 handle = ext4_journal_start_reserved(handle,
4904 4893 EXT4_HT_EXT_CONVERT);
4905 if (IS_ERR(handle)) 4894 if (IS_ERR(handle))
4906 return PTR_ERR(handle 4895 return PTR_ERR(handle);
4907 } 4896 }
4908 4897
4909 list_for_each_entry(io_end_vec, &io_e 4898 list_for_each_entry(io_end_vec, &io_end->list_vec, list) {
4910 ret = ext4_convert_unwritten_ 4899 ret = ext4_convert_unwritten_extents(handle, io_end->inode,
4911 4900 io_end_vec->offset,
4912 4901 io_end_vec->size);
4913 if (ret) 4902 if (ret)
4914 break; 4903 break;
4915 } 4904 }
4916 4905
4917 if (handle) 4906 if (handle)
4918 err = ext4_journal_stop(handl 4907 err = ext4_journal_stop(handle);
4919 4908
4920 return ret < 0 ? ret : err; 4909 return ret < 0 ? ret : err;
4921 } 4910 }
4922 4911
4923 static int ext4_iomap_xattr_fiemap(struct ino 4912 static int ext4_iomap_xattr_fiemap(struct inode *inode, struct iomap *iomap)
4924 { 4913 {
4925 __u64 physical = 0; 4914 __u64 physical = 0;
4926 __u64 length = 0; 4915 __u64 length = 0;
4927 int blockbits = inode->i_sb->s_blocks 4916 int blockbits = inode->i_sb->s_blocksize_bits;
4928 int error = 0; 4917 int error = 0;
4929 u16 iomap_type; 4918 u16 iomap_type;
4930 4919
4931 /* in-inode? */ 4920 /* in-inode? */
4932 if (ext4_test_inode_state(inode, EXT4 4921 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
4933 struct ext4_iloc iloc; 4922 struct ext4_iloc iloc;
4934 int offset; /* offset of 4923 int offset; /* offset of xattr in inode */
4935 4924
4936 error = ext4_get_inode_loc(in 4925 error = ext4_get_inode_loc(inode, &iloc);
4937 if (error) 4926 if (error)
4938 return error; 4927 return error;
4939 physical = (__u64)iloc.bh->b_ 4928 physical = (__u64)iloc.bh->b_blocknr << blockbits;
4940 offset = EXT4_GOOD_OLD_INODE_ 4929 offset = EXT4_GOOD_OLD_INODE_SIZE +
4941 EXT4_I(inode) 4930 EXT4_I(inode)->i_extra_isize;
4942 physical += offset; 4931 physical += offset;
4943 length = EXT4_SB(inode->i_sb) 4932 length = EXT4_SB(inode->i_sb)->s_inode_size - offset;
4944 brelse(iloc.bh); 4933 brelse(iloc.bh);
4945 iomap_type = IOMAP_INLINE; 4934 iomap_type = IOMAP_INLINE;
4946 } else if (EXT4_I(inode)->i_file_acl) 4935 } else if (EXT4_I(inode)->i_file_acl) { /* external block */
4947 physical = (__u64)EXT4_I(inod 4936 physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits;
4948 length = inode->i_sb->s_block 4937 length = inode->i_sb->s_blocksize;
4949 iomap_type = IOMAP_MAPPED; 4938 iomap_type = IOMAP_MAPPED;
4950 } else { 4939 } else {
4951 /* no in-inode or external bl 4940 /* no in-inode or external block for xattr, so return -ENOENT */
4952 error = -ENOENT; 4941 error = -ENOENT;
4953 goto out; 4942 goto out;
4954 } 4943 }
4955 4944
4956 iomap->addr = physical; 4945 iomap->addr = physical;
4957 iomap->offset = 0; 4946 iomap->offset = 0;
4958 iomap->length = length; 4947 iomap->length = length;
4959 iomap->type = iomap_type; 4948 iomap->type = iomap_type;
4960 iomap->flags = 0; 4949 iomap->flags = 0;
4961 out: 4950 out:
4962 return error; 4951 return error;
4963 } 4952 }
4964 4953
4965 static int ext4_iomap_xattr_begin(struct inod 4954 static int ext4_iomap_xattr_begin(struct inode *inode, loff_t offset,
4966 loff_t leng 4955 loff_t length, unsigned flags,
4967 struct ioma 4956 struct iomap *iomap, struct iomap *srcmap)
4968 { 4957 {
4969 int error; 4958 int error;
4970 4959
4971 error = ext4_iomap_xattr_fiemap(inode 4960 error = ext4_iomap_xattr_fiemap(inode, iomap);
4972 if (error == 0 && (offset >= iomap->l 4961 if (error == 0 && (offset >= iomap->length))
4973 error = -ENOENT; 4962 error = -ENOENT;
4974 return error; 4963 return error;
4975 } 4964 }
4976 4965
4977 static const struct iomap_ops ext4_iomap_xatt 4966 static const struct iomap_ops ext4_iomap_xattr_ops = {
4978 .iomap_begin = ext4_iomap_ 4967 .iomap_begin = ext4_iomap_xattr_begin,
4979 }; 4968 };
4980 4969
4981 static int ext4_fiemap_check_ranges(struct in 4970 static int ext4_fiemap_check_ranges(struct inode *inode, u64 start, u64 *len)
4982 { 4971 {
4983 u64 maxbytes; 4972 u64 maxbytes;
4984 4973
4985 if (ext4_test_inode_flag(inode, EXT4_ 4974 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4986 maxbytes = inode->i_sb->s_max 4975 maxbytes = inode->i_sb->s_maxbytes;
4987 else 4976 else
4988 maxbytes = EXT4_SB(inode->i_s 4977 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
4989 4978
4990 if (*len == 0) 4979 if (*len == 0)
4991 return -EINVAL; 4980 return -EINVAL;
4992 if (start > maxbytes) 4981 if (start > maxbytes)
4993 return -EFBIG; 4982 return -EFBIG;
4994 4983
4995 /* 4984 /*
4996 * Shrink request scope to what the f 4985 * Shrink request scope to what the fs can actually handle.
4997 */ 4986 */
4998 if (*len > maxbytes || (maxbytes - *l 4987 if (*len > maxbytes || (maxbytes - *len) < start)
4999 *len = maxbytes - start; 4988 *len = maxbytes - start;
5000 return 0; 4989 return 0;
5001 } 4990 }
5002 4991
5003 int ext4_fiemap(struct inode *inode, struct f 4992 int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
5004 u64 start, u64 len) 4993 u64 start, u64 len)
5005 { 4994 {
5006 int error = 0; 4995 int error = 0;
5007 4996
5008 if (fieinfo->fi_flags & FIEMAP_FLAG_C 4997 if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {
5009 error = ext4_ext_precache(ino 4998 error = ext4_ext_precache(inode);
5010 if (error) 4999 if (error)
5011 return error; 5000 return error;
5012 fieinfo->fi_flags &= ~FIEMAP_ 5001 fieinfo->fi_flags &= ~FIEMAP_FLAG_CACHE;
5013 } 5002 }
5014 5003
5015 /* 5004 /*
5016 * For bitmap files the maximum size 5005 * For bitmap files the maximum size limit could be smaller than
5017 * s_maxbytes, so check len here manu 5006 * s_maxbytes, so check len here manually instead of just relying on the
5018 * generic check. 5007 * generic check.
5019 */ 5008 */
5020 error = ext4_fiemap_check_ranges(inod 5009 error = ext4_fiemap_check_ranges(inode, start, &len);
5021 if (error) 5010 if (error)
5022 return error; 5011 return error;
5023 5012
5024 if (fieinfo->fi_flags & FIEMAP_FLAG_X 5013 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
5025 fieinfo->fi_flags &= ~FIEMAP_ 5014 fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR;
5026 return iomap_fiemap(inode, fi 5015 return iomap_fiemap(inode, fieinfo, start, len,
5027 &ext4_iom 5016 &ext4_iomap_xattr_ops);
5028 } 5017 }
5029 5018
5030 return iomap_fiemap(inode, fieinfo, s 5019 return iomap_fiemap(inode, fieinfo, start, len, &ext4_iomap_report_ops);
5031 } 5020 }
5032 5021
5033 int ext4_get_es_cache(struct inode *inode, st 5022 int ext4_get_es_cache(struct inode *inode, struct fiemap_extent_info *fieinfo,
5034 __u64 start, __u64 len) 5023 __u64 start, __u64 len)
5035 { 5024 {
5036 ext4_lblk_t start_blk, len_blks; 5025 ext4_lblk_t start_blk, len_blks;
5037 __u64 last_blk; 5026 __u64 last_blk;
5038 int error = 0; 5027 int error = 0;
5039 5028
5040 if (ext4_has_inline_data(inode)) { 5029 if (ext4_has_inline_data(inode)) {
5041 int has_inline; 5030 int has_inline;
5042 5031
5043 down_read(&EXT4_I(inode)->xat 5032 down_read(&EXT4_I(inode)->xattr_sem);
5044 has_inline = ext4_has_inline_ 5033 has_inline = ext4_has_inline_data(inode);
5045 up_read(&EXT4_I(inode)->xattr 5034 up_read(&EXT4_I(inode)->xattr_sem);
5046 if (has_inline) 5035 if (has_inline)
5047 return 0; 5036 return 0;
5048 } 5037 }
5049 5038
5050 if (fieinfo->fi_flags & FIEMAP_FLAG_C 5039 if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {
5051 error = ext4_ext_precache(ino 5040 error = ext4_ext_precache(inode);
5052 if (error) 5041 if (error)
5053 return error; 5042 return error;
5054 fieinfo->fi_flags &= ~FIEMAP_ 5043 fieinfo->fi_flags &= ~FIEMAP_FLAG_CACHE;
5055 } 5044 }
5056 5045
5057 error = fiemap_prep(inode, fieinfo, s 5046 error = fiemap_prep(inode, fieinfo, start, &len, 0);
5058 if (error) 5047 if (error)
5059 return error; 5048 return error;
5060 5049
5061 error = ext4_fiemap_check_ranges(inod 5050 error = ext4_fiemap_check_ranges(inode, start, &len);
5062 if (error) 5051 if (error)
5063 return error; 5052 return error;
5064 5053
5065 start_blk = start >> inode->i_sb->s_b 5054 start_blk = start >> inode->i_sb->s_blocksize_bits;
5066 last_blk = (start + len - 1) >> inode 5055 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits;
5067 if (last_blk >= EXT_MAX_BLOCKS) 5056 if (last_blk >= EXT_MAX_BLOCKS)
5068 last_blk = EXT_MAX_BLOCKS-1; 5057 last_blk = EXT_MAX_BLOCKS-1;
5069 len_blks = ((ext4_lblk_t) last_blk) - 5058 len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1;
5070 5059
5071 /* 5060 /*
5072 * Walk the extent tree gathering ext 5061 * Walk the extent tree gathering extent information
5073 * and pushing extents back to the us 5062 * and pushing extents back to the user.
5074 */ 5063 */
5075 return ext4_fill_es_cache_info(inode, 5064 return ext4_fill_es_cache_info(inode, start_blk, len_blks, fieinfo);
5076 } 5065 }
5077 5066
5078 /* 5067 /*
5079 * ext4_ext_shift_path_extents: 5068 * ext4_ext_shift_path_extents:
5080 * Shift the extents of a path structure lyin 5069 * Shift the extents of a path structure lying between path[depth].p_ext
5081 * and EXT_LAST_EXTENT(path[depth].p_hdr), by 5070 * and EXT_LAST_EXTENT(path[depth].p_hdr), by @shift blocks. @SHIFT tells
5082 * if it is right shift or left shift operati 5071 * if it is right shift or left shift operation.
5083 */ 5072 */
5084 static int 5073 static int
5085 ext4_ext_shift_path_extents(struct ext4_ext_p 5074 ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift,
5086 struct inode *ino 5075 struct inode *inode, handle_t *handle,
5087 enum SHIFT_DIRECT 5076 enum SHIFT_DIRECTION SHIFT)
5088 { 5077 {
5089 int depth, err = 0; 5078 int depth, err = 0;
5090 struct ext4_extent *ex_start, *ex_las 5079 struct ext4_extent *ex_start, *ex_last;
5091 bool update = false; 5080 bool update = false;
5092 int credits, restart_credits; 5081 int credits, restart_credits;
5093 depth = path->p_depth; 5082 depth = path->p_depth;
5094 5083
5095 while (depth >= 0) { 5084 while (depth >= 0) {
5096 if (depth == path->p_depth) { 5085 if (depth == path->p_depth) {
5097 ex_start = path[depth 5086 ex_start = path[depth].p_ext;
5098 if (!ex_start) 5087 if (!ex_start)
5099 return -EFSCO 5088 return -EFSCORRUPTED;
5100 5089
5101 ex_last = EXT_LAST_EX 5090 ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);
5102 /* leaf + sb + inode 5091 /* leaf + sb + inode */
5103 credits = 3; 5092 credits = 3;
5104 if (ex_start == EXT_F 5093 if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr)) {
5105 update = true 5094 update = true;
5106 /* extent tre 5095 /* extent tree + sb + inode */
5107 credits = dep 5096 credits = depth + 2;
5108 } 5097 }
5109 5098
5110 restart_credits = ext 5099 restart_credits = ext4_writepage_trans_blocks(inode);
5111 err = ext4_datasem_en 5100 err = ext4_datasem_ensure_credits(handle, inode, credits,
5112 resta 5101 restart_credits, 0);
5113 if (err) { 5102 if (err) {
5114 if (err > 0) 5103 if (err > 0)
5115 err = 5104 err = -EAGAIN;
5116 goto out; 5105 goto out;
5117 } 5106 }
5118 5107
5119 err = ext4_ext_get_ac 5108 err = ext4_ext_get_access(handle, inode, path + depth);
5120 if (err) 5109 if (err)
5121 goto out; 5110 goto out;
5122 5111
5123 while (ex_start <= ex 5112 while (ex_start <= ex_last) {
5124 if (SHIFT == 5113 if (SHIFT == SHIFT_LEFT) {
5125 le32_ 5114 le32_add_cpu(&ex_start->ee_block,
5126 5115 -shift);
5127 /* Tr 5116 /* Try to merge to the left. */
5128 if (( 5117 if ((ex_start >
5129 E 5118 EXT_FIRST_EXTENT(path[depth].p_hdr))
5130 & 5119 &&
5131 e 5120 ext4_ext_try_to_merge_right(inode,
5132 p 5121 path, ex_start - 1))
5133 5122 ex_last--;
5134 else 5123 else
5135 5124 ex_start++;
5136 } else { 5125 } else {
5137 le32_ 5126 le32_add_cpu(&ex_last->ee_block, shift);
5138 ext4_ 5127 ext4_ext_try_to_merge_right(inode, path,
5139 5128 ex_last);
5140 ex_la 5129 ex_last--;
5141 } 5130 }
5142 } 5131 }
5143 err = ext4_ext_dirty( 5132 err = ext4_ext_dirty(handle, inode, path + depth);
5144 if (err) 5133 if (err)
5145 goto out; 5134 goto out;
5146 5135
5147 if (--depth < 0 || !u 5136 if (--depth < 0 || !update)
5148 break; 5137 break;
5149 } 5138 }
5150 5139
5151 /* Update index too */ 5140 /* Update index too */
5152 err = ext4_ext_get_access(han 5141 err = ext4_ext_get_access(handle, inode, path + depth);
5153 if (err) 5142 if (err)
5154 goto out; 5143 goto out;
5155 5144
5156 if (SHIFT == SHIFT_LEFT) 5145 if (SHIFT == SHIFT_LEFT)
5157 le32_add_cpu(&path[de 5146 le32_add_cpu(&path[depth].p_idx->ei_block, -shift);
5158 else 5147 else
5159 le32_add_cpu(&path[de 5148 le32_add_cpu(&path[depth].p_idx->ei_block, shift);
5160 err = ext4_ext_dirty(handle, 5149 err = ext4_ext_dirty(handle, inode, path + depth);
5161 if (err) 5150 if (err)
5162 goto out; 5151 goto out;
5163 5152
5164 /* we are done if current ind 5153 /* we are done if current index is not a starting index */
5165 if (path[depth].p_idx != EXT_ 5154 if (path[depth].p_idx != EXT_FIRST_INDEX(path[depth].p_hdr))
5166 break; 5155 break;
5167 5156
5168 depth--; 5157 depth--;
5169 } 5158 }
5170 5159
5171 out: 5160 out:
5172 return err; 5161 return err;
5173 } 5162 }
5174 5163
5175 /* 5164 /*
5176 * ext4_ext_shift_extents: 5165 * ext4_ext_shift_extents:
5177 * All the extents which lies in the range fr 5166 * All the extents which lies in the range from @start to the last allocated
5178 * block for the @inode are shifted either to 5167 * block for the @inode are shifted either towards left or right (depending
5179 * upon @SHIFT) by @shift blocks. 5168 * upon @SHIFT) by @shift blocks.
5180 * On success, 0 is returned, error otherwise 5169 * On success, 0 is returned, error otherwise.
5181 */ 5170 */
5182 static int 5171 static int
5183 ext4_ext_shift_extents(struct inode *inode, h 5172 ext4_ext_shift_extents(struct inode *inode, handle_t *handle,
5184 ext4_lblk_t start, ext 5173 ext4_lblk_t start, ext4_lblk_t shift,
5185 enum SHIFT_DIRECTION S 5174 enum SHIFT_DIRECTION SHIFT)
5186 { 5175 {
5187 struct ext4_ext_path *path; 5176 struct ext4_ext_path *path;
5188 int ret = 0, depth; 5177 int ret = 0, depth;
5189 struct ext4_extent *extent; 5178 struct ext4_extent *extent;
5190 ext4_lblk_t stop, *iterator, ex_start 5179 ext4_lblk_t stop, *iterator, ex_start, ex_end;
5191 ext4_lblk_t tmp = EXT_MAX_BLOCKS; 5180 ext4_lblk_t tmp = EXT_MAX_BLOCKS;
5192 5181
5193 /* Let path point to the last extent 5182 /* Let path point to the last extent */
5194 path = ext4_find_extent(inode, EXT_MA 5183 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
5195 EXT4_EX_NOCAC 5184 EXT4_EX_NOCACHE);
5196 if (IS_ERR(path)) 5185 if (IS_ERR(path))
5197 return PTR_ERR(path); 5186 return PTR_ERR(path);
5198 5187
5199 depth = path->p_depth; 5188 depth = path->p_depth;
5200 extent = path[depth].p_ext; 5189 extent = path[depth].p_ext;
5201 if (!extent) 5190 if (!extent)
5202 goto out; 5191 goto out;
5203 5192
5204 stop = le32_to_cpu(extent->ee_block); 5193 stop = le32_to_cpu(extent->ee_block);
5205 5194
5206 /* 5195 /*
5207 * For left shifts, make sure the hole 5196 * For left shifts, make sure the hole on the left is big enough to
5208 * accommodate the shift. For right s 5197 * accommodate the shift. For right shifts, make sure the last extent
5209 * won't be shifted beyond EXT_MAX_BLO 5198 * won't be shifted beyond EXT_MAX_BLOCKS.
5210 */ 5199 */
5211 if (SHIFT == SHIFT_LEFT) { 5200 if (SHIFT == SHIFT_LEFT) {
5212 path = ext4_find_extent(inode !! 5201 path = ext4_find_extent(inode, start - 1, &path,
5213 EXT4_ 5202 EXT4_EX_NOCACHE);
5214 if (IS_ERR(path)) 5203 if (IS_ERR(path))
5215 return PTR_ERR(path); 5204 return PTR_ERR(path);
5216 depth = path->p_depth; 5205 depth = path->p_depth;
5217 extent = path[depth].p_ext; 5206 extent = path[depth].p_ext;
5218 if (extent) { 5207 if (extent) {
5219 ex_start = le32_to_cp 5208 ex_start = le32_to_cpu(extent->ee_block);
5220 ex_end = le32_to_cpu( 5209 ex_end = le32_to_cpu(extent->ee_block) +
5221 ext4_ext_get_ 5210 ext4_ext_get_actual_len(extent);
5222 } else { 5211 } else {
5223 ex_start = 0; 5212 ex_start = 0;
5224 ex_end = 0; 5213 ex_end = 0;
5225 } 5214 }
5226 5215
5227 if ((start == ex_start && shi 5216 if ((start == ex_start && shift > ex_start) ||
5228 (shift > start - ex_end)) 5217 (shift > start - ex_end)) {
5229 ret = -EINVAL; 5218 ret = -EINVAL;
5230 goto out; 5219 goto out;
5231 } 5220 }
5232 } else { 5221 } else {
5233 if (shift > EXT_MAX_BLOCKS - 5222 if (shift > EXT_MAX_BLOCKS -
5234 (stop + ext4_ext_get_actu 5223 (stop + ext4_ext_get_actual_len(extent))) {
5235 ret = -EINVAL; 5224 ret = -EINVAL;
5236 goto out; 5225 goto out;
5237 } 5226 }
5238 } 5227 }
5239 5228
5240 /* 5229 /*
5241 * In case of left shift, iterator po 5230 * In case of left shift, iterator points to start and it is increased
5242 * till we reach stop. In case of rig 5231 * till we reach stop. In case of right shift, iterator points to stop
5243 * and it is decreased till we reach 5232 * and it is decreased till we reach start.
5244 */ 5233 */
5245 again: 5234 again:
5246 ret = 0; 5235 ret = 0;
5247 if (SHIFT == SHIFT_LEFT) 5236 if (SHIFT == SHIFT_LEFT)
5248 iterator = &start; 5237 iterator = &start;
5249 else 5238 else
5250 iterator = &stop; 5239 iterator = &stop;
5251 5240
5252 if (tmp != EXT_MAX_BLOCKS) 5241 if (tmp != EXT_MAX_BLOCKS)
5253 *iterator = tmp; 5242 *iterator = tmp;
5254 5243
5255 /* 5244 /*
5256 * Its safe to start updating extents 5245 * Its safe to start updating extents. Start and stop are unsigned, so
5257 * in case of right shift if extent w 5246 * in case of right shift if extent with 0 block is reached, iterator
5258 * becomes NULL to indicate the end o 5247 * becomes NULL to indicate the end of the loop.
5259 */ 5248 */
5260 while (iterator && start <= stop) { 5249 while (iterator && start <= stop) {
5261 path = ext4_find_extent(inode !! 5250 path = ext4_find_extent(inode, *iterator, &path,
5262 EXT4_ 5251 EXT4_EX_NOCACHE);
5263 if (IS_ERR(path)) 5252 if (IS_ERR(path))
5264 return PTR_ERR(path); 5253 return PTR_ERR(path);
5265 depth = path->p_depth; 5254 depth = path->p_depth;
5266 extent = path[depth].p_ext; 5255 extent = path[depth].p_ext;
5267 if (!extent) { 5256 if (!extent) {
5268 EXT4_ERROR_INODE(inod 5257 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
5269 (uns 5258 (unsigned long) *iterator);
5270 return -EFSCORRUPTED; 5259 return -EFSCORRUPTED;
5271 } 5260 }
5272 if (SHIFT == SHIFT_LEFT && *i 5261 if (SHIFT == SHIFT_LEFT && *iterator >
5273 le32_to_cpu(extent->ee_bl 5262 le32_to_cpu(extent->ee_block)) {
5274 /* Hole, move to the 5263 /* Hole, move to the next extent */
5275 if (extent < EXT_LAST 5264 if (extent < EXT_LAST_EXTENT(path[depth].p_hdr)) {
5276 path[depth].p 5265 path[depth].p_ext++;
5277 } else { 5266 } else {
5278 *iterator = e 5267 *iterator = ext4_ext_next_allocated_block(path);
5279 continue; 5268 continue;
5280 } 5269 }
5281 } 5270 }
5282 5271
5283 tmp = *iterator; 5272 tmp = *iterator;
5284 if (SHIFT == SHIFT_LEFT) { 5273 if (SHIFT == SHIFT_LEFT) {
5285 extent = EXT_LAST_EXT 5274 extent = EXT_LAST_EXTENT(path[depth].p_hdr);
5286 *iterator = le32_to_c 5275 *iterator = le32_to_cpu(extent->ee_block) +
5287 ext4_ 5276 ext4_ext_get_actual_len(extent);
5288 } else { 5277 } else {
5289 extent = EXT_FIRST_EX 5278 extent = EXT_FIRST_EXTENT(path[depth].p_hdr);
5290 if (le32_to_cpu(exten 5279 if (le32_to_cpu(extent->ee_block) > start)
5291 *iterator = l 5280 *iterator = le32_to_cpu(extent->ee_block) - 1;
5292 else if (le32_to_cpu( 5281 else if (le32_to_cpu(extent->ee_block) == start)
5293 iterator = NU 5282 iterator = NULL;
5294 else { 5283 else {
5295 extent = EXT_ 5284 extent = EXT_LAST_EXTENT(path[depth].p_hdr);
5296 while (le32_t 5285 while (le32_to_cpu(extent->ee_block) >= start)
5297 exten 5286 extent--;
5298 5287
5299 if (extent == 5288 if (extent == EXT_LAST_EXTENT(path[depth].p_hdr))
5300 break 5289 break;
5301 5290
5302 extent++; 5291 extent++;
5303 iterator = NU 5292 iterator = NULL;
5304 } 5293 }
5305 path[depth].p_ext = e 5294 path[depth].p_ext = extent;
5306 } 5295 }
5307 ret = ext4_ext_shift_path_ext 5296 ret = ext4_ext_shift_path_extents(path, shift, inode,
5308 handle, SHIFT 5297 handle, SHIFT);
5309 /* iterator can be NULL which 5298 /* iterator can be NULL which means we should break */
5310 if (ret == -EAGAIN) 5299 if (ret == -EAGAIN)
5311 goto again; 5300 goto again;
5312 if (ret) 5301 if (ret)
5313 break; 5302 break;
5314 } 5303 }
5315 out: 5304 out:
5316 ext4_free_ext_path(path); !! 5305 ext4_ext_drop_refs(path);
>> 5306 kfree(path);
5317 return ret; 5307 return ret;
5318 } 5308 }
5319 5309
5320 /* 5310 /*
5321 * ext4_collapse_range: 5311 * ext4_collapse_range:
5322 * This implements the fallocate's collapse r 5312 * This implements the fallocate's collapse range functionality for ext4
5323 * Returns: 0 and non-zero on error. 5313 * Returns: 0 and non-zero on error.
5324 */ 5314 */
5325 static int ext4_collapse_range(struct file *f 5315 static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len)
5326 { 5316 {
5327 struct inode *inode = file_inode(file 5317 struct inode *inode = file_inode(file);
5328 struct super_block *sb = inode->i_sb; 5318 struct super_block *sb = inode->i_sb;
5329 struct address_space *mapping = inode <<
5330 ext4_lblk_t punch_start, punch_stop; 5319 ext4_lblk_t punch_start, punch_stop;
5331 handle_t *handle; 5320 handle_t *handle;
5332 unsigned int credits; 5321 unsigned int credits;
5333 loff_t new_size, ioffset; 5322 loff_t new_size, ioffset;
5334 int ret; 5323 int ret;
5335 5324
5336 /* 5325 /*
5337 * We need to test this early because 5326 * We need to test this early because xfstests assumes that a
5338 * collapse range of (0, 1) will retu 5327 * collapse range of (0, 1) will return EOPNOTSUPP if the file
5339 * system does not support collapse r 5328 * system does not support collapse range.
5340 */ 5329 */
5341 if (!ext4_test_inode_flag(inode, EXT4 5330 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5342 return -EOPNOTSUPP; 5331 return -EOPNOTSUPP;
5343 5332
5344 /* Collapse range works only on fs cl 5333 /* Collapse range works only on fs cluster size aligned regions. */
5345 if (!IS_ALIGNED(offset | len, EXT4_CL 5334 if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))
5346 return -EINVAL; 5335 return -EINVAL;
5347 5336
5348 trace_ext4_collapse_range(inode, offs 5337 trace_ext4_collapse_range(inode, offset, len);
5349 5338
5350 punch_start = offset >> EXT4_BLOCK_SI 5339 punch_start = offset >> EXT4_BLOCK_SIZE_BITS(sb);
5351 punch_stop = (offset + len) >> EXT4_B 5340 punch_stop = (offset + len) >> EXT4_BLOCK_SIZE_BITS(sb);
5352 5341
>> 5342 /* Call ext4_force_commit to flush all data in case of data=journal. */
>> 5343 if (ext4_should_journal_data(inode)) {
>> 5344 ret = ext4_force_commit(inode->i_sb);
>> 5345 if (ret)
>> 5346 return ret;
>> 5347 }
>> 5348
5353 inode_lock(inode); 5349 inode_lock(inode);
5354 /* 5350 /*
5355 * There is no need to overlap collap 5351 * There is no need to overlap collapse range with EOF, in which case
5356 * it is effectively a truncate opera 5352 * it is effectively a truncate operation
5357 */ 5353 */
5358 if (offset + len >= inode->i_size) { 5354 if (offset + len >= inode->i_size) {
5359 ret = -EINVAL; 5355 ret = -EINVAL;
5360 goto out_mutex; 5356 goto out_mutex;
5361 } 5357 }
5362 5358
5363 /* Currently just for extent based fi 5359 /* Currently just for extent based files */
5364 if (!ext4_test_inode_flag(inode, EXT4 5360 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5365 ret = -EOPNOTSUPP; 5361 ret = -EOPNOTSUPP;
5366 goto out_mutex; 5362 goto out_mutex;
5367 } 5363 }
5368 5364
5369 /* Wait for existing dio to complete 5365 /* Wait for existing dio to complete */
5370 inode_dio_wait(inode); 5366 inode_dio_wait(inode);
5371 5367
5372 ret = file_modified(file); 5368 ret = file_modified(file);
5373 if (ret) 5369 if (ret)
5374 goto out_mutex; 5370 goto out_mutex;
5375 5371
5376 /* 5372 /*
5377 * Prevent page faults from reinstant 5373 * Prevent page faults from reinstantiating pages we have released from
5378 * page cache. 5374 * page cache.
5379 */ 5375 */
5380 filemap_invalidate_lock(mapping); !! 5376 down_write(&EXT4_I(inode)->i_mmap_sem);
5381 5377
5382 ret = ext4_break_layouts(inode); 5378 ret = ext4_break_layouts(inode);
5383 if (ret) 5379 if (ret)
5384 goto out_mmap; 5380 goto out_mmap;
5385 5381
5386 /* 5382 /*
5387 * Need to round down offset to be al 5383 * Need to round down offset to be aligned with page size boundary
5388 * for page size > block size. 5384 * for page size > block size.
5389 */ 5385 */
5390 ioffset = round_down(offset, PAGE_SIZ 5386 ioffset = round_down(offset, PAGE_SIZE);
5391 /* 5387 /*
5392 * Write tail of the last page before 5388 * Write tail of the last page before removed range since it will get
5393 * removed from the page cache below. 5389 * removed from the page cache below.
5394 */ 5390 */
5395 ret = filemap_write_and_wait_range(ma !! 5391 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset);
5396 if (ret) 5392 if (ret)
5397 goto out_mmap; 5393 goto out_mmap;
5398 /* 5394 /*
5399 * Write data that will be shifted to 5395 * Write data that will be shifted to preserve them when discarding
5400 * page cache below. We are also prot 5396 * page cache below. We are also protected from pages becoming dirty
5401 * by i_rwsem and invalidate_lock. !! 5397 * by i_mmap_sem.
5402 */ 5398 */
5403 ret = filemap_write_and_wait_range(ma !! 5399 ret = filemap_write_and_wait_range(inode->i_mapping, offset + len,
5404 LL 5400 LLONG_MAX);
5405 if (ret) 5401 if (ret)
5406 goto out_mmap; 5402 goto out_mmap;
5407 truncate_pagecache(inode, ioffset); 5403 truncate_pagecache(inode, ioffset);
5408 5404
5409 credits = ext4_writepage_trans_blocks 5405 credits = ext4_writepage_trans_blocks(inode);
5410 handle = ext4_journal_start(inode, EX 5406 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5411 if (IS_ERR(handle)) { 5407 if (IS_ERR(handle)) {
5412 ret = PTR_ERR(handle); 5408 ret = PTR_ERR(handle);
5413 goto out_mmap; 5409 goto out_mmap;
5414 } 5410 }
5415 ext4_fc_mark_ineligible(sb, EXT4_FC_R !! 5411 ext4_fc_start_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE);
5416 5412
5417 down_write(&EXT4_I(inode)->i_data_sem 5413 down_write(&EXT4_I(inode)->i_data_sem);
5418 ext4_discard_preallocations(inode); !! 5414 ext4_discard_preallocations(inode, 0);
5419 ext4_es_remove_extent(inode, punch_st !! 5415
>> 5416 ret = ext4_es_remove_extent(inode, punch_start,
>> 5417 EXT_MAX_BLOCKS - punch_start);
>> 5418 if (ret) {
>> 5419 up_write(&EXT4_I(inode)->i_data_sem);
>> 5420 goto out_stop;
>> 5421 }
5420 5422
5421 ret = ext4_ext_remove_space(inode, pu 5423 ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1);
5422 if (ret) { 5424 if (ret) {
5423 up_write(&EXT4_I(inode)->i_da 5425 up_write(&EXT4_I(inode)->i_data_sem);
5424 goto out_stop; 5426 goto out_stop;
5425 } 5427 }
5426 ext4_discard_preallocations(inode); !! 5428 ext4_discard_preallocations(inode, 0);
5427 5429
5428 ret = ext4_ext_shift_extents(inode, h 5430 ret = ext4_ext_shift_extents(inode, handle, punch_stop,
5429 punch_st 5431 punch_stop - punch_start, SHIFT_LEFT);
5430 if (ret) { 5432 if (ret) {
5431 up_write(&EXT4_I(inode)->i_da 5433 up_write(&EXT4_I(inode)->i_data_sem);
5432 goto out_stop; 5434 goto out_stop;
5433 } 5435 }
5434 5436
5435 new_size = inode->i_size - len; 5437 new_size = inode->i_size - len;
5436 i_size_write(inode, new_size); 5438 i_size_write(inode, new_size);
5437 EXT4_I(inode)->i_disksize = new_size; 5439 EXT4_I(inode)->i_disksize = new_size;
5438 5440
5439 up_write(&EXT4_I(inode)->i_data_sem); 5441 up_write(&EXT4_I(inode)->i_data_sem);
5440 if (IS_SYNC(inode)) 5442 if (IS_SYNC(inode))
5441 ext4_handle_sync(handle); 5443 ext4_handle_sync(handle);
5442 inode_set_mtime_to_ts(inode, inode_se !! 5444 inode->i_mtime = inode->i_ctime = current_time(inode);
5443 ret = ext4_mark_inode_dirty(handle, i 5445 ret = ext4_mark_inode_dirty(handle, inode);
5444 ext4_update_inode_fsync_trans(handle, 5446 ext4_update_inode_fsync_trans(handle, inode, 1);
5445 5447
5446 out_stop: 5448 out_stop:
5447 ext4_journal_stop(handle); 5449 ext4_journal_stop(handle);
>> 5450 ext4_fc_stop_ineligible(sb);
5448 out_mmap: 5451 out_mmap:
5449 filemap_invalidate_unlock(mapping); !! 5452 up_write(&EXT4_I(inode)->i_mmap_sem);
5450 out_mutex: 5453 out_mutex:
5451 inode_unlock(inode); 5454 inode_unlock(inode);
5452 return ret; 5455 return ret;
5453 } 5456 }
5454 5457
5455 /* 5458 /*
5456 * ext4_insert_range: 5459 * ext4_insert_range:
5457 * This function implements the FALLOC_FL_INS 5460 * This function implements the FALLOC_FL_INSERT_RANGE flag of fallocate.
5458 * The data blocks starting from @offset to t 5461 * The data blocks starting from @offset to the EOF are shifted by @len
5459 * towards right to create a hole in the @ino 5462 * towards right to create a hole in the @inode. Inode size is increased
5460 * by len bytes. 5463 * by len bytes.
5461 * Returns 0 on success, error otherwise. 5464 * Returns 0 on success, error otherwise.
5462 */ 5465 */
5463 static int ext4_insert_range(struct file *fil 5466 static int ext4_insert_range(struct file *file, loff_t offset, loff_t len)
5464 { 5467 {
5465 struct inode *inode = file_inode(file 5468 struct inode *inode = file_inode(file);
5466 struct super_block *sb = inode->i_sb; 5469 struct super_block *sb = inode->i_sb;
5467 struct address_space *mapping = inode <<
5468 handle_t *handle; 5470 handle_t *handle;
5469 struct ext4_ext_path *path; 5471 struct ext4_ext_path *path;
5470 struct ext4_extent *extent; 5472 struct ext4_extent *extent;
5471 ext4_lblk_t offset_lblk, len_lblk, ee 5473 ext4_lblk_t offset_lblk, len_lblk, ee_start_lblk = 0;
5472 unsigned int credits, ee_len; 5474 unsigned int credits, ee_len;
5473 int ret = 0, depth, split_flag = 0; 5475 int ret = 0, depth, split_flag = 0;
5474 loff_t ioffset; 5476 loff_t ioffset;
5475 5477
5476 /* 5478 /*
5477 * We need to test this early because 5479 * We need to test this early because xfstests assumes that an
5478 * insert range of (0, 1) will return 5480 * insert range of (0, 1) will return EOPNOTSUPP if the file
5479 * system does not support insert ran 5481 * system does not support insert range.
5480 */ 5482 */
5481 if (!ext4_test_inode_flag(inode, EXT4 5483 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5482 return -EOPNOTSUPP; 5484 return -EOPNOTSUPP;
5483 5485
5484 /* Insert range works only on fs clus 5486 /* Insert range works only on fs cluster size aligned regions. */
5485 if (!IS_ALIGNED(offset | len, EXT4_CL 5487 if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))
5486 return -EINVAL; 5488 return -EINVAL;
5487 5489
5488 trace_ext4_insert_range(inode, offset 5490 trace_ext4_insert_range(inode, offset, len);
5489 5491
5490 offset_lblk = offset >> EXT4_BLOCK_SI 5492 offset_lblk = offset >> EXT4_BLOCK_SIZE_BITS(sb);
5491 len_lblk = len >> EXT4_BLOCK_SIZE_BIT 5493 len_lblk = len >> EXT4_BLOCK_SIZE_BITS(sb);
5492 5494
>> 5495 /* Call ext4_force_commit to flush all data in case of data=journal */
>> 5496 if (ext4_should_journal_data(inode)) {
>> 5497 ret = ext4_force_commit(inode->i_sb);
>> 5498 if (ret)
>> 5499 return ret;
>> 5500 }
>> 5501
5493 inode_lock(inode); 5502 inode_lock(inode);
5494 /* Currently just for extent based fi 5503 /* Currently just for extent based files */
5495 if (!ext4_test_inode_flag(inode, EXT4 5504 if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
5496 ret = -EOPNOTSUPP; 5505 ret = -EOPNOTSUPP;
5497 goto out_mutex; 5506 goto out_mutex;
5498 } 5507 }
5499 5508
5500 /* Check whether the maximum file siz 5509 /* Check whether the maximum file size would be exceeded */
5501 if (len > inode->i_sb->s_maxbytes - i 5510 if (len > inode->i_sb->s_maxbytes - inode->i_size) {
5502 ret = -EFBIG; 5511 ret = -EFBIG;
5503 goto out_mutex; 5512 goto out_mutex;
5504 } 5513 }
5505 5514
5506 /* Offset must be less than i_size */ 5515 /* Offset must be less than i_size */
5507 if (offset >= inode->i_size) { 5516 if (offset >= inode->i_size) {
5508 ret = -EINVAL; 5517 ret = -EINVAL;
5509 goto out_mutex; 5518 goto out_mutex;
5510 } 5519 }
5511 5520
5512 /* Wait for existing dio to complete 5521 /* Wait for existing dio to complete */
5513 inode_dio_wait(inode); 5522 inode_dio_wait(inode);
5514 5523
5515 ret = file_modified(file); 5524 ret = file_modified(file);
5516 if (ret) 5525 if (ret)
5517 goto out_mutex; 5526 goto out_mutex;
5518 5527
5519 /* 5528 /*
5520 * Prevent page faults from reinstant 5529 * Prevent page faults from reinstantiating pages we have released from
5521 * page cache. 5530 * page cache.
5522 */ 5531 */
5523 filemap_invalidate_lock(mapping); !! 5532 down_write(&EXT4_I(inode)->i_mmap_sem);
5524 5533
5525 ret = ext4_break_layouts(inode); 5534 ret = ext4_break_layouts(inode);
5526 if (ret) 5535 if (ret)
5527 goto out_mmap; 5536 goto out_mmap;
5528 5537
5529 /* 5538 /*
5530 * Need to round down to align start 5539 * Need to round down to align start offset to page size boundary
5531 * for page size > block size. 5540 * for page size > block size.
5532 */ 5541 */
5533 ioffset = round_down(offset, PAGE_SIZ 5542 ioffset = round_down(offset, PAGE_SIZE);
5534 /* Write out all dirty pages */ 5543 /* Write out all dirty pages */
5535 ret = filemap_write_and_wait_range(in 5544 ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
5536 LLONG_MAX); 5545 LLONG_MAX);
5537 if (ret) 5546 if (ret)
5538 goto out_mmap; 5547 goto out_mmap;
5539 truncate_pagecache(inode, ioffset); 5548 truncate_pagecache(inode, ioffset);
5540 5549
5541 credits = ext4_writepage_trans_blocks 5550 credits = ext4_writepage_trans_blocks(inode);
5542 handle = ext4_journal_start(inode, EX 5551 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
5543 if (IS_ERR(handle)) { 5552 if (IS_ERR(handle)) {
5544 ret = PTR_ERR(handle); 5553 ret = PTR_ERR(handle);
5545 goto out_mmap; 5554 goto out_mmap;
5546 } 5555 }
5547 ext4_fc_mark_ineligible(sb, EXT4_FC_R !! 5556 ext4_fc_start_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE);
5548 5557
5549 /* Expand file to avoid data loss if 5558 /* Expand file to avoid data loss if there is error while shifting */
5550 inode->i_size += len; 5559 inode->i_size += len;
5551 EXT4_I(inode)->i_disksize += len; 5560 EXT4_I(inode)->i_disksize += len;
5552 inode_set_mtime_to_ts(inode, inode_se !! 5561 inode->i_mtime = inode->i_ctime = current_time(inode);
5553 ret = ext4_mark_inode_dirty(handle, i 5562 ret = ext4_mark_inode_dirty(handle, inode);
5554 if (ret) 5563 if (ret)
5555 goto out_stop; 5564 goto out_stop;
5556 5565
5557 down_write(&EXT4_I(inode)->i_data_sem 5566 down_write(&EXT4_I(inode)->i_data_sem);
5558 ext4_discard_preallocations(inode); !! 5567 ext4_discard_preallocations(inode, 0);
5559 5568
5560 path = ext4_find_extent(inode, offset 5569 path = ext4_find_extent(inode, offset_lblk, NULL, 0);
5561 if (IS_ERR(path)) { 5570 if (IS_ERR(path)) {
5562 up_write(&EXT4_I(inode)->i_da 5571 up_write(&EXT4_I(inode)->i_data_sem);
5563 ret = PTR_ERR(path); 5572 ret = PTR_ERR(path);
5564 goto out_stop; 5573 goto out_stop;
5565 } 5574 }
5566 5575
5567 depth = ext_depth(inode); 5576 depth = ext_depth(inode);
5568 extent = path[depth].p_ext; 5577 extent = path[depth].p_ext;
5569 if (extent) { 5578 if (extent) {
5570 ee_start_lblk = le32_to_cpu(e 5579 ee_start_lblk = le32_to_cpu(extent->ee_block);
5571 ee_len = ext4_ext_get_actual_ 5580 ee_len = ext4_ext_get_actual_len(extent);
5572 5581
5573 /* 5582 /*
5574 * If offset_lblk is not the 5583 * If offset_lblk is not the starting block of extent, split
5575 * the extent @offset_lblk 5584 * the extent @offset_lblk
5576 */ 5585 */
5577 if ((offset_lblk > ee_start_l 5586 if ((offset_lblk > ee_start_lblk) &&
5578 (offset_lblk 5587 (offset_lblk < (ee_start_lblk + ee_len))) {
5579 if (ext4_ext_is_unwri 5588 if (ext4_ext_is_unwritten(extent))
5580 split_flag = 5589 split_flag = EXT4_EXT_MARK_UNWRIT1 |
5581 EXT4_ 5590 EXT4_EXT_MARK_UNWRIT2;
5582 path = ext4_split_ext !! 5591 ret = ext4_split_extent_at(handle, inode, &path,
5583 offse 5592 offset_lblk, split_flag,
5584 EXT4_ 5593 EXT4_EX_NOCACHE |
5585 EXT4_ 5594 EXT4_GET_BLOCKS_PRE_IO |
5586 EXT4_ 5595 EXT4_GET_BLOCKS_METADATA_NOFAIL);
5587 } 5596 }
5588 5597
5589 if (IS_ERR(path)) { !! 5598 ext4_ext_drop_refs(path);
>> 5599 kfree(path);
>> 5600 if (ret < 0) {
5590 up_write(&EXT4_I(inod 5601 up_write(&EXT4_I(inode)->i_data_sem);
5591 ret = PTR_ERR(path); <<
5592 goto out_stop; 5602 goto out_stop;
5593 } 5603 }
>> 5604 } else {
>> 5605 ext4_ext_drop_refs(path);
>> 5606 kfree(path);
5594 } 5607 }
5595 5608
5596 ext4_free_ext_path(path); !! 5609 ret = ext4_es_remove_extent(inode, offset_lblk,
5597 ext4_es_remove_extent(inode, offset_l !! 5610 EXT_MAX_BLOCKS - offset_lblk);
>> 5611 if (ret) {
>> 5612 up_write(&EXT4_I(inode)->i_data_sem);
>> 5613 goto out_stop;
>> 5614 }
5598 5615
5599 /* 5616 /*
5600 * if offset_lblk lies in a hole whic 5617 * if offset_lblk lies in a hole which is at start of file, use
5601 * ee_start_lblk to shift extents 5618 * ee_start_lblk to shift extents
5602 */ 5619 */
5603 ret = ext4_ext_shift_extents(inode, h 5620 ret = ext4_ext_shift_extents(inode, handle,
5604 max(ee_start_lblk, offset_lbl !! 5621 ee_start_lblk > offset_lblk ? ee_start_lblk : offset_lblk,
>> 5622 len_lblk, SHIFT_RIGHT);
5605 5623
5606 up_write(&EXT4_I(inode)->i_data_sem); 5624 up_write(&EXT4_I(inode)->i_data_sem);
5607 if (IS_SYNC(inode)) 5625 if (IS_SYNC(inode))
5608 ext4_handle_sync(handle); 5626 ext4_handle_sync(handle);
5609 if (ret >= 0) 5627 if (ret >= 0)
5610 ext4_update_inode_fsync_trans 5628 ext4_update_inode_fsync_trans(handle, inode, 1);
5611 5629
5612 out_stop: 5630 out_stop:
5613 ext4_journal_stop(handle); 5631 ext4_journal_stop(handle);
>> 5632 ext4_fc_stop_ineligible(sb);
5614 out_mmap: 5633 out_mmap:
5615 filemap_invalidate_unlock(mapping); !! 5634 up_write(&EXT4_I(inode)->i_mmap_sem);
5616 out_mutex: 5635 out_mutex:
5617 inode_unlock(inode); 5636 inode_unlock(inode);
5618 return ret; 5637 return ret;
5619 } 5638 }
5620 5639
5621 /** 5640 /**
5622 * ext4_swap_extents() - Swap extents between 5641 * ext4_swap_extents() - Swap extents between two inodes
5623 * @handle: handle for this transaction 5642 * @handle: handle for this transaction
5624 * @inode1: First inode 5643 * @inode1: First inode
5625 * @inode2: Second inode 5644 * @inode2: Second inode
5626 * @lblk1: Start block for first inode 5645 * @lblk1: Start block for first inode
5627 * @lblk2: Start block for second inode 5646 * @lblk2: Start block for second inode
5628 * @count: Number of blocks to swap 5647 * @count: Number of blocks to swap
5629 * @unwritten: Mark second inode's extents as 5648 * @unwritten: Mark second inode's extents as unwritten after swap
5630 * @erp: Pointer to save error value 5649 * @erp: Pointer to save error value
5631 * 5650 *
5632 * This helper routine does exactly what is p 5651 * This helper routine does exactly what is promise "swap extents". All other
5633 * stuff such as page-cache locking consisten 5652 * stuff such as page-cache locking consistency, bh mapping consistency or
5634 * extent's data copying must be performed by 5653 * extent's data copying must be performed by caller.
5635 * Locking: 5654 * Locking:
5636 * i_rwsem is held for both inod !! 5655 * i_mutex is held for both inodes
5637 * i_data_sem is locked for writ 5656 * i_data_sem is locked for write for both inodes
5638 * Assumptions: 5657 * Assumptions:
5639 * All pages from requested rang 5658 * All pages from requested range are locked for both inodes
5640 */ 5659 */
5641 int 5660 int
5642 ext4_swap_extents(handle_t *handle, struct in 5661 ext4_swap_extents(handle_t *handle, struct inode *inode1,
5643 struct inode *inode2, ext4_ 5662 struct inode *inode2, ext4_lblk_t lblk1, ext4_lblk_t lblk2,
5644 ext4_lblk_t count, int unwr 5663 ext4_lblk_t count, int unwritten, int *erp)
5645 { 5664 {
5646 struct ext4_ext_path *path1 = NULL; 5665 struct ext4_ext_path *path1 = NULL;
5647 struct ext4_ext_path *path2 = NULL; 5666 struct ext4_ext_path *path2 = NULL;
5648 int replaced_count = 0; 5667 int replaced_count = 0;
5649 5668
5650 BUG_ON(!rwsem_is_locked(&EXT4_I(inode 5669 BUG_ON(!rwsem_is_locked(&EXT4_I(inode1)->i_data_sem));
5651 BUG_ON(!rwsem_is_locked(&EXT4_I(inode 5670 BUG_ON(!rwsem_is_locked(&EXT4_I(inode2)->i_data_sem));
5652 BUG_ON(!inode_is_locked(inode1)); 5671 BUG_ON(!inode_is_locked(inode1));
5653 BUG_ON(!inode_is_locked(inode2)); 5672 BUG_ON(!inode_is_locked(inode2));
5654 5673
5655 ext4_es_remove_extent(inode1, lblk1, !! 5674 *erp = ext4_es_remove_extent(inode1, lblk1, count);
5656 ext4_es_remove_extent(inode2, lblk2, !! 5675 if (unlikely(*erp))
>> 5676 return 0;
>> 5677 *erp = ext4_es_remove_extent(inode2, lblk2, count);
>> 5678 if (unlikely(*erp))
>> 5679 return 0;
5657 5680
5658 while (count) { 5681 while (count) {
5659 struct ext4_extent *ex1, *ex2 5682 struct ext4_extent *ex1, *ex2, tmp_ex;
5660 ext4_lblk_t e1_blk, e2_blk; 5683 ext4_lblk_t e1_blk, e2_blk;
5661 int e1_len, e2_len, len; 5684 int e1_len, e2_len, len;
5662 int split = 0; 5685 int split = 0;
5663 5686
5664 path1 = ext4_find_extent(inod !! 5687 path1 = ext4_find_extent(inode1, lblk1, NULL, EXT4_EX_NOCACHE);
5665 if (IS_ERR(path1)) { 5688 if (IS_ERR(path1)) {
5666 *erp = PTR_ERR(path1) 5689 *erp = PTR_ERR(path1);
5667 goto errout; !! 5690 path1 = NULL;
>> 5691 finish:
>> 5692 count = 0;
>> 5693 goto repeat;
5668 } 5694 }
5669 path2 = ext4_find_extent(inod !! 5695 path2 = ext4_find_extent(inode2, lblk2, NULL, EXT4_EX_NOCACHE);
5670 if (IS_ERR(path2)) { 5696 if (IS_ERR(path2)) {
5671 *erp = PTR_ERR(path2) 5697 *erp = PTR_ERR(path2);
5672 goto errout; !! 5698 path2 = NULL;
>> 5699 goto finish;
5673 } 5700 }
5674 ex1 = path1[path1->p_depth].p 5701 ex1 = path1[path1->p_depth].p_ext;
5675 ex2 = path2[path2->p_depth].p 5702 ex2 = path2[path2->p_depth].p_ext;
5676 /* Do we have something to sw 5703 /* Do we have something to swap ? */
5677 if (unlikely(!ex2 || !ex1)) 5704 if (unlikely(!ex2 || !ex1))
5678 goto errout; !! 5705 goto finish;
5679 5706
5680 e1_blk = le32_to_cpu(ex1->ee_ 5707 e1_blk = le32_to_cpu(ex1->ee_block);
5681 e2_blk = le32_to_cpu(ex2->ee_ 5708 e2_blk = le32_to_cpu(ex2->ee_block);
5682 e1_len = ext4_ext_get_actual_ 5709 e1_len = ext4_ext_get_actual_len(ex1);
5683 e2_len = ext4_ext_get_actual_ 5710 e2_len = ext4_ext_get_actual_len(ex2);
5684 5711
5685 /* Hole handling */ 5712 /* Hole handling */
5686 if (!in_range(lblk1, e1_blk, 5713 if (!in_range(lblk1, e1_blk, e1_len) ||
5687 !in_range(lblk2, e2_blk, 5714 !in_range(lblk2, e2_blk, e2_len)) {
5688 ext4_lblk_t next1, ne 5715 ext4_lblk_t next1, next2;
5689 5716
5690 /* if hole after exte 5717 /* if hole after extent, then go to next extent */
5691 next1 = ext4_ext_next 5718 next1 = ext4_ext_next_allocated_block(path1);
5692 next2 = ext4_ext_next 5719 next2 = ext4_ext_next_allocated_block(path2);
5693 /* If hole before ext 5720 /* If hole before extent, then shift to that extent */
5694 if (e1_blk > lblk1) 5721 if (e1_blk > lblk1)
5695 next1 = e1_bl 5722 next1 = e1_blk;
5696 if (e2_blk > lblk2) 5723 if (e2_blk > lblk2)
5697 next2 = e2_bl 5724 next2 = e2_blk;
5698 /* Do we have somethi 5725 /* Do we have something to swap */
5699 if (next1 == EXT_MAX_ 5726 if (next1 == EXT_MAX_BLOCKS || next2 == EXT_MAX_BLOCKS)
5700 goto errout; !! 5727 goto finish;
5701 /* Move to the righte 5728 /* Move to the rightest boundary */
5702 len = next1 - lblk1; 5729 len = next1 - lblk1;
5703 if (len < next2 - lbl 5730 if (len < next2 - lblk2)
5704 len = next2 - 5731 len = next2 - lblk2;
5705 if (len > count) 5732 if (len > count)
5706 len = count; 5733 len = count;
5707 lblk1 += len; 5734 lblk1 += len;
5708 lblk2 += len; 5735 lblk2 += len;
5709 count -= len; 5736 count -= len;
5710 continue; !! 5737 goto repeat;
5711 } 5738 }
5712 5739
5713 /* Prepare left boundary */ 5740 /* Prepare left boundary */
5714 if (e1_blk < lblk1) { 5741 if (e1_blk < lblk1) {
5715 split = 1; 5742 split = 1;
5716 path1 = ext4_force_sp !! 5743 *erp = ext4_force_split_extent_at(handle, inode1,
5717 !! 5744 &path1, lblk1, 0);
5718 if (IS_ERR(path1)) { !! 5745 if (unlikely(*erp))
5719 *erp = PTR_ER !! 5746 goto finish;
5720 goto errout; <<
5721 } <<
5722 } 5747 }
5723 if (e2_blk < lblk2) { 5748 if (e2_blk < lblk2) {
5724 split = 1; 5749 split = 1;
5725 path2 = ext4_force_sp !! 5750 *erp = ext4_force_split_extent_at(handle, inode2,
5726 !! 5751 &path2, lblk2, 0);
5727 if (IS_ERR(path2)) { !! 5752 if (unlikely(*erp))
5728 *erp = PTR_ER !! 5753 goto finish;
5729 goto errout; <<
5730 } <<
5731 } 5754 }
5732 /* ext4_split_extent_at() may 5755 /* ext4_split_extent_at() may result in leaf extent split,
5733 * path must to be revalidate 5756 * path must to be revalidated. */
5734 if (split) 5757 if (split)
5735 continue; !! 5758 goto repeat;
5736 5759
5737 /* Prepare right boundary */ 5760 /* Prepare right boundary */
5738 len = count; 5761 len = count;
5739 if (len > e1_blk + e1_len - l 5762 if (len > e1_blk + e1_len - lblk1)
5740 len = e1_blk + e1_len 5763 len = e1_blk + e1_len - lblk1;
5741 if (len > e2_blk + e2_len - l 5764 if (len > e2_blk + e2_len - lblk2)
5742 len = e2_blk + e2_len 5765 len = e2_blk + e2_len - lblk2;
5743 5766
5744 if (len != e1_len) { 5767 if (len != e1_len) {
5745 split = 1; 5768 split = 1;
5746 path1 = ext4_force_sp !! 5769 *erp = ext4_force_split_extent_at(handle, inode1,
5747 !! 5770 &path1, lblk1 + len, 0);
5748 if (IS_ERR(path1)) { !! 5771 if (unlikely(*erp))
5749 *erp = PTR_ER !! 5772 goto finish;
5750 goto errout; <<
5751 } <<
5752 } 5773 }
5753 if (len != e2_len) { 5774 if (len != e2_len) {
5754 split = 1; 5775 split = 1;
5755 path2 = ext4_force_sp !! 5776 *erp = ext4_force_split_extent_at(handle, inode2,
5756 !! 5777 &path2, lblk2 + len, 0);
5757 if (IS_ERR(path2)) { !! 5778 if (*erp)
5758 *erp = PTR_ER !! 5779 goto finish;
5759 goto errout; <<
5760 } <<
5761 } 5780 }
5762 /* ext4_split_extent_at() may 5781 /* ext4_split_extent_at() may result in leaf extent split,
5763 * path must to be revalidate 5782 * path must to be revalidated. */
5764 if (split) 5783 if (split)
5765 continue; !! 5784 goto repeat;
5766 5785
5767 BUG_ON(e2_len != e1_len); 5786 BUG_ON(e2_len != e1_len);
5768 *erp = ext4_ext_get_access(ha 5787 *erp = ext4_ext_get_access(handle, inode1, path1 + path1->p_depth);
5769 if (unlikely(*erp)) 5788 if (unlikely(*erp))
5770 goto errout; !! 5789 goto finish;
5771 *erp = ext4_ext_get_access(ha 5790 *erp = ext4_ext_get_access(handle, inode2, path2 + path2->p_depth);
5772 if (unlikely(*erp)) 5791 if (unlikely(*erp))
5773 goto errout; !! 5792 goto finish;
5774 5793
5775 /* Both extents are fully ins 5794 /* Both extents are fully inside boundaries. Swap it now */
5776 tmp_ex = *ex1; 5795 tmp_ex = *ex1;
5777 ext4_ext_store_pblock(ex1, ex 5796 ext4_ext_store_pblock(ex1, ext4_ext_pblock(ex2));
5778 ext4_ext_store_pblock(ex2, ex 5797 ext4_ext_store_pblock(ex2, ext4_ext_pblock(&tmp_ex));
5779 ex1->ee_len = cpu_to_le16(e2_ 5798 ex1->ee_len = cpu_to_le16(e2_len);
5780 ex2->ee_len = cpu_to_le16(e1_ 5799 ex2->ee_len = cpu_to_le16(e1_len);
5781 if (unwritten) 5800 if (unwritten)
5782 ext4_ext_mark_unwritt 5801 ext4_ext_mark_unwritten(ex2);
5783 if (ext4_ext_is_unwritten(&tm 5802 if (ext4_ext_is_unwritten(&tmp_ex))
5784 ext4_ext_mark_unwritt 5803 ext4_ext_mark_unwritten(ex1);
5785 5804
5786 ext4_ext_try_to_merge(handle, 5805 ext4_ext_try_to_merge(handle, inode2, path2, ex2);
5787 ext4_ext_try_to_merge(handle, 5806 ext4_ext_try_to_merge(handle, inode1, path1, ex1);
5788 *erp = ext4_ext_dirty(handle, 5807 *erp = ext4_ext_dirty(handle, inode2, path2 +
5789 path2-> 5808 path2->p_depth);
5790 if (unlikely(*erp)) 5809 if (unlikely(*erp))
5791 goto errout; !! 5810 goto finish;
5792 *erp = ext4_ext_dirty(handle, 5811 *erp = ext4_ext_dirty(handle, inode1, path1 +
5793 path1-> 5812 path1->p_depth);
5794 /* 5813 /*
5795 * Looks scarry ah..? second 5814 * Looks scarry ah..? second inode already points to new blocks,
5796 * and it was successfully di 5815 * and it was successfully dirtied. But luckily error may happen
5797 * only due to journal error, 5816 * only due to journal error, so full transaction will be
5798 * aborted anyway. 5817 * aborted anyway.
5799 */ 5818 */
5800 if (unlikely(*erp)) 5819 if (unlikely(*erp))
5801 goto errout; !! 5820 goto finish;
5802 <<
5803 lblk1 += len; 5821 lblk1 += len;
5804 lblk2 += len; 5822 lblk2 += len;
5805 replaced_count += len; 5823 replaced_count += len;
5806 count -= len; 5824 count -= len;
5807 } <<
5808 5825
5809 errout: !! 5826 repeat:
5810 ext4_free_ext_path(path1); !! 5827 ext4_ext_drop_refs(path1);
5811 ext4_free_ext_path(path2); !! 5828 kfree(path1);
>> 5829 ext4_ext_drop_refs(path2);
>> 5830 kfree(path2);
>> 5831 path1 = path2 = NULL;
>> 5832 }
5812 return replaced_count; 5833 return replaced_count;
5813 } 5834 }
5814 5835
5815 /* 5836 /*
5816 * ext4_clu_mapped - determine whether any bl 5837 * ext4_clu_mapped - determine whether any block in a logical cluster has
5817 * been mapped to a physica 5838 * been mapped to a physical cluster
5818 * 5839 *
5819 * @inode - file containing the logical clust 5840 * @inode - file containing the logical cluster
5820 * @lclu - logical cluster of interest 5841 * @lclu - logical cluster of interest
5821 * 5842 *
5822 * Returns 1 if any block in the logical clus 5843 * Returns 1 if any block in the logical cluster is mapped, signifying
5823 * that a physical cluster has been allocated 5844 * that a physical cluster has been allocated for it. Otherwise,
5824 * returns 0. Can also return negative error 5845 * returns 0. Can also return negative error codes. Derived from
5825 * ext4_ext_map_blocks(). 5846 * ext4_ext_map_blocks().
5826 */ 5847 */
5827 int ext4_clu_mapped(struct inode *inode, ext4 5848 int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu)
5828 { 5849 {
5829 struct ext4_sb_info *sbi = EXT4_SB(in 5850 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5830 struct ext4_ext_path *path; 5851 struct ext4_ext_path *path;
5831 int depth, mapped = 0, err = 0; 5852 int depth, mapped = 0, err = 0;
5832 struct ext4_extent *extent; 5853 struct ext4_extent *extent;
5833 ext4_lblk_t first_lblk, first_lclu, l 5854 ext4_lblk_t first_lblk, first_lclu, last_lclu;
5834 5855
5835 /* 5856 /*
5836 * if data can be stored inline, the 5857 * if data can be stored inline, the logical cluster isn't
5837 * mapped - no physical clusters have 5858 * mapped - no physical clusters have been allocated, and the
5838 * file has no extents 5859 * file has no extents
5839 */ 5860 */
5840 if (ext4_test_inode_state(inode, EXT4 5861 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) ||
5841 ext4_has_inline_data(inode)) 5862 ext4_has_inline_data(inode))
5842 return 0; 5863 return 0;
5843 5864
5844 /* search for the extent closest to t 5865 /* search for the extent closest to the first block in the cluster */
5845 path = ext4_find_extent(inode, EXT4_C 5866 path = ext4_find_extent(inode, EXT4_C2B(sbi, lclu), NULL, 0);
5846 if (IS_ERR(path)) !! 5867 if (IS_ERR(path)) {
5847 return PTR_ERR(path); !! 5868 err = PTR_ERR(path);
>> 5869 path = NULL;
>> 5870 goto out;
>> 5871 }
5848 5872
5849 depth = ext_depth(inode); 5873 depth = ext_depth(inode);
5850 5874
5851 /* 5875 /*
5852 * A consistent leaf must not be empt 5876 * A consistent leaf must not be empty. This situation is possible,
5853 * though, _during_ tree modification 5877 * though, _during_ tree modification, and it's why an assert can't
5854 * be put in ext4_find_extent(). 5878 * be put in ext4_find_extent().
5855 */ 5879 */
5856 if (unlikely(path[depth].p_ext == NUL 5880 if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
5857 EXT4_ERROR_INODE(inode, 5881 EXT4_ERROR_INODE(inode,
5858 "bad extent address - lbl 5882 "bad extent address - lblock: %lu, depth: %d, pblock: %lld",
5859 (unsigned lo 5883 (unsigned long) EXT4_C2B(sbi, lclu),
5860 depth, path[ 5884 depth, path[depth].p_block);
5861 err = -EFSCORRUPTED; 5885 err = -EFSCORRUPTED;
5862 goto out; 5886 goto out;
5863 } 5887 }
5864 5888
5865 extent = path[depth].p_ext; 5889 extent = path[depth].p_ext;
5866 5890
5867 /* can't be mapped if the extent tree 5891 /* can't be mapped if the extent tree is empty */
5868 if (extent == NULL) 5892 if (extent == NULL)
5869 goto out; 5893 goto out;
5870 5894
5871 first_lblk = le32_to_cpu(extent->ee_b 5895 first_lblk = le32_to_cpu(extent->ee_block);
5872 first_lclu = EXT4_B2C(sbi, first_lblk 5896 first_lclu = EXT4_B2C(sbi, first_lblk);
5873 5897
5874 /* 5898 /*
5875 * Three possible outcomes at this po 5899 * Three possible outcomes at this point - found extent spanning
5876 * the target cluster, to the left of 5900 * the target cluster, to the left of the target cluster, or to the
5877 * right of the target cluster. The 5901 * right of the target cluster. The first two cases are handled here.
5878 * The last case indicates the target 5902 * The last case indicates the target cluster is not mapped.
5879 */ 5903 */
5880 if (lclu >= first_lclu) { 5904 if (lclu >= first_lclu) {
5881 last_lclu = EXT4_B2C(sbi, fir 5905 last_lclu = EXT4_B2C(sbi, first_lblk +
5882 ext4_ext 5906 ext4_ext_get_actual_len(extent) - 1);
5883 if (lclu <= last_lclu) { 5907 if (lclu <= last_lclu) {
5884 mapped = 1; 5908 mapped = 1;
5885 } else { 5909 } else {
5886 first_lblk = ext4_ext 5910 first_lblk = ext4_ext_next_allocated_block(path);
5887 first_lclu = EXT4_B2C 5911 first_lclu = EXT4_B2C(sbi, first_lblk);
5888 if (lclu == first_lcl 5912 if (lclu == first_lclu)
5889 mapped = 1; 5913 mapped = 1;
5890 } 5914 }
5891 } 5915 }
5892 5916
5893 out: 5917 out:
5894 ext4_free_ext_path(path); !! 5918 ext4_ext_drop_refs(path);
>> 5919 kfree(path);
5895 5920
5896 return err ? err : mapped; 5921 return err ? err : mapped;
5897 } 5922 }
5898 5923
5899 /* 5924 /*
5900 * Updates physical block address and unwritt 5925 * Updates physical block address and unwritten status of extent
5901 * starting at lblk start and of len. If such 5926 * starting at lblk start and of len. If such an extent doesn't exist,
5902 * this function splits the extent tree appro 5927 * this function splits the extent tree appropriately to create an
5903 * extent like this. This function is called 5928 * extent like this. This function is called in the fast commit
5904 * replay path. Returns 0 on success and err 5929 * replay path. Returns 0 on success and error on failure.
5905 */ 5930 */
5906 int ext4_ext_replay_update_ex(struct inode *i 5931 int ext4_ext_replay_update_ex(struct inode *inode, ext4_lblk_t start,
5907 int len, int un 5932 int len, int unwritten, ext4_fsblk_t pblk)
5908 { 5933 {
5909 struct ext4_ext_path *path; 5934 struct ext4_ext_path *path;
5910 struct ext4_extent *ex; 5935 struct ext4_extent *ex;
5911 int ret; 5936 int ret;
5912 5937
5913 path = ext4_find_extent(inode, start, 5938 path = ext4_find_extent(inode, start, NULL, 0);
5914 if (IS_ERR(path)) 5939 if (IS_ERR(path))
5915 return PTR_ERR(path); 5940 return PTR_ERR(path);
5916 ex = path[path->p_depth].p_ext; 5941 ex = path[path->p_depth].p_ext;
5917 if (!ex) { 5942 if (!ex) {
5918 ret = -EFSCORRUPTED; 5943 ret = -EFSCORRUPTED;
5919 goto out; 5944 goto out;
5920 } 5945 }
5921 5946
5922 if (le32_to_cpu(ex->ee_block) != star 5947 if (le32_to_cpu(ex->ee_block) != start ||
5923 ext4_ext_get_actual_len(ex) ! 5948 ext4_ext_get_actual_len(ex) != len) {
5924 /* We need to split this exte 5949 /* We need to split this extent to match our extent first */
5925 down_write(&EXT4_I(inode)->i_ 5950 down_write(&EXT4_I(inode)->i_data_sem);
5926 path = ext4_force_split_exten !! 5951 ret = ext4_force_split_extent_at(NULL, inode, &path, start, 1);
5927 up_write(&EXT4_I(inode)->i_da 5952 up_write(&EXT4_I(inode)->i_data_sem);
5928 if (IS_ERR(path)) { !! 5953 if (ret)
5929 ret = PTR_ERR(path); <<
5930 goto out; 5954 goto out;
5931 } <<
5932 5955
5933 path = ext4_find_extent(inode !! 5956 path = ext4_find_extent(inode, start, &path, 0);
5934 if (IS_ERR(path)) 5957 if (IS_ERR(path))
5935 return PTR_ERR(path); 5958 return PTR_ERR(path);
5936 <<
5937 ex = path[path->p_depth].p_ex 5959 ex = path[path->p_depth].p_ext;
5938 WARN_ON(le32_to_cpu(ex->ee_bl 5960 WARN_ON(le32_to_cpu(ex->ee_block) != start);
5939 5961
5940 if (ext4_ext_get_actual_len(e 5962 if (ext4_ext_get_actual_len(ex) != len) {
5941 down_write(&EXT4_I(in 5963 down_write(&EXT4_I(inode)->i_data_sem);
5942 path = ext4_force_spl !! 5964 ret = ext4_force_split_extent_at(NULL, inode, &path,
5943 !! 5965 start + len, 1);
5944 up_write(&EXT4_I(inod 5966 up_write(&EXT4_I(inode)->i_data_sem);
5945 if (IS_ERR(path)) { !! 5967 if (ret)
5946 ret = PTR_ERR <<
5947 goto out; 5968 goto out;
5948 } <<
5949 5969
5950 path = ext4_find_exte !! 5970 path = ext4_find_extent(inode, start, &path, 0);
5951 if (IS_ERR(path)) 5971 if (IS_ERR(path))
5952 return PTR_ER 5972 return PTR_ERR(path);
5953 ex = path[path->p_dep 5973 ex = path[path->p_depth].p_ext;
5954 } 5974 }
5955 } 5975 }
5956 if (unwritten) 5976 if (unwritten)
5957 ext4_ext_mark_unwritten(ex); 5977 ext4_ext_mark_unwritten(ex);
5958 else 5978 else
5959 ext4_ext_mark_initialized(ex) 5979 ext4_ext_mark_initialized(ex);
5960 ext4_ext_store_pblock(ex, pblk); 5980 ext4_ext_store_pblock(ex, pblk);
5961 down_write(&EXT4_I(inode)->i_data_sem 5981 down_write(&EXT4_I(inode)->i_data_sem);
5962 ret = ext4_ext_dirty(NULL, inode, &pa 5982 ret = ext4_ext_dirty(NULL, inode, &path[path->p_depth]);
5963 up_write(&EXT4_I(inode)->i_data_sem); 5983 up_write(&EXT4_I(inode)->i_data_sem);
5964 out: 5984 out:
5965 ext4_free_ext_path(path); !! 5985 ext4_ext_drop_refs(path);
>> 5986 kfree(path);
5966 ext4_mark_inode_dirty(NULL, inode); 5987 ext4_mark_inode_dirty(NULL, inode);
5967 return ret; 5988 return ret;
5968 } 5989 }
5969 5990
5970 /* Try to shrink the extent tree */ 5991 /* Try to shrink the extent tree */
5971 void ext4_ext_replay_shrink_inode(struct inod 5992 void ext4_ext_replay_shrink_inode(struct inode *inode, ext4_lblk_t end)
5972 { 5993 {
5973 struct ext4_ext_path *path = NULL; 5994 struct ext4_ext_path *path = NULL;
5974 struct ext4_extent *ex; 5995 struct ext4_extent *ex;
5975 ext4_lblk_t old_cur, cur = 0; 5996 ext4_lblk_t old_cur, cur = 0;
5976 5997
5977 while (cur < end) { 5998 while (cur < end) {
5978 path = ext4_find_extent(inode 5999 path = ext4_find_extent(inode, cur, NULL, 0);
5979 if (IS_ERR(path)) 6000 if (IS_ERR(path))
5980 return; 6001 return;
5981 ex = path[path->p_depth].p_ex 6002 ex = path[path->p_depth].p_ext;
5982 if (!ex) { 6003 if (!ex) {
5983 ext4_free_ext_path(pa !! 6004 ext4_ext_drop_refs(path);
>> 6005 kfree(path);
5984 ext4_mark_inode_dirty 6006 ext4_mark_inode_dirty(NULL, inode);
5985 return; 6007 return;
5986 } 6008 }
5987 old_cur = cur; 6009 old_cur = cur;
5988 cur = le32_to_cpu(ex->ee_bloc 6010 cur = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex);
5989 if (cur <= old_cur) 6011 if (cur <= old_cur)
5990 cur = old_cur + 1; 6012 cur = old_cur + 1;
5991 ext4_ext_try_to_merge(NULL, i 6013 ext4_ext_try_to_merge(NULL, inode, path, ex);
5992 down_write(&EXT4_I(inode)->i_ 6014 down_write(&EXT4_I(inode)->i_data_sem);
5993 ext4_ext_dirty(NULL, inode, & 6015 ext4_ext_dirty(NULL, inode, &path[path->p_depth]);
5994 up_write(&EXT4_I(inode)->i_da 6016 up_write(&EXT4_I(inode)->i_data_sem);
5995 ext4_mark_inode_dirty(NULL, i 6017 ext4_mark_inode_dirty(NULL, inode);
5996 ext4_free_ext_path(path); !! 6018 ext4_ext_drop_refs(path);
>> 6019 kfree(path);
5997 } 6020 }
5998 } 6021 }
5999 6022
6000 /* Check if *cur is a hole and if it is, skip 6023 /* Check if *cur is a hole and if it is, skip it */
6001 static int skip_hole(struct inode *inode, ext 6024 static int skip_hole(struct inode *inode, ext4_lblk_t *cur)
6002 { 6025 {
6003 int ret; 6026 int ret;
6004 struct ext4_map_blocks map; 6027 struct ext4_map_blocks map;
6005 6028
6006 map.m_lblk = *cur; 6029 map.m_lblk = *cur;
6007 map.m_len = ((inode->i_size) >> inode 6030 map.m_len = ((inode->i_size) >> inode->i_sb->s_blocksize_bits) - *cur;
6008 6031
6009 ret = ext4_map_blocks(NULL, inode, &m 6032 ret = ext4_map_blocks(NULL, inode, &map, 0);
6010 if (ret < 0) 6033 if (ret < 0)
6011 return ret; 6034 return ret;
6012 if (ret != 0) 6035 if (ret != 0)
6013 return 0; 6036 return 0;
6014 *cur = *cur + map.m_len; 6037 *cur = *cur + map.m_len;
6015 return 0; 6038 return 0;
6016 } 6039 }
6017 6040
6018 /* Count number of blocks used by this inode 6041 /* Count number of blocks used by this inode and update i_blocks */
6019 int ext4_ext_replay_set_iblocks(struct inode 6042 int ext4_ext_replay_set_iblocks(struct inode *inode)
6020 { 6043 {
6021 struct ext4_ext_path *path = NULL, *p 6044 struct ext4_ext_path *path = NULL, *path2 = NULL;
6022 struct ext4_extent *ex; 6045 struct ext4_extent *ex;
6023 ext4_lblk_t cur = 0, end; 6046 ext4_lblk_t cur = 0, end;
6024 int numblks = 0, i, ret = 0; 6047 int numblks = 0, i, ret = 0;
6025 ext4_fsblk_t cmp1, cmp2; 6048 ext4_fsblk_t cmp1, cmp2;
6026 struct ext4_map_blocks map; 6049 struct ext4_map_blocks map;
6027 6050
6028 /* Determin the size of the file firs 6051 /* Determin the size of the file first */
6029 path = ext4_find_extent(inode, EXT_MA 6052 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
6030 EXT4_ 6053 EXT4_EX_NOCACHE);
6031 if (IS_ERR(path)) 6054 if (IS_ERR(path))
6032 return PTR_ERR(path); 6055 return PTR_ERR(path);
6033 ex = path[path->p_depth].p_ext; 6056 ex = path[path->p_depth].p_ext;
6034 if (!ex) !! 6057 if (!ex) {
>> 6058 ext4_ext_drop_refs(path);
>> 6059 kfree(path);
6035 goto out; 6060 goto out;
>> 6061 }
6036 end = le32_to_cpu(ex->ee_block) + ext 6062 end = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex);
>> 6063 ext4_ext_drop_refs(path);
>> 6064 kfree(path);
6037 6065
6038 /* Count the number of data blocks */ 6066 /* Count the number of data blocks */
6039 cur = 0; 6067 cur = 0;
6040 while (cur < end) { 6068 while (cur < end) {
6041 map.m_lblk = cur; 6069 map.m_lblk = cur;
6042 map.m_len = end - cur; 6070 map.m_len = end - cur;
6043 ret = ext4_map_blocks(NULL, i 6071 ret = ext4_map_blocks(NULL, inode, &map, 0);
6044 if (ret < 0) 6072 if (ret < 0)
6045 break; 6073 break;
6046 if (ret > 0) 6074 if (ret > 0)
6047 numblks += ret; 6075 numblks += ret;
6048 cur = cur + map.m_len; 6076 cur = cur + map.m_len;
6049 } 6077 }
6050 6078
6051 /* 6079 /*
6052 * Count the number of extent tree bl 6080 * Count the number of extent tree blocks. We do it by looking up
6053 * two successive extents and determi 6081 * two successive extents and determining the difference between
6054 * their paths. When path is differen 6082 * their paths. When path is different for 2 successive extents
6055 * we compare the blocks in the path 6083 * we compare the blocks in the path at each level and increment
6056 * iblocks by total number of differe 6084 * iblocks by total number of differences found.
6057 */ 6085 */
6058 cur = 0; 6086 cur = 0;
6059 ret = skip_hole(inode, &cur); 6087 ret = skip_hole(inode, &cur);
6060 if (ret < 0) 6088 if (ret < 0)
6061 goto out; 6089 goto out;
6062 path = ext4_find_extent(inode, cur, p !! 6090 path = ext4_find_extent(inode, cur, NULL, 0);
6063 if (IS_ERR(path)) 6091 if (IS_ERR(path))
6064 goto out; 6092 goto out;
6065 numblks += path->p_depth; 6093 numblks += path->p_depth;
>> 6094 ext4_ext_drop_refs(path);
>> 6095 kfree(path);
6066 while (cur < end) { 6096 while (cur < end) {
6067 path = ext4_find_extent(inode !! 6097 path = ext4_find_extent(inode, cur, NULL, 0);
6068 if (IS_ERR(path)) 6098 if (IS_ERR(path))
6069 break; 6099 break;
6070 ex = path[path->p_depth].p_ex 6100 ex = path[path->p_depth].p_ext;
6071 if (!ex) !! 6101 if (!ex) {
6072 goto cleanup; !! 6102 ext4_ext_drop_refs(path);
6073 !! 6103 kfree(path);
>> 6104 return 0;
>> 6105 }
6074 cur = max(cur + 1, le32_to_cp 6106 cur = max(cur + 1, le32_to_cpu(ex->ee_block) +
6075 ext4_ 6107 ext4_ext_get_actual_len(ex));
6076 ret = skip_hole(inode, &cur); 6108 ret = skip_hole(inode, &cur);
6077 if (ret < 0) !! 6109 if (ret < 0) {
>> 6110 ext4_ext_drop_refs(path);
>> 6111 kfree(path);
6078 break; 6112 break;
6079 !! 6113 }
6080 path2 = ext4_find_extent(inod !! 6114 path2 = ext4_find_extent(inode, cur, NULL, 0);
6081 if (IS_ERR(path2)) !! 6115 if (IS_ERR(path2)) {
>> 6116 ext4_ext_drop_refs(path);
>> 6117 kfree(path);
6082 break; 6118 break;
6083 !! 6119 }
>> 6120 ex = path2[path2->p_depth].p_ext;
6084 for (i = 0; i <= max(path->p_ 6121 for (i = 0; i <= max(path->p_depth, path2->p_depth); i++) {
6085 cmp1 = cmp2 = 0; 6122 cmp1 = cmp2 = 0;
6086 if (i <= path->p_dept 6123 if (i <= path->p_depth)
6087 cmp1 = path[i 6124 cmp1 = path[i].p_bh ?
6088 path[ 6125 path[i].p_bh->b_blocknr : 0;
6089 if (i <= path2->p_dep 6126 if (i <= path2->p_depth)
6090 cmp2 = path2[ 6127 cmp2 = path2[i].p_bh ?
6091 path2 6128 path2[i].p_bh->b_blocknr : 0;
6092 if (cmp1 != cmp2 && c 6129 if (cmp1 != cmp2 && cmp2 != 0)
6093 numblks++; 6130 numblks++;
6094 } 6131 }
>> 6132 ext4_ext_drop_refs(path);
>> 6133 ext4_ext_drop_refs(path2);
>> 6134 kfree(path);
>> 6135 kfree(path2);
6095 } 6136 }
6096 6137
6097 out: 6138 out:
6098 inode->i_blocks = numblks << (inode-> 6139 inode->i_blocks = numblks << (inode->i_sb->s_blocksize_bits - 9);
6099 ext4_mark_inode_dirty(NULL, inode); 6140 ext4_mark_inode_dirty(NULL, inode);
6100 cleanup: <<
6101 ext4_free_ext_path(path); <<
6102 ext4_free_ext_path(path2); <<
6103 return 0; 6141 return 0;
6104 } 6142 }
6105 6143
6106 int ext4_ext_clear_bb(struct inode *inode) 6144 int ext4_ext_clear_bb(struct inode *inode)
6107 { 6145 {
6108 struct ext4_ext_path *path = NULL; 6146 struct ext4_ext_path *path = NULL;
6109 struct ext4_extent *ex; 6147 struct ext4_extent *ex;
6110 ext4_lblk_t cur = 0, end; 6148 ext4_lblk_t cur = 0, end;
6111 int j, ret = 0; 6149 int j, ret = 0;
6112 struct ext4_map_blocks map; 6150 struct ext4_map_blocks map;
6113 6151
6114 if (ext4_test_inode_flag(inode, EXT4_ <<
6115 return 0; <<
6116 <<
6117 /* Determin the size of the file firs 6152 /* Determin the size of the file first */
6118 path = ext4_find_extent(inode, EXT_MA 6153 path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
6119 EXT4_ 6154 EXT4_EX_NOCACHE);
6120 if (IS_ERR(path)) 6155 if (IS_ERR(path))
6121 return PTR_ERR(path); 6156 return PTR_ERR(path);
6122 ex = path[path->p_depth].p_ext; 6157 ex = path[path->p_depth].p_ext;
6123 if (!ex) !! 6158 if (!ex) {
6124 goto out; !! 6159 ext4_ext_drop_refs(path);
>> 6160 kfree(path);
>> 6161 return 0;
>> 6162 }
6125 end = le32_to_cpu(ex->ee_block) + ext 6163 end = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex);
>> 6164 ext4_ext_drop_refs(path);
>> 6165 kfree(path);
6126 6166
6127 cur = 0; 6167 cur = 0;
6128 while (cur < end) { 6168 while (cur < end) {
6129 map.m_lblk = cur; 6169 map.m_lblk = cur;
6130 map.m_len = end - cur; 6170 map.m_len = end - cur;
6131 ret = ext4_map_blocks(NULL, i 6171 ret = ext4_map_blocks(NULL, inode, &map, 0);
6132 if (ret < 0) 6172 if (ret < 0)
6133 break; 6173 break;
6134 if (ret > 0) { 6174 if (ret > 0) {
6135 path = ext4_find_exte !! 6175 path = ext4_find_extent(inode, map.m_lblk, NULL, 0);
6136 if (!IS_ERR(path)) { !! 6176 if (!IS_ERR_OR_NULL(path)) {
6137 for (j = 0; j 6177 for (j = 0; j < path->p_depth; j++) {
>> 6178
6138 ext4_ 6179 ext4_mb_mark_bb(inode->i_sb,
6139 !! 6180 path[j].p_block, 1, 0);
6140 ext4_ 6181 ext4_fc_record_regions(inode->i_sb, inode->i_ino,
6141 6182 0, path[j].p_block, 1, 1);
6142 } 6183 }
6143 } else { !! 6184 ext4_ext_drop_refs(path);
6144 path = NULL; !! 6185 kfree(path);
6145 } 6186 }
6146 ext4_mb_mark_bb(inode !! 6187 ext4_mb_mark_bb(inode->i_sb, map.m_pblk, map.m_len, 0);
6147 ext4_fc_record_region 6188 ext4_fc_record_regions(inode->i_sb, inode->i_ino,
6148 map.m 6189 map.m_lblk, map.m_pblk, map.m_len, 1);
6149 } 6190 }
6150 cur = cur + map.m_len; 6191 cur = cur + map.m_len;
6151 } 6192 }
6152 6193
6153 out: <<
6154 ext4_free_ext_path(path); <<
6155 return 0; 6194 return 0;
6156 } 6195 }
6157 6196
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.