Blame view
fs/ext4/extents.c
163 KB
a86c61812 [PATCH] ext3: add... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/* * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com * Written by Alex Tomas <alex@clusterfs.com> * * Architecture independence: * Copyright (c) 2005, Bull S.A. * Written by Pierre Peiffer <pierre.peiffer@bull.net> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * |
b8a07463c ext4: fix misspel... |
18 |
* You should have received a copy of the GNU General Public License |
a86c61812 [PATCH] ext3: add... |
19 20 21 22 23 24 25 26 27 28 29 30 |
* along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111- */ /* * Extents support for EXT4 * * TODO: * - ext4*_error() should be used in some situations * - analyze all BUG()/BUG_ON(), use -EIO where appropriate * - smart tree reduction */ |
a86c61812 [PATCH] ext3: add... |
31 32 |
#include <linux/fs.h> #include <linux/time.h> |
cd02ff0b1 jbd2: JBD_XXX to ... |
33 |
#include <linux/jbd2.h> |
a86c61812 [PATCH] ext3: add... |
34 35 36 37 38 |
#include <linux/highuid.h> #include <linux/pagemap.h> #include <linux/quotaops.h> #include <linux/string.h> #include <linux/slab.h> |
a86c61812 [PATCH] ext3: add... |
39 |
#include <asm/uaccess.h> |
6873fa0de Hook ext4 to the ... |
40 |
#include <linux/fiemap.h> |
66114cad6 writeback: separa... |
41 |
#include <linux/backing-dev.h> |
3dcf54515 ext4: move header... |
42 |
#include "ext4_jbd2.h" |
4a092d737 ext4: rationalize... |
43 |
#include "ext4_extents.h" |
f19d5870c ext4: add normal ... |
44 |
#include "xattr.h" |
a86c61812 [PATCH] ext3: add... |
45 |
|
0562e0bad ext4: add more tr... |
46 |
#include <trace/events/ext4.h> |
5f95d21fb ext4: rewrite pun... |
47 48 49 50 51 |
/* * used by extent splitting. */ #define EXT4_EXT_MAY_ZEROOUT 0x1 /* safe to zeroout if split fails \ due to ENOSPC */ |
556615dcb ext4: rename unin... |
52 53 |
#define EXT4_EXT_MARK_UNWRIT1 0x2 /* mark first half unwritten */ #define EXT4_EXT_MARK_UNWRIT2 0x4 /* mark second half unwritten */ |
5f95d21fb ext4: rewrite pun... |
54 |
|
dee1f973c ext4: race-condit... |
55 56 |
#define EXT4_EXT_DATA_VALID1 0x8 /* first half contains valid data */ #define EXT4_EXT_DATA_VALID2 0x10 /* second half contains valid data */ |
7ac5990d5 ext4: verify and ... |
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
static __le32 ext4_extent_block_csum(struct inode *inode, struct ext4_extent_header *eh) { struct ext4_inode_info *ei = EXT4_I(inode); struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); __u32 csum; csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh, EXT4_EXTENT_TAIL_OFFSET(eh)); return cpu_to_le32(csum); } static int ext4_extent_block_csum_verify(struct inode *inode, struct ext4_extent_header *eh) { struct ext4_extent_tail *et; |
9aa5d32ba ext4: Replace ope... |
73 |
if (!ext4_has_metadata_csum(inode->i_sb)) |
7ac5990d5 ext4: verify and ... |
74 75 76 77 78 79 80 81 82 83 84 85 |
return 1; et = find_ext4_extent_tail(eh); if (et->et_checksum != ext4_extent_block_csum(inode, eh)) return 0; return 1; } static void ext4_extent_block_csum_set(struct inode *inode, struct ext4_extent_header *eh) { struct ext4_extent_tail *et; |
9aa5d32ba ext4: Replace ope... |
86 |
if (!ext4_has_metadata_csum(inode->i_sb)) |
7ac5990d5 ext4: verify and ... |
87 88 89 90 91 |
return; et = find_ext4_extent_tail(eh); et->et_checksum = ext4_extent_block_csum(inode, eh); } |
d583fb87a ext4: punch out e... |
92 93 |
static int ext4_split_extent(handle_t *handle, struct inode *inode, |
dfe508093 ext4: drop EXT4_E... |
94 |
struct ext4_ext_path **ppath, |
d583fb87a ext4: punch out e... |
95 96 97 |
struct ext4_map_blocks *map, int split_flag, int flags); |
5f95d21fb ext4: rewrite pun... |
98 99 |
static int ext4_split_extent_at(handle_t *handle, struct inode *inode, |
dfe508093 ext4: drop EXT4_E... |
100 |
struct ext4_ext_path **ppath, |
5f95d21fb ext4: rewrite pun... |
101 102 103 |
ext4_lblk_t split, int split_flag, int flags); |
91dd8c114 ext4: prevent rac... |
104 |
static int ext4_find_delayed_extent(struct inode *inode, |
69eb33dc2 ext4: remove sing... |
105 |
struct extent_status *newes); |
91dd8c114 ext4: prevent rac... |
106 |
|
487caeef9 ext4: Fix possibl... |
107 108 109 |
static int ext4_ext_truncate_extend_restart(handle_t *handle, struct inode *inode, int needed) |
a86c61812 [PATCH] ext3: add... |
110 111 |
{ int err; |
0390131ba ext4: Allow ext4 ... |
112 113 |
if (!ext4_handle_valid(handle)) return 0; |
7b8081912 ext4: fix jbd2 ha... |
114 |
if (handle->h_buffer_credits >= needed) |
9102e4fa8 ext4: Fix ext4_ex... |
115 |
return 0; |
7b8081912 ext4: fix jbd2 ha... |
116 117 118 119 120 121 |
/* * If we need to extend the journal get a few extra blocks * while we're at it for efficiency's sake. */ needed += 3; err = ext4_journal_extend(handle, needed - handle->h_buffer_credits); |
0123c9399 ext4: Fix ext4_ex... |
122 |
if (err <= 0) |
9102e4fa8 ext4: Fix ext4_ex... |
123 |
return err; |
487caeef9 ext4: Fix possibl... |
124 |
err = ext4_truncate_restart_trans(handle, inode, needed); |
0617b83fa ext4: restart ext... |
125 126 |
if (err == 0) err = -EAGAIN; |
487caeef9 ext4: Fix possibl... |
127 128 |
return err; |
a86c61812 [PATCH] ext3: add... |
129 130 131 132 133 134 135 136 137 138 139 140 |
} /* * could return: * - EROFS * - ENOMEM */ static int ext4_ext_get_access(handle_t *handle, struct inode *inode, struct ext4_ext_path *path) { if (path->p_bh) { /* path points to block */ |
5d6012553 ext4: add missing... |
141 |
BUFFER_TRACE(path->p_bh, "get_write_access"); |
a86c61812 [PATCH] ext3: add... |
142 143 144 145 146 147 148 149 150 151 152 153 154 |
return ext4_journal_get_write_access(handle, path->p_bh); } /* path points to leaf/index in inode body */ /* we use in-core data, no need to protect them */ return 0; } /* * could return: * - EROFS * - ENOMEM * - EIO */ |
2656497b2 ext4: mext_insert... |
155 156 |
int __ext4_ext_dirty(const char *where, unsigned int line, handle_t *handle, struct inode *inode, struct ext4_ext_path *path) |
a86c61812 [PATCH] ext3: add... |
157 158 |
{ int err; |
4b1f16607 ext4: add i_data_... |
159 160 |
WARN_ON(!rwsem_is_locked(&EXT4_I(inode)->i_data_sem)); |
a86c61812 [PATCH] ext3: add... |
161 |
if (path->p_bh) { |
7ac5990d5 ext4: verify and ... |
162 |
ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh)); |
a86c61812 [PATCH] ext3: add... |
163 |
/* path points to block */ |
9ea7a0df6 jbd2: add debuggi... |
164 165 |
err = __ext4_handle_dirty_metadata(where, line, handle, inode, path->p_bh); |
a86c61812 [PATCH] ext3: add... |
166 167 168 169 170 171 |
} else { /* path points to leaf/index in inode body */ err = ext4_mark_inode_dirty(handle, inode); } return err; } |
f65e6fba1 [PATCH] ext4: 48b... |
172 |
static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode, |
a86c61812 [PATCH] ext3: add... |
173 |
struct ext4_ext_path *path, |
725d26d3f ext4: Introduce e... |
174 |
ext4_lblk_t block) |
a86c61812 [PATCH] ext3: add... |
175 |
{ |
a86c61812 [PATCH] ext3: add... |
176 |
if (path) { |
81fdbb4a8 ext4: move variab... |
177 |
int depth = path->p_depth; |
a86c61812 [PATCH] ext3: add... |
178 |
struct ext4_extent *ex; |
a86c61812 [PATCH] ext3: add... |
179 |
|
ad4fb9caf ext4: fix 32bit o... |
180 181 182 183 184 185 186 187 188 189 190 191 192 193 |
/* * Try to predict block placement assuming that we are * filling in a file which will eventually be * non-sparse --- i.e., in the case of libbfd writing * an ELF object sections out-of-order but in a way * the eventually results in a contiguous object or * executable file, or some database extending a table * space file. However, this is actually somewhat * non-ideal if we are writing a sparse file such as * qemu or KVM writing a raw image file that is going * to stay fairly sparse, since it will end up * fragmenting the file system's free space. Maybe we * should have some hueristics or some way to allow * userspace to pass a hint to file system, |
b8d6568a1 ext4: Fix comment... |
194 |
* especially if the latter case turns out to be |
ad4fb9caf ext4: fix 32bit o... |
195 196 |
* common. */ |
7e0289766 [PATCH] ext4: if ... |
197 |
ex = path[depth].p_ext; |
ad4fb9caf ext4: fix 32bit o... |
198 199 200 201 202 203 204 205 206 |
if (ex) { ext4_fsblk_t ext_pblk = ext4_ext_pblock(ex); ext4_lblk_t ext_block = le32_to_cpu(ex->ee_block); if (block > ext_block) return ext_pblk + (block - ext_block); else return ext_pblk - (ext_block - block); } |
a86c61812 [PATCH] ext3: add... |
207 |
|
d0d856e8b [PATCH] ext4: cle... |
208 209 |
/* it looks like index is empty; * try to find starting block from index itself */ |
a86c61812 [PATCH] ext3: add... |
210 211 212 213 214 |
if (path[depth].p_bh) return path[depth].p_bh->b_blocknr; } /* OK. use inode's group */ |
f86186b44 ext4: refactor du... |
215 |
return ext4_inode_to_goal_block(inode); |
a86c61812 [PATCH] ext3: add... |
216 |
} |
654b4908b ext4: cleanup blo... |
217 218 219 |
/* * Allocation for a meta data block */ |
f65e6fba1 [PATCH] ext4: 48b... |
220 |
static ext4_fsblk_t |
654b4908b ext4: cleanup blo... |
221 |
ext4_ext_new_meta_block(handle_t *handle, struct inode *inode, |
a86c61812 [PATCH] ext3: add... |
222 |
struct ext4_ext_path *path, |
55f020db6 ext4: add flag to... |
223 |
struct ext4_extent *ex, int *err, unsigned int flags) |
a86c61812 [PATCH] ext3: add... |
224 |
{ |
f65e6fba1 [PATCH] ext4: 48b... |
225 |
ext4_fsblk_t goal, newblock; |
a86c61812 [PATCH] ext3: add... |
226 227 |
goal = ext4_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block)); |
55f020db6 ext4: add flag to... |
228 229 |
newblock = ext4_new_meta_blocks(handle, inode, goal, flags, NULL, err); |
a86c61812 [PATCH] ext3: add... |
230 231 |
return newblock; } |
55ad63bf3 ext4: fix extent ... |
232 |
static inline int ext4_ext_space_block(struct inode *inode, int check) |
a86c61812 [PATCH] ext3: add... |
233 234 235 236 237 |
{ int size; size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) / sizeof(struct ext4_extent); |
bbf2f9fb1 Fix misspellings ... |
238 |
#ifdef AGGRESSIVE_TEST |
02dc62fba ext4: clean up AG... |
239 240 |
if (!check && size > 6) size = 6; |
a86c61812 [PATCH] ext3: add... |
241 242 243 |
#endif return size; } |
55ad63bf3 ext4: fix extent ... |
244 |
static inline int ext4_ext_space_block_idx(struct inode *inode, int check) |
a86c61812 [PATCH] ext3: add... |
245 246 247 248 249 |
{ int size; size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) / sizeof(struct ext4_extent_idx); |
bbf2f9fb1 Fix misspellings ... |
250 |
#ifdef AGGRESSIVE_TEST |
02dc62fba ext4: clean up AG... |
251 252 |
if (!check && size > 5) size = 5; |
a86c61812 [PATCH] ext3: add... |
253 254 255 |
#endif return size; } |
55ad63bf3 ext4: fix extent ... |
256 |
static inline int ext4_ext_space_root(struct inode *inode, int check) |
a86c61812 [PATCH] ext3: add... |
257 258 259 260 261 262 |
{ int size; size = sizeof(EXT4_I(inode)->i_data); size -= sizeof(struct ext4_extent_header); size /= sizeof(struct ext4_extent); |
bbf2f9fb1 Fix misspellings ... |
263 |
#ifdef AGGRESSIVE_TEST |
02dc62fba ext4: clean up AG... |
264 265 |
if (!check && size > 3) size = 3; |
a86c61812 [PATCH] ext3: add... |
266 267 268 |
#endif return size; } |
55ad63bf3 ext4: fix extent ... |
269 |
static inline int ext4_ext_space_root_idx(struct inode *inode, int check) |
a86c61812 [PATCH] ext3: add... |
270 271 272 273 274 275 |
{ int size; size = sizeof(EXT4_I(inode)->i_data); size -= sizeof(struct ext4_extent_header); size /= sizeof(struct ext4_extent_idx); |
bbf2f9fb1 Fix misspellings ... |
276 |
#ifdef AGGRESSIVE_TEST |
02dc62fba ext4: clean up AG... |
277 278 |
if (!check && size > 4) size = 4; |
a86c61812 [PATCH] ext3: add... |
279 280 281 |
#endif return size; } |
fcf6b1b72 ext4: refactor ex... |
282 283 |
static inline int ext4_force_split_extent_at(handle_t *handle, struct inode *inode, |
dfe508093 ext4: drop EXT4_E... |
284 |
struct ext4_ext_path **ppath, ext4_lblk_t lblk, |
fcf6b1b72 ext4: refactor ex... |
285 286 |
int nofail) { |
dfe508093 ext4: drop EXT4_E... |
287 |
struct ext4_ext_path *path = *ppath; |
fcf6b1b72 ext4: refactor ex... |
288 |
int unwritten = ext4_ext_is_unwritten(path[path->p_depth].p_ext); |
dfe508093 ext4: drop EXT4_E... |
289 |
return ext4_split_extent_at(handle, inode, ppath, lblk, unwritten ? |
fcf6b1b72 ext4: refactor ex... |
290 291 292 293 |
EXT4_EXT_MARK_UNWRIT1|EXT4_EXT_MARK_UNWRIT2 : 0, EXT4_EX_NOCACHE | EXT4_GET_BLOCKS_PRE_IO | (nofail ? EXT4_GET_BLOCKS_METADATA_NOFAIL:0)); } |
d2a176379 ext4: delayed all... |
294 295 296 297 298 |
/* * Calculate the number of metadata blocks needed * to allocate @blocks * Worse case is one block per extent */ |
01f49d0b9 ext4: use ext4_lb... |
299 |
int ext4_ext_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock) |
d2a176379 ext4: delayed all... |
300 |
{ |
9d0be5023 ext4: Calculate m... |
301 |
struct ext4_inode_info *ei = EXT4_I(inode); |
81fdbb4a8 ext4: move variab... |
302 |
int idxs; |
d2a176379 ext4: delayed all... |
303 |
|
9d0be5023 ext4: Calculate m... |
304 305 |
idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) / sizeof(struct ext4_extent_idx)); |
d2a176379 ext4: delayed all... |
306 307 |
/* |
9d0be5023 ext4: Calculate m... |
308 309 310 311 312 313 |
* If the new delayed allocation block is contiguous with the * previous da block, it can share index blocks with the * previous block, so we only need to allocate a new index * block every idxs leaf blocks. At ldxs**2 blocks, we need * an additional index block, and at ldxs**3 blocks, yet * another index blocks. |
d2a176379 ext4: delayed all... |
314 |
*/ |
9d0be5023 ext4: Calculate m... |
315 316 |
if (ei->i_da_metadata_calc_len && ei->i_da_metadata_calc_last_lblock+1 == lblock) { |
81fdbb4a8 ext4: move variab... |
317 |
int num = 0; |
9d0be5023 ext4: Calculate m... |
318 319 320 321 322 323 324 325 326 327 328 329 |
if ((ei->i_da_metadata_calc_len % idxs) == 0) num++; if ((ei->i_da_metadata_calc_len % (idxs*idxs)) == 0) num++; if ((ei->i_da_metadata_calc_len % (idxs*idxs*idxs)) == 0) { num++; ei->i_da_metadata_calc_len = 0; } else ei->i_da_metadata_calc_len++; ei->i_da_metadata_calc_last_lblock++; return num; } |
d2a176379 ext4: delayed all... |
330 |
|
9d0be5023 ext4: Calculate m... |
331 332 333 334 335 336 337 |
/* * In the worst case we need a new set of index blocks at * every level of the inode's extent tree. */ ei->i_da_metadata_calc_len = 1; ei->i_da_metadata_calc_last_lblock = lblock; return ext_depth(inode) + 1; |
d2a176379 ext4: delayed all... |
338 |
} |
c29c0ae7f ext4: Make extent... |
339 340 341 342 343 344 345 |
static int ext4_ext_max_entries(struct inode *inode, int depth) { int max; if (depth == ext_depth(inode)) { if (depth == 0) |
55ad63bf3 ext4: fix extent ... |
346 |
max = ext4_ext_space_root(inode, 1); |
c29c0ae7f ext4: Make extent... |
347 |
else |
55ad63bf3 ext4: fix extent ... |
348 |
max = ext4_ext_space_root_idx(inode, 1); |
c29c0ae7f ext4: Make extent... |
349 350 |
} else { if (depth == 0) |
55ad63bf3 ext4: fix extent ... |
351 |
max = ext4_ext_space_block(inode, 1); |
c29c0ae7f ext4: Make extent... |
352 |
else |
55ad63bf3 ext4: fix extent ... |
353 |
max = ext4_ext_space_block_idx(inode, 1); |
c29c0ae7f ext4: Make extent... |
354 355 356 357 |
} return max; } |
56b19868a ext4: Add checks ... |
358 359 |
static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext) { |
bf89d16f6 ext4: rename {ext... |
360 |
ext4_fsblk_t block = ext4_ext_pblock(ext); |
56b19868a ext4: Add checks ... |
361 |
int len = ext4_ext_get_actual_len(ext); |
5946d0893 ext4: check for o... |
362 |
ext4_lblk_t lblock = le32_to_cpu(ext->ee_block); |
e84a26ce1 ext4: Make the ex... |
363 |
|
f70749ca4 ext4: check for e... |
364 365 366 367 368 369 |
/* * We allow neither: * - zero length * - overflow/wrap-around */ if (lblock + len <= lblock) |
31d4f3a2f ext4: check for z... |
370 |
return 0; |
6fd058f77 ext4: Add a compr... |
371 |
return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len); |
56b19868a ext4: Add checks ... |
372 373 374 375 376 |
} static int ext4_valid_extent_idx(struct inode *inode, struct ext4_extent_idx *ext_idx) { |
bf89d16f6 ext4: rename {ext... |
377 |
ext4_fsblk_t block = ext4_idx_pblock(ext_idx); |
e84a26ce1 ext4: Make the ex... |
378 |
|
6fd058f77 ext4: Add a compr... |
379 |
return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1); |
56b19868a ext4: Add checks ... |
380 381 382 383 384 385 |
} static int ext4_valid_extent_entries(struct inode *inode, struct ext4_extent_header *eh, int depth) { |
56b19868a ext4: Add checks ... |
386 387 388 389 390 391 392 393 |
unsigned short entries; if (eh->eh_entries == 0) return 1; entries = le16_to_cpu(eh->eh_entries); if (depth == 0) { /* leaf entries */ |
81fdbb4a8 ext4: move variab... |
394 |
struct ext4_extent *ext = EXT_FIRST_EXTENT(eh); |
5946d0893 ext4: check for o... |
395 396 397 398 399 |
struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; ext4_fsblk_t pblock = 0; ext4_lblk_t lblock = 0; ext4_lblk_t prev = 0; int len = 0; |
56b19868a ext4: Add checks ... |
400 401 402 |
while (entries) { if (!ext4_valid_extent(inode, ext)) return 0; |
5946d0893 ext4: check for o... |
403 404 405 406 407 408 409 410 411 |
/* Check for overlapping extents */ lblock = le32_to_cpu(ext->ee_block); len = ext4_ext_get_actual_len(ext); if ((lblock <= prev) && prev) { pblock = ext4_ext_pblock(ext); es->s_last_error_block = cpu_to_le64(pblock); return 0; } |
56b19868a ext4: Add checks ... |
412 413 |
ext++; entries--; |
5946d0893 ext4: check for o... |
414 |
prev = lblock + len - 1; |
56b19868a ext4: Add checks ... |
415 416 |
} } else { |
81fdbb4a8 ext4: move variab... |
417 |
struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh); |
56b19868a ext4: Add checks ... |
418 419 420 421 422 423 424 425 426 |
while (entries) { if (!ext4_valid_extent_idx(inode, ext_idx)) return 0; ext_idx++; entries--; } } return 1; } |
c398eda0e ext4: Pass line n... |
427 428 |
static int __ext4_ext_check(const char *function, unsigned int line, struct inode *inode, struct ext4_extent_header *eh, |
c349179b4 ext4: print the b... |
429 |
int depth, ext4_fsblk_t pblk) |
c29c0ae7f ext4: Make extent... |
430 431 |
{ const char *error_msg; |
6a797d273 ext4: call out CR... |
432 |
int max = 0, err = -EFSCORRUPTED; |
c29c0ae7f ext4: Make extent... |
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 |
if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) { error_msg = "invalid magic"; goto corrupted; } if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) { error_msg = "unexpected eh_depth"; goto corrupted; } if (unlikely(eh->eh_max == 0)) { error_msg = "invalid eh_max"; goto corrupted; } max = ext4_ext_max_entries(inode, depth); if (unlikely(le16_to_cpu(eh->eh_max) > max)) { error_msg = "too large eh_max"; goto corrupted; } if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) { error_msg = "invalid eh_entries"; goto corrupted; } |
56b19868a ext4: Add checks ... |
455 456 457 458 |
if (!ext4_valid_extent_entries(inode, eh, depth)) { error_msg = "invalid extent entries"; goto corrupted; } |
7bc949164 ext4: verify exte... |
459 460 461 462 |
if (unlikely(depth > 32)) { error_msg = "too large eh_depth"; goto corrupted; } |
7ac5990d5 ext4: verify and ... |
463 464 465 466 |
/* Verify checksum on non-root extent tree nodes */ if (ext_depth(inode) != depth && !ext4_extent_block_csum_verify(inode, eh)) { error_msg = "extent tree corrupted"; |
6a797d273 ext4: call out CR... |
467 |
err = -EFSBADCRC; |
7ac5990d5 ext4: verify and ... |
468 469 |
goto corrupted; } |
c29c0ae7f ext4: Make extent... |
470 471 472 |
return 0; corrupted: |
c398eda0e ext4: Pass line n... |
473 |
ext4_error_inode(inode, function, line, 0, |
c349179b4 ext4: print the b... |
474 475 476 477 478 479 |
"pblk %llu bad header/extent: %s - magic %x, " "entries %u, max %u(%u), depth %u(%u)", (unsigned long long) pblk, error_msg, le16_to_cpu(eh->eh_magic), le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max), max, le16_to_cpu(eh->eh_depth), depth); |
6a797d273 ext4: call out CR... |
480 |
return err; |
c29c0ae7f ext4: Make extent... |
481 |
} |
c349179b4 ext4: print the b... |
482 483 |
#define ext4_ext_check(inode, eh, depth, pblk) \ __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk)) |
c29c0ae7f ext4: Make extent... |
484 |
|
7a262f7c6 ext4: Validate ex... |
485 486 |
int ext4_ext_check_inode(struct inode *inode) { |
c349179b4 ext4: print the b... |
487 |
return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode), 0); |
7a262f7c6 ext4: Validate ex... |
488 |
} |
7d7ea89e7 ext4: refactor co... |
489 490 |
static struct buffer_head * __read_extent_tree_block(const char *function, unsigned int line, |
107a7bd31 ext4: cache all o... |
491 492 |
struct inode *inode, ext4_fsblk_t pblk, int depth, int flags) |
f84891289 ext4: create a ne... |
493 |
{ |
7d7ea89e7 ext4: refactor co... |
494 495 |
struct buffer_head *bh; int err; |
c45653c34 ext4: avoid deadl... |
496 |
bh = sb_getblk_gfp(inode->i_sb, pblk, __GFP_MOVABLE | GFP_NOFS); |
7d7ea89e7 ext4: refactor co... |
497 498 |
if (unlikely(!bh)) return ERR_PTR(-ENOMEM); |
f84891289 ext4: create a ne... |
499 |
|
7d7ea89e7 ext4: refactor co... |
500 501 502 503 504 505 |
if (!bh_uptodate_or_lock(bh)) { trace_ext4_ext_load_extent(inode, pblk, _RET_IP_); err = bh_submit_read(bh); if (err < 0) goto errout; } |
7869a4a6c ext4: add support... |
506 |
if (buffer_verified(bh) && !(flags & EXT4_EX_FORCE_CACHE)) |
7d7ea89e7 ext4: refactor co... |
507 508 |
return bh; err = __ext4_ext_check(function, line, inode, |
c349179b4 ext4: print the b... |
509 |
ext_block_hdr(bh), depth, pblk); |
7d7ea89e7 ext4: refactor co... |
510 511 |
if (err) goto errout; |
f84891289 ext4: create a ne... |
512 |
set_buffer_verified(bh); |
107a7bd31 ext4: cache all o... |
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 |
/* * If this is a leaf block, cache all of its entries */ if (!(flags & EXT4_EX_NOCACHE) && depth == 0) { struct ext4_extent_header *eh = ext_block_hdr(bh); struct ext4_extent *ex = EXT_FIRST_EXTENT(eh); ext4_lblk_t prev = 0; int i; for (i = le16_to_cpu(eh->eh_entries); i > 0; i--, ex++) { unsigned int status = EXTENT_STATUS_WRITTEN; ext4_lblk_t lblk = le32_to_cpu(ex->ee_block); int len = ext4_ext_get_actual_len(ex); if (prev && (prev != lblk)) ext4_es_cache_extent(inode, prev, lblk - prev, ~0, EXTENT_STATUS_HOLE); |
556615dcb ext4: rename unin... |
531 |
if (ext4_ext_is_unwritten(ex)) |
107a7bd31 ext4: cache all o... |
532 533 534 535 536 537 |
status = EXTENT_STATUS_UNWRITTEN; ext4_es_cache_extent(inode, lblk, len, ext4_ext_pblock(ex), status); prev = lblk + len; } } |
7d7ea89e7 ext4: refactor co... |
538 539 540 541 |
return bh; errout: put_bh(bh); return ERR_PTR(err); |
f84891289 ext4: create a ne... |
542 |
} |
107a7bd31 ext4: cache all o... |
543 544 545 |
#define read_extent_tree_block(inode, pblk, depth, flags) \ __read_extent_tree_block(__func__, __LINE__, (inode), (pblk), \ (depth), (flags)) |
f84891289 ext4: create a ne... |
546 |
|
7869a4a6c ext4: add support... |
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 |
/* * This function is called to cache a file's extent information in the * extent status tree */ int ext4_ext_precache(struct inode *inode) { struct ext4_inode_info *ei = EXT4_I(inode); struct ext4_ext_path *path = NULL; struct buffer_head *bh; int i = 0, depth, ret = 0; if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) return 0; /* not an extent-mapped inode */ down_read(&ei->i_data_sem); depth = ext_depth(inode); path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS); if (path == NULL) { up_read(&ei->i_data_sem); return -ENOMEM; } /* Don't cache anything if there are no external extent blocks */ if (depth == 0) goto out; path[0].p_hdr = ext_inode_hdr(inode); ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0); if (ret) goto out; path[0].p_idx = EXT_FIRST_INDEX(path[0].p_hdr); while (i >= 0) { /* * If this is a leaf block or we've reached the end of * the index block, go up */ if ((i == depth) || path[i].p_idx > EXT_LAST_INDEX(path[i].p_hdr)) { brelse(path[i].p_bh); path[i].p_bh = NULL; i--; continue; } bh = read_extent_tree_block(inode, ext4_idx_pblock(path[i].p_idx++), depth - i - 1, EXT4_EX_FORCE_CACHE); if (IS_ERR(bh)) { ret = PTR_ERR(bh); break; } i++; path[i].p_bh = bh; path[i].p_hdr = ext_block_hdr(bh); path[i].p_idx = EXT_FIRST_INDEX(path[i].p_hdr); } ext4_set_inode_state(inode, EXT4_STATE_EXT_PRECACHED); out: up_read(&ei->i_data_sem); ext4_ext_drop_refs(path); kfree(path); return ret; } |
a86c61812 [PATCH] ext3: add... |
611 612 613 614 615 616 617 618 |
#ifdef EXT_DEBUG static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path) { int k, l = path->p_depth; ext_debug("path:"); for (k = 0; k <= l; k++, path++) { if (path->p_idx) { |
2ae021076 [PATCH] ext4: blk... |
619 |
ext_debug(" %d->%llu", le32_to_cpu(path->p_idx->ei_block), |
bf89d16f6 ext4: rename {ext... |
620 |
ext4_idx_pblock(path->p_idx)); |
a86c61812 [PATCH] ext3: add... |
621 |
} else if (path->p_ext) { |
553f90089 ext4: Show unwrit... |
622 |
ext_debug(" %d:[%d]%d:%llu ", |
a86c61812 [PATCH] ext3: add... |
623 |
le32_to_cpu(path->p_ext->ee_block), |
556615dcb ext4: rename unin... |
624 |
ext4_ext_is_unwritten(path->p_ext), |
a2df2a634 fallocate support... |
625 |
ext4_ext_get_actual_len(path->p_ext), |
bf89d16f6 ext4: rename {ext... |
626 |
ext4_ext_pblock(path->p_ext)); |
a86c61812 [PATCH] ext3: add... |
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 |
} else ext_debug(" []"); } ext_debug(" "); } static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path) { int depth = ext_depth(inode); struct ext4_extent_header *eh; struct ext4_extent *ex; int i; if (!path) return; eh = path[depth].p_hdr; ex = EXT_FIRST_EXTENT(eh); |
553f90089 ext4: Show unwrit... |
646 647 |
ext_debug("Displaying leaf extents for inode %lu ", inode->i_ino); |
a86c61812 [PATCH] ext3: add... |
648 |
for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) { |
553f90089 ext4: Show unwrit... |
649 |
ext_debug("%d:[%d]%d:%llu ", le32_to_cpu(ex->ee_block), |
556615dcb ext4: rename unin... |
650 |
ext4_ext_is_unwritten(ex), |
bf89d16f6 ext4: rename {ext... |
651 |
ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex)); |
a86c61812 [PATCH] ext3: add... |
652 653 654 655 |
} ext_debug(" "); } |
1b16da77f ext4: teach ext4_... |
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 |
static void ext4_ext_show_move(struct inode *inode, struct ext4_ext_path *path, ext4_fsblk_t newblock, int level) { int depth = ext_depth(inode); struct ext4_extent *ex; if (depth != level) { struct ext4_extent_idx *idx; idx = path[level].p_idx; while (idx <= EXT_MAX_INDEX(path[level].p_hdr)) { ext_debug("%d: move %d:%llu in new index %llu ", level, le32_to_cpu(idx->ei_block), ext4_idx_pblock(idx), newblock); idx++; } return; } ex = path[depth].p_ext; while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) { ext_debug("move %d:%llu:[%d]%d in new leaf %llu ", le32_to_cpu(ex->ee_block), ext4_ext_pblock(ex), |
556615dcb ext4: rename unin... |
684 |
ext4_ext_is_unwritten(ex), |
1b16da77f ext4: teach ext4_... |
685 686 687 688 689 |
ext4_ext_get_actual_len(ex), newblock); ex++; } } |
a86c61812 [PATCH] ext3: add... |
690 |
#else |
af5bc92dd ext4: Fix whitesp... |
691 692 |
#define ext4_ext_show_path(inode, path) #define ext4_ext_show_leaf(inode, path) |
1b16da77f ext4: teach ext4_... |
693 |
#define ext4_ext_show_move(inode, path, newblock, level) |
a86c61812 [PATCH] ext3: add... |
694 |
#endif |
b35905c16 ext4: Fix memory ... |
695 |
void ext4_ext_drop_refs(struct ext4_ext_path *path) |
a86c61812 [PATCH] ext3: add... |
696 |
{ |
b7ea89ad0 ext4: allow a NUL... |
697 |
int depth, i; |
a86c61812 [PATCH] ext3: add... |
698 |
|
b7ea89ad0 ext4: allow a NUL... |
699 700 701 |
if (!path) return; depth = path->p_depth; |
a86c61812 [PATCH] ext3: add... |
702 703 704 705 706 707 708 709 |
for (i = 0; i <= depth; i++, path++) if (path->p_bh) { brelse(path->p_bh); path->p_bh = NULL; } } /* |
d0d856e8b [PATCH] ext4: cle... |
710 711 |
* ext4_ext_binsearch_idx: * binary search for the closest index of the given block |
c29c0ae7f ext4: Make extent... |
712 |
* the header must be checked before calling this |
a86c61812 [PATCH] ext3: add... |
713 714 |
*/ static void |
725d26d3f ext4: Introduce e... |
715 716 |
ext4_ext_binsearch_idx(struct inode *inode, struct ext4_ext_path *path, ext4_lblk_t block) |
a86c61812 [PATCH] ext3: add... |
717 718 719 |
{ struct ext4_extent_header *eh = path->p_hdr; struct ext4_extent_idx *r, *l, *m; |
a86c61812 [PATCH] ext3: add... |
720 |
|
bba907433 ext4 extents: rem... |
721 |
ext_debug("binsearch for %u(idx): ", block); |
a86c61812 [PATCH] ext3: add... |
722 723 |
l = EXT_FIRST_INDEX(eh) + 1; |
e9f410b1c ext4: extent macr... |
724 |
r = EXT_LAST_INDEX(eh); |
a86c61812 [PATCH] ext3: add... |
725 726 727 728 729 730 |
while (l <= r) { m = l + (r - l) / 2; if (block < le32_to_cpu(m->ei_block)) r = m - 1; else l = m + 1; |
26d535ed2 Fix compilation w... |
731 732 733 |
ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ei_block), m, le32_to_cpu(m->ei_block), r, le32_to_cpu(r->ei_block)); |
a86c61812 [PATCH] ext3: add... |
734 735 736 |
} path->p_idx = l - 1; |
4a3c3a512 ext4: fix format ... |
737 |
ext_debug(" -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block), |
bf89d16f6 ext4: rename {ext... |
738 |
ext4_idx_pblock(path->p_idx)); |
a86c61812 [PATCH] ext3: add... |
739 740 741 742 743 744 745 746 747 748 |
#ifdef CHECK_BINSEARCH { struct ext4_extent_idx *chix, *ix; int k; chix = ix = EXT_FIRST_INDEX(eh); for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) { if (k != 0 && le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) { |
4776004f5 ext4: Add printk ... |
749 750 751 752 753 754 |
printk(KERN_DEBUG "k=%d, ix=0x%p, " "first=0x%p ", k, ix, EXT_FIRST_INDEX(eh)); printk(KERN_DEBUG "%u <= %u ", |
a86c61812 [PATCH] ext3: add... |
755 756 757 758 |
le32_to_cpu(ix->ei_block), le32_to_cpu(ix[-1].ei_block)); } BUG_ON(k && le32_to_cpu(ix->ei_block) |
8c55e2041 EXT4: Fix whitespace |
759 |
<= le32_to_cpu(ix[-1].ei_block)); |
a86c61812 [PATCH] ext3: add... |
760 761 762 763 764 765 766 767 768 769 770 |
if (block < le32_to_cpu(ix->ei_block)) break; chix = ix; } BUG_ON(chix != path->p_idx); } #endif } /* |
d0d856e8b [PATCH] ext4: cle... |
771 772 |
* ext4_ext_binsearch: * binary search for closest extent of the given block |
c29c0ae7f ext4: Make extent... |
773 |
* the header must be checked before calling this |
a86c61812 [PATCH] ext3: add... |
774 775 |
*/ static void |
725d26d3f ext4: Introduce e... |
776 777 |
ext4_ext_binsearch(struct inode *inode, struct ext4_ext_path *path, ext4_lblk_t block) |
a86c61812 [PATCH] ext3: add... |
778 779 780 |
{ struct ext4_extent_header *eh = path->p_hdr; struct ext4_extent *r, *l, *m; |
a86c61812 [PATCH] ext3: add... |
781 782 |
if (eh->eh_entries == 0) { /* |
d0d856e8b [PATCH] ext4: cle... |
783 784 |
* this leaf is empty: * we get such a leaf in split/add case |
a86c61812 [PATCH] ext3: add... |
785 786 787 |
*/ return; } |
bba907433 ext4 extents: rem... |
788 |
ext_debug("binsearch for %u: ", block); |
a86c61812 [PATCH] ext3: add... |
789 790 |
l = EXT_FIRST_EXTENT(eh) + 1; |
e9f410b1c ext4: extent macr... |
791 |
r = EXT_LAST_EXTENT(eh); |
a86c61812 [PATCH] ext3: add... |
792 793 794 795 796 797 798 |
while (l <= r) { m = l + (r - l) / 2; if (block < le32_to_cpu(m->ee_block)) r = m - 1; else l = m + 1; |
26d535ed2 Fix compilation w... |
799 800 801 |
ext_debug("%p(%u):%p(%u):%p(%u) ", l, le32_to_cpu(l->ee_block), m, le32_to_cpu(m->ee_block), r, le32_to_cpu(r->ee_block)); |
a86c61812 [PATCH] ext3: add... |
802 803 804 |
} path->p_ext = l - 1; |
553f90089 ext4: Show unwrit... |
805 |
ext_debug(" -> %d:%llu:[%d]%d ", |
8c55e2041 EXT4: Fix whitespace |
806 |
le32_to_cpu(path->p_ext->ee_block), |
bf89d16f6 ext4: rename {ext... |
807 |
ext4_ext_pblock(path->p_ext), |
556615dcb ext4: rename unin... |
808 |
ext4_ext_is_unwritten(path->p_ext), |
a2df2a634 fallocate support... |
809 |
ext4_ext_get_actual_len(path->p_ext)); |
a86c61812 [PATCH] ext3: add... |
810 811 812 813 814 815 816 817 818 |
#ifdef CHECK_BINSEARCH { struct ext4_extent *chex, *ex; int k; chex = ex = EXT_FIRST_EXTENT(eh); for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) { BUG_ON(k && le32_to_cpu(ex->ee_block) |
8c55e2041 EXT4: Fix whitespace |
819 |
<= le32_to_cpu(ex[-1].ee_block)); |
a86c61812 [PATCH] ext3: add... |
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 |
if (block < le32_to_cpu(ex->ee_block)) break; chex = ex; } BUG_ON(chex != path->p_ext); } #endif } int ext4_ext_tree_init(handle_t *handle, struct inode *inode) { struct ext4_extent_header *eh; eh = ext_inode_hdr(inode); eh->eh_depth = 0; eh->eh_entries = 0; eh->eh_magic = EXT4_EXT_MAGIC; |
55ad63bf3 ext4: fix extent ... |
838 |
eh->eh_max = cpu_to_le16(ext4_ext_space_root(inode, 0)); |
a86c61812 [PATCH] ext3: add... |
839 |
ext4_mark_inode_dirty(handle, inode); |
a86c61812 [PATCH] ext3: add... |
840 841 842 843 |
return 0; } struct ext4_ext_path * |
ed8a1a766 ext4: rename ext4... |
844 845 |
ext4_find_extent(struct inode *inode, ext4_lblk_t block, struct ext4_ext_path **orig_path, int flags) |
a86c61812 [PATCH] ext3: add... |
846 847 848 |
{ struct ext4_extent_header *eh; struct buffer_head *bh; |
705912ca9 ext4: teach ext4_... |
849 850 |
struct ext4_ext_path *path = orig_path ? *orig_path : NULL; short int depth, i, ppos = 0; |
860d21e2c ext4: return ENOM... |
851 |
int ret; |
a86c61812 [PATCH] ext3: add... |
852 853 |
eh = ext_inode_hdr(inode); |
c29c0ae7f ext4: Make extent... |
854 |
depth = ext_depth(inode); |
a86c61812 [PATCH] ext3: add... |
855 |
|
10809df84 ext4: teach ext4_... |
856 |
if (path) { |
523f431cc ext4: call ext4_e... |
857 |
ext4_ext_drop_refs(path); |
10809df84 ext4: teach ext4_... |
858 859 860 861 862 863 |
if (depth > path[0].p_maxdepth) { kfree(path); *orig_path = path = NULL; } } if (!path) { |
523f431cc ext4: call ext4_e... |
864 |
/* account possible depth increase */ |
5d4958f92 [PATCH] ext4: kma... |
865 |
path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 2), |
a86c61812 [PATCH] ext3: add... |
866 |
GFP_NOFS); |
19008f6df ext4: fix ext4_sw... |
867 |
if (unlikely(!path)) |
a86c61812 [PATCH] ext3: add... |
868 |
return ERR_PTR(-ENOMEM); |
10809df84 ext4: teach ext4_... |
869 |
path[0].p_maxdepth = depth + 1; |
a86c61812 [PATCH] ext3: add... |
870 |
} |
a86c61812 [PATCH] ext3: add... |
871 |
path[0].p_hdr = eh; |
1973adcba ext4: Make ext4_e... |
872 |
path[0].p_bh = NULL; |
a86c61812 [PATCH] ext3: add... |
873 |
|
c29c0ae7f ext4: Make extent... |
874 |
i = depth; |
a86c61812 [PATCH] ext3: add... |
875 876 877 878 879 |
/* walk through the tree */ while (i) { ext_debug("depth %d: num %d, max %d ", ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max)); |
c29c0ae7f ext4: Make extent... |
880 |
|
a86c61812 [PATCH] ext3: add... |
881 |
ext4_ext_binsearch_idx(inode, path + ppos, block); |
bf89d16f6 ext4: rename {ext... |
882 |
path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx); |
a86c61812 [PATCH] ext3: add... |
883 884 |
path[ppos].p_depth = i; path[ppos].p_ext = NULL; |
107a7bd31 ext4: cache all o... |
885 886 |
bh = read_extent_tree_block(inode, path[ppos].p_block, --i, flags); |
a1c83681d fs: Drop unlikely... |
887 |
if (IS_ERR(bh)) { |
7d7ea89e7 ext4: refactor co... |
888 |
ret = PTR_ERR(bh); |
a86c61812 [PATCH] ext3: add... |
889 |
goto err; |
860d21e2c ext4: return ENOM... |
890 |
} |
7d7ea89e7 ext4: refactor co... |
891 |
|
a86c61812 [PATCH] ext3: add... |
892 893 |
eh = ext_block_hdr(bh); ppos++; |
a86c61812 [PATCH] ext3: add... |
894 895 |
path[ppos].p_bh = bh; path[ppos].p_hdr = eh; |
a86c61812 [PATCH] ext3: add... |
896 897 898 |
} path[ppos].p_depth = i; |
a86c61812 [PATCH] ext3: add... |
899 900 |
path[ppos].p_ext = NULL; path[ppos].p_idx = NULL; |
a86c61812 [PATCH] ext3: add... |
901 902 |
/* find extent */ ext4_ext_binsearch(inode, path + ppos, block); |
1973adcba ext4: Make ext4_e... |
903 904 |
/* if not an empty leaf */ if (path[ppos].p_ext) |
bf89d16f6 ext4: rename {ext... |
905 |
path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext); |
a86c61812 [PATCH] ext3: add... |
906 907 908 909 910 911 912 |
ext4_ext_show_path(inode, path); return path; err: ext4_ext_drop_refs(path); |
dfe508093 ext4: drop EXT4_E... |
913 914 915 |
kfree(path); if (orig_path) *orig_path = NULL; |
860d21e2c ext4: return ENOM... |
916 |
return ERR_PTR(ret); |
a86c61812 [PATCH] ext3: add... |
917 918 919 |
} /* |
d0d856e8b [PATCH] ext4: cle... |
920 921 922 |
* ext4_ext_insert_index: * insert new index [@logical;@ptr] into the block at @curp; * check where to insert: before @curp or after @curp |
a86c61812 [PATCH] ext3: add... |
923 |
*/ |
1f109d5a1 ext4: make variou... |
924 925 926 |
static int ext4_ext_insert_index(handle_t *handle, struct inode *inode, struct ext4_ext_path *curp, int logical, ext4_fsblk_t ptr) |
a86c61812 [PATCH] ext3: add... |
927 928 929 |
{ struct ext4_extent_idx *ix; int len, err; |
7e0289766 [PATCH] ext4: if ... |
930 931 |
err = ext4_ext_get_access(handle, inode, curp); if (err) |
a86c61812 [PATCH] ext3: add... |
932 |
return err; |
273df556b ext4: Convert BUG... |
933 934 935 936 |
if (unlikely(logical == le32_to_cpu(curp->p_idx->ei_block))) { EXT4_ERROR_INODE(inode, "logical %d == ei_block %d!", logical, le32_to_cpu(curp->p_idx->ei_block)); |
6a797d273 ext4: call out CR... |
937 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
938 |
} |
d46203159 ext4: avoid eh_en... |
939 940 941 942 943 944 945 |
if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries) >= le16_to_cpu(curp->p_hdr->eh_max))) { EXT4_ERROR_INODE(inode, "eh_entries %d >= eh_max %d!", le16_to_cpu(curp->p_hdr->eh_entries), le16_to_cpu(curp->p_hdr->eh_max)); |
6a797d273 ext4: call out CR... |
946 |
return -EFSCORRUPTED; |
d46203159 ext4: avoid eh_en... |
947 |
} |
a86c61812 [PATCH] ext3: add... |
948 949 |
if (logical > le32_to_cpu(curp->p_idx->ei_block)) { /* insert after */ |
80e675f90 ext4: optimize me... |
950 951 |
ext_debug("insert new index %d after: %llu ", logical, ptr); |
a86c61812 [PATCH] ext3: add... |
952 953 954 |
ix = curp->p_idx + 1; } else { /* insert before */ |
80e675f90 ext4: optimize me... |
955 956 |
ext_debug("insert new index %d before: %llu ", logical, ptr); |
a86c61812 [PATCH] ext3: add... |
957 958 |
ix = curp->p_idx; } |
80e675f90 ext4: optimize me... |
959 960 961 962 963 964 965 966 967 |
len = EXT_LAST_INDEX(curp->p_hdr) - ix + 1; BUG_ON(len < 0); if (len > 0) { ext_debug("insert new index %d: " "move %d indices from 0x%p to 0x%p ", logical, len, ix, ix + 1); memmove(ix + 1, ix, len * sizeof(struct ext4_extent_idx)); } |
f472e0266 ext4: avoid stamp... |
968 969 |
if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) { EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!"); |
6a797d273 ext4: call out CR... |
970 |
return -EFSCORRUPTED; |
f472e0266 ext4: avoid stamp... |
971 |
} |
a86c61812 [PATCH] ext3: add... |
972 |
ix->ei_block = cpu_to_le32(logical); |
f65e6fba1 [PATCH] ext4: 48b... |
973 |
ext4_idx_store_pblock(ix, ptr); |
e8546d061 ext4: le*_add_cpu... |
974 |
le16_add_cpu(&curp->p_hdr->eh_entries, 1); |
a86c61812 [PATCH] ext3: add... |
975 |
|
273df556b ext4: Convert BUG... |
976 977 |
if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) { EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!"); |
6a797d273 ext4: call out CR... |
978 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
979 |
} |
a86c61812 [PATCH] ext3: add... |
980 981 982 983 984 985 986 987 |
err = ext4_ext_dirty(handle, inode, curp); ext4_std_error(inode->i_sb, err); return err; } /* |
d0d856e8b [PATCH] ext4: cle... |
988 989 990 991 992 993 994 995 |
* ext4_ext_split: * inserts new subtree into the path, using free index entry * at depth @at: * - allocates all needed blocks (new leaf and all intermediate index blocks) * - makes decision where to split * - moves remaining extents and index entries (right to the split point) * into the newly allocated blocks * - initializes subtree |
a86c61812 [PATCH] ext3: add... |
996 997 |
*/ static int ext4_ext_split(handle_t *handle, struct inode *inode, |
55f020db6 ext4: add flag to... |
998 999 1000 |
unsigned int flags, struct ext4_ext_path *path, struct ext4_extent *newext, int at) |
a86c61812 [PATCH] ext3: add... |
1001 1002 1003 1004 1005 |
{ struct buffer_head *bh = NULL; int depth = ext_depth(inode); struct ext4_extent_header *neh; struct ext4_extent_idx *fidx; |
a86c61812 [PATCH] ext3: add... |
1006 |
int i = at, k, m, a; |
f65e6fba1 [PATCH] ext4: 48b... |
1007 |
ext4_fsblk_t newblock, oldblock; |
a86c61812 [PATCH] ext3: add... |
1008 |
__le32 border; |
f65e6fba1 [PATCH] ext4: 48b... |
1009 |
ext4_fsblk_t *ablocks = NULL; /* array of allocated blocks */ |
a86c61812 [PATCH] ext3: add... |
1010 1011 1012 |
int err = 0; /* make decision: where to split? */ |
d0d856e8b [PATCH] ext4: cle... |
1013 |
/* FIXME: now decision is simplest: at current extent */ |
a86c61812 [PATCH] ext3: add... |
1014 |
|
d0d856e8b [PATCH] ext4: cle... |
1015 |
/* if current leaf will be split, then we should use |
a86c61812 [PATCH] ext3: add... |
1016 |
* border from split point */ |
273df556b ext4: Convert BUG... |
1017 1018 |
if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) { EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!"); |
6a797d273 ext4: call out CR... |
1019 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1020 |
} |
a86c61812 [PATCH] ext3: add... |
1021 1022 |
if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) { border = path[depth].p_ext[1].ee_block; |
d0d856e8b [PATCH] ext4: cle... |
1023 |
ext_debug("leaf will be split." |
a86c61812 [PATCH] ext3: add... |
1024 1025 |
" next leaf starts at %d ", |
8c55e2041 EXT4: Fix whitespace |
1026 |
le32_to_cpu(border)); |
a86c61812 [PATCH] ext3: add... |
1027 1028 1029 1030 1031 |
} else { border = newext->ee_block; ext_debug("leaf will be added." " next leaf starts at %d ", |
8c55e2041 EXT4: Fix whitespace |
1032 |
le32_to_cpu(border)); |
a86c61812 [PATCH] ext3: add... |
1033 1034 1035 |
} /* |
d0d856e8b [PATCH] ext4: cle... |
1036 1037 |
* If error occurs, then we break processing * and mark filesystem read-only. index won't |
a86c61812 [PATCH] ext3: add... |
1038 |
* be inserted and tree will be in consistent |
d0d856e8b [PATCH] ext4: cle... |
1039 |
* state. Next mount will repair buffers too. |
a86c61812 [PATCH] ext3: add... |
1040 1041 1042 |
*/ /* |
d0d856e8b [PATCH] ext4: cle... |
1043 1044 1045 |
* Get array to track all allocated blocks. * We need this to handle errors and free blocks * upon them. |
a86c61812 [PATCH] ext3: add... |
1046 |
*/ |
5d4958f92 [PATCH] ext4: kma... |
1047 |
ablocks = kzalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS); |
a86c61812 [PATCH] ext3: add... |
1048 1049 |
if (!ablocks) return -ENOMEM; |
a86c61812 [PATCH] ext3: add... |
1050 1051 1052 1053 1054 |
/* allocate all needed blocks */ ext_debug("allocate %d blocks for indexes/leaf ", depth - at); for (a = 0; a < depth - at; a++) { |
654b4908b ext4: cleanup blo... |
1055 |
newblock = ext4_ext_new_meta_block(handle, inode, path, |
55f020db6 ext4: add flag to... |
1056 |
newext, &err, flags); |
a86c61812 [PATCH] ext3: add... |
1057 1058 1059 1060 1061 1062 1063 |
if (newblock == 0) goto cleanup; ablocks[a] = newblock; } /* initialize new leaf */ newblock = ablocks[--a]; |
273df556b ext4: Convert BUG... |
1064 1065 |
if (unlikely(newblock == 0)) { EXT4_ERROR_INODE(inode, "newblock == 0!"); |
6a797d273 ext4: call out CR... |
1066 |
err = -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1067 1068 |
goto cleanup; } |
c45653c34 ext4: avoid deadl... |
1069 |
bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); |
aebf02430 ext4: use unlikel... |
1070 |
if (unlikely(!bh)) { |
860d21e2c ext4: return ENOM... |
1071 |
err = -ENOMEM; |
a86c61812 [PATCH] ext3: add... |
1072 1073 1074 |
goto cleanup; } lock_buffer(bh); |
7e0289766 [PATCH] ext4: if ... |
1075 1076 |
err = ext4_journal_get_create_access(handle, bh); if (err) |
a86c61812 [PATCH] ext3: add... |
1077 1078 1079 1080 |
goto cleanup; neh = ext_block_hdr(bh); neh->eh_entries = 0; |
55ad63bf3 ext4: fix extent ... |
1081 |
neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0)); |
a86c61812 [PATCH] ext3: add... |
1082 1083 |
neh->eh_magic = EXT4_EXT_MAGIC; neh->eh_depth = 0; |
a86c61812 [PATCH] ext3: add... |
1084 |
|
d0d856e8b [PATCH] ext4: cle... |
1085 |
/* move remainder of path[depth] to the new leaf */ |
273df556b ext4: Convert BUG... |
1086 1087 1088 1089 1090 |
if (unlikely(path[depth].p_hdr->eh_entries != path[depth].p_hdr->eh_max)) { EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!", path[depth].p_hdr->eh_entries, path[depth].p_hdr->eh_max); |
6a797d273 ext4: call out CR... |
1091 |
err = -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1092 1093 |
goto cleanup; } |
a86c61812 [PATCH] ext3: add... |
1094 |
/* start copy from next extent */ |
1b16da77f ext4: teach ext4_... |
1095 1096 |
m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++; ext4_ext_show_move(inode, path, newblock, depth); |
a86c61812 [PATCH] ext3: add... |
1097 |
if (m) { |
1b16da77f ext4: teach ext4_... |
1098 1099 1100 |
struct ext4_extent *ex; ex = EXT_FIRST_EXTENT(neh); memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m); |
e8546d061 ext4: le*_add_cpu... |
1101 |
le16_add_cpu(&neh->eh_entries, m); |
a86c61812 [PATCH] ext3: add... |
1102 |
} |
7ac5990d5 ext4: verify and ... |
1103 |
ext4_extent_block_csum_set(inode, neh); |
a86c61812 [PATCH] ext3: add... |
1104 1105 |
set_buffer_uptodate(bh); unlock_buffer(bh); |
0390131ba ext4: Allow ext4 ... |
1106 |
err = ext4_handle_dirty_metadata(handle, inode, bh); |
7e0289766 [PATCH] ext4: if ... |
1107 |
if (err) |
a86c61812 [PATCH] ext3: add... |
1108 1109 1110 1111 1112 1113 |
goto cleanup; brelse(bh); bh = NULL; /* correct old leaf */ if (m) { |
7e0289766 [PATCH] ext4: if ... |
1114 1115 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) |
a86c61812 [PATCH] ext3: add... |
1116 |
goto cleanup; |
e8546d061 ext4: le*_add_cpu... |
1117 |
le16_add_cpu(&path[depth].p_hdr->eh_entries, -m); |
7e0289766 [PATCH] ext4: if ... |
1118 1119 |
err = ext4_ext_dirty(handle, inode, path + depth); if (err) |
a86c61812 [PATCH] ext3: add... |
1120 1121 1122 1123 1124 1125 |
goto cleanup; } /* create intermediate indexes */ k = depth - at - 1; |
273df556b ext4: Convert BUG... |
1126 1127 |
if (unlikely(k < 0)) { EXT4_ERROR_INODE(inode, "k %d < 0!", k); |
6a797d273 ext4: call out CR... |
1128 |
err = -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1129 1130 |
goto cleanup; } |
a86c61812 [PATCH] ext3: add... |
1131 1132 1133 1134 1135 1136 1137 1138 1139 |
if (k) ext_debug("create %d intermediate indices ", k); /* insert new index into current index block */ /* current depth stored in i var */ i = depth - 1; while (k--) { oldblock = newblock; newblock = ablocks[--a]; |
bba907433 ext4 extents: rem... |
1140 |
bh = sb_getblk(inode->i_sb, newblock); |
aebf02430 ext4: use unlikel... |
1141 |
if (unlikely(!bh)) { |
860d21e2c ext4: return ENOM... |
1142 |
err = -ENOMEM; |
a86c61812 [PATCH] ext3: add... |
1143 1144 1145 |
goto cleanup; } lock_buffer(bh); |
7e0289766 [PATCH] ext4: if ... |
1146 1147 |
err = ext4_journal_get_create_access(handle, bh); if (err) |
a86c61812 [PATCH] ext3: add... |
1148 1149 1150 1151 1152 |
goto cleanup; neh = ext_block_hdr(bh); neh->eh_entries = cpu_to_le16(1); neh->eh_magic = EXT4_EXT_MAGIC; |
55ad63bf3 ext4: fix extent ... |
1153 |
neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0)); |
a86c61812 [PATCH] ext3: add... |
1154 1155 1156 |
neh->eh_depth = cpu_to_le16(depth - i); fidx = EXT_FIRST_INDEX(neh); fidx->ei_block = border; |
f65e6fba1 [PATCH] ext4: 48b... |
1157 |
ext4_idx_store_pblock(fidx, oldblock); |
a86c61812 [PATCH] ext3: add... |
1158 |
|
bba907433 ext4 extents: rem... |
1159 1160 1161 |
ext_debug("int.index at %d (block %llu): %u -> %llu ", i, newblock, le32_to_cpu(border), oldblock); |
a86c61812 [PATCH] ext3: add... |
1162 |
|
1b16da77f ext4: teach ext4_... |
1163 |
/* move remainder of path[i] to the new index block */ |
273df556b ext4: Convert BUG... |
1164 1165 1166 1167 1168 |
if (unlikely(EXT_MAX_INDEX(path[i].p_hdr) != EXT_LAST_INDEX(path[i].p_hdr))) { EXT4_ERROR_INODE(inode, "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!", le32_to_cpu(path[i].p_ext->ee_block)); |
6a797d273 ext4: call out CR... |
1169 |
err = -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1170 1171 |
goto cleanup; } |
1b16da77f ext4: teach ext4_... |
1172 1173 1174 1175 1176 1177 |
/* start copy indexes */ m = EXT_MAX_INDEX(path[i].p_hdr) - path[i].p_idx++; ext_debug("cur 0x%p, last 0x%p ", path[i].p_idx, EXT_MAX_INDEX(path[i].p_hdr)); ext4_ext_show_move(inode, path, newblock, i); |
a86c61812 [PATCH] ext3: add... |
1178 |
if (m) { |
1b16da77f ext4: teach ext4_... |
1179 |
memmove(++fidx, path[i].p_idx, |
a86c61812 [PATCH] ext3: add... |
1180 |
sizeof(struct ext4_extent_idx) * m); |
e8546d061 ext4: le*_add_cpu... |
1181 |
le16_add_cpu(&neh->eh_entries, m); |
a86c61812 [PATCH] ext3: add... |
1182 |
} |
7ac5990d5 ext4: verify and ... |
1183 |
ext4_extent_block_csum_set(inode, neh); |
a86c61812 [PATCH] ext3: add... |
1184 1185 |
set_buffer_uptodate(bh); unlock_buffer(bh); |
0390131ba ext4: Allow ext4 ... |
1186 |
err = ext4_handle_dirty_metadata(handle, inode, bh); |
7e0289766 [PATCH] ext4: if ... |
1187 |
if (err) |
a86c61812 [PATCH] ext3: add... |
1188 1189 1190 1191 1192 1193 1194 1195 1196 |
goto cleanup; brelse(bh); bh = NULL; /* correct old index */ if (m) { err = ext4_ext_get_access(handle, inode, path + i); if (err) goto cleanup; |
e8546d061 ext4: le*_add_cpu... |
1197 |
le16_add_cpu(&path[i].p_hdr->eh_entries, -m); |
a86c61812 [PATCH] ext3: add... |
1198 1199 1200 1201 1202 1203 1204 1205 1206 |
err = ext4_ext_dirty(handle, inode, path + i); if (err) goto cleanup; } i--; } /* insert new index */ |
a86c61812 [PATCH] ext3: add... |
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 |
err = ext4_ext_insert_index(handle, inode, path + at, le32_to_cpu(border), newblock); cleanup: if (bh) { if (buffer_locked(bh)) unlock_buffer(bh); brelse(bh); } if (err) { /* free all allocated blocks in error case */ for (i = 0; i < depth; i++) { if (!ablocks[i]) continue; |
7dc576158 ext4: Fix sparse ... |
1222 |
ext4_free_blocks(handle, inode, NULL, ablocks[i], 1, |
e6362609b ext4: call ext4_f... |
1223 |
EXT4_FREE_BLOCKS_METADATA); |
a86c61812 [PATCH] ext3: add... |
1224 1225 1226 1227 1228 1229 1230 1231 |
} } kfree(ablocks); return err; } /* |
d0d856e8b [PATCH] ext4: cle... |
1232 1233 1234 1235 1236 1237 |
* ext4_ext_grow_indepth: * implements tree growing procedure: * - allocates new block * - moves top-level data (index block or leaf) into the new block * - initializes new top-level, creating index that points to the * just created block |
a86c61812 [PATCH] ext3: add... |
1238 1239 |
*/ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode, |
be5cd90dd ext4: optimize bl... |
1240 |
unsigned int flags) |
a86c61812 [PATCH] ext3: add... |
1241 |
{ |
a86c61812 [PATCH] ext3: add... |
1242 |
struct ext4_extent_header *neh; |
a86c61812 [PATCH] ext3: add... |
1243 |
struct buffer_head *bh; |
be5cd90dd ext4: optimize bl... |
1244 1245 |
ext4_fsblk_t newblock, goal = 0; struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; |
a86c61812 [PATCH] ext3: add... |
1246 |
int err = 0; |
be5cd90dd ext4: optimize bl... |
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 |
/* Try to prepend new index to old one */ if (ext_depth(inode)) goal = ext4_idx_pblock(EXT_FIRST_INDEX(ext_inode_hdr(inode))); if (goal > le32_to_cpu(es->s_first_data_block)) { flags |= EXT4_MB_HINT_TRY_GOAL; goal--; } else goal = ext4_inode_to_goal_block(inode); newblock = ext4_new_meta_blocks(handle, inode, goal, flags, NULL, &err); |
a86c61812 [PATCH] ext3: add... |
1257 1258 |
if (newblock == 0) return err; |
c45653c34 ext4: avoid deadl... |
1259 |
bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); |
aebf02430 ext4: use unlikel... |
1260 |
if (unlikely(!bh)) |
860d21e2c ext4: return ENOM... |
1261 |
return -ENOMEM; |
a86c61812 [PATCH] ext3: add... |
1262 |
lock_buffer(bh); |
7e0289766 [PATCH] ext4: if ... |
1263 1264 |
err = ext4_journal_get_create_access(handle, bh); if (err) { |
a86c61812 [PATCH] ext3: add... |
1265 1266 1267 1268 1269 |
unlock_buffer(bh); goto out; } /* move top-level index/leaf into new block */ |
1939dd84b ext4: cleanup ext... |
1270 1271 |
memmove(bh->b_data, EXT4_I(inode)->i_data, sizeof(EXT4_I(inode)->i_data)); |
a86c61812 [PATCH] ext3: add... |
1272 1273 1274 1275 1276 1277 |
/* set size of new block */ neh = ext_block_hdr(bh); /* old root could have indexes or leaves * so calculate e_max right way */ if (ext_depth(inode)) |
55ad63bf3 ext4: fix extent ... |
1278 |
neh->eh_max = cpu_to_le16(ext4_ext_space_block_idx(inode, 0)); |
a86c61812 [PATCH] ext3: add... |
1279 |
else |
55ad63bf3 ext4: fix extent ... |
1280 |
neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0)); |
a86c61812 [PATCH] ext3: add... |
1281 |
neh->eh_magic = EXT4_EXT_MAGIC; |
7ac5990d5 ext4: verify and ... |
1282 |
ext4_extent_block_csum_set(inode, neh); |
a86c61812 [PATCH] ext3: add... |
1283 1284 |
set_buffer_uptodate(bh); unlock_buffer(bh); |
0390131ba ext4: Allow ext4 ... |
1285 |
err = ext4_handle_dirty_metadata(handle, inode, bh); |
7e0289766 [PATCH] ext4: if ... |
1286 |
if (err) |
a86c61812 [PATCH] ext3: add... |
1287 |
goto out; |
1939dd84b ext4: cleanup ext... |
1288 |
/* Update top-level index: num,max,pointer */ |
a86c61812 [PATCH] ext3: add... |
1289 |
neh = ext_inode_hdr(inode); |
1939dd84b ext4: cleanup ext... |
1290 1291 1292 1293 1294 1295 1296 1297 |
neh->eh_entries = cpu_to_le16(1); ext4_idx_store_pblock(EXT_FIRST_INDEX(neh), newblock); if (neh->eh_depth == 0) { /* Root extent block becomes index block */ neh->eh_max = cpu_to_le16(ext4_ext_space_root_idx(inode, 0)); EXT_FIRST_INDEX(neh)->ei_block = EXT_FIRST_EXTENT(neh)->ee_block; } |
2ae021076 [PATCH] ext4: blk... |
1298 1299 |
ext_debug("new root: num %d(%d), lblock %d, ptr %llu ", |
a86c61812 [PATCH] ext3: add... |
1300 |
le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max), |
5a0790c2c ext4: remove init... |
1301 |
le32_to_cpu(EXT_FIRST_INDEX(neh)->ei_block), |
bf89d16f6 ext4: rename {ext... |
1302 |
ext4_idx_pblock(EXT_FIRST_INDEX(neh))); |
a86c61812 [PATCH] ext3: add... |
1303 |
|
ba39ebb61 ext4: convert to ... |
1304 |
le16_add_cpu(&neh->eh_depth, 1); |
1939dd84b ext4: cleanup ext... |
1305 |
ext4_mark_inode_dirty(handle, inode); |
a86c61812 [PATCH] ext3: add... |
1306 1307 1308 1309 1310 1311 1312 |
out: brelse(bh); return err; } /* |
d0d856e8b [PATCH] ext4: cle... |
1313 1314 1315 |
* ext4_ext_create_new_leaf: * finds empty index and adds new leaf. * if no free index is found, then it requests in-depth growing. |
a86c61812 [PATCH] ext3: add... |
1316 1317 |
*/ static int ext4_ext_create_new_leaf(handle_t *handle, struct inode *inode, |
107a7bd31 ext4: cache all o... |
1318 1319 |
unsigned int mb_flags, unsigned int gb_flags, |
dfe508093 ext4: drop EXT4_E... |
1320 |
struct ext4_ext_path **ppath, |
55f020db6 ext4: add flag to... |
1321 |
struct ext4_extent *newext) |
a86c61812 [PATCH] ext3: add... |
1322 |
{ |
dfe508093 ext4: drop EXT4_E... |
1323 |
struct ext4_ext_path *path = *ppath; |
a86c61812 [PATCH] ext3: add... |
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 |
struct ext4_ext_path *curp; int depth, i, err = 0; repeat: i = depth = ext_depth(inode); /* walk up to the tree and look for free index entry */ curp = path + depth; while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) { i--; curp--; } |
d0d856e8b [PATCH] ext4: cle... |
1336 1337 |
/* we use already allocated block for index block, * so subsequent data blocks should be contiguous */ |
a86c61812 [PATCH] ext3: add... |
1338 1339 1340 |
if (EXT_HAS_FREE_INDEX(curp)) { /* if we found index with free entry, then use that * entry: create all needed subtree and add new leaf */ |
107a7bd31 ext4: cache all o... |
1341 |
err = ext4_ext_split(handle, inode, mb_flags, path, newext, i); |
787e0981f ext4: return erro... |
1342 1343 |
if (err) goto out; |
a86c61812 [PATCH] ext3: add... |
1344 1345 |
/* refill path */ |
ed8a1a766 ext4: rename ext4... |
1346 |
path = ext4_find_extent(inode, |
725d26d3f ext4: Introduce e... |
1347 |
(ext4_lblk_t)le32_to_cpu(newext->ee_block), |
dfe508093 ext4: drop EXT4_E... |
1348 |
ppath, gb_flags); |
a86c61812 [PATCH] ext3: add... |
1349 1350 1351 1352 |
if (IS_ERR(path)) err = PTR_ERR(path); } else { /* tree is full, time to grow in depth */ |
be5cd90dd ext4: optimize bl... |
1353 |
err = ext4_ext_grow_indepth(handle, inode, mb_flags); |
a86c61812 [PATCH] ext3: add... |
1354 1355 1356 1357 |
if (err) goto out; /* refill path */ |
ed8a1a766 ext4: rename ext4... |
1358 |
path = ext4_find_extent(inode, |
725d26d3f ext4: Introduce e... |
1359 |
(ext4_lblk_t)le32_to_cpu(newext->ee_block), |
dfe508093 ext4: drop EXT4_E... |
1360 |
ppath, gb_flags); |
a86c61812 [PATCH] ext3: add... |
1361 1362 1363 1364 1365 1366 |
if (IS_ERR(path)) { err = PTR_ERR(path); goto out; } /* |
d0d856e8b [PATCH] ext4: cle... |
1367 1368 |
* only first (depth 0 -> 1) produces free space; * in all other cases we have to split the grown tree |
a86c61812 [PATCH] ext3: add... |
1369 1370 1371 |
*/ depth = ext_depth(inode); if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) { |
d0d856e8b [PATCH] ext4: cle... |
1372 |
/* now we need to split */ |
a86c61812 [PATCH] ext3: add... |
1373 1374 1375 1376 1377 1378 1379 1380 1381 |
goto repeat; } } out: return err; } /* |
1988b51e4 ext4: Add new fun... |
1382 1383 1384 1385 1386 1387 |
* search the closest allocated block to the left for *logical * and returns it at @logical + it's physical address at @phys * if *logical is the smallest allocated block, the function * returns 0 at @phys * return value contains 0 (success) or error code */ |
1f109d5a1 ext4: make variou... |
1388 1389 1390 |
static int ext4_ext_search_left(struct inode *inode, struct ext4_ext_path *path, ext4_lblk_t *logical, ext4_fsblk_t *phys) |
1988b51e4 ext4: Add new fun... |
1391 1392 1393 |
{ struct ext4_extent_idx *ix; struct ext4_extent *ex; |
b939e3766 ext4: Use the ext... |
1394 |
int depth, ee_len; |
1988b51e4 ext4: Add new fun... |
1395 |
|
273df556b ext4: Convert BUG... |
1396 1397 |
if (unlikely(path == NULL)) { EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); |
6a797d273 ext4: call out CR... |
1398 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1399 |
} |
1988b51e4 ext4: Add new fun... |
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 |
depth = path->p_depth; *phys = 0; if (depth == 0 && path->p_ext == NULL) return 0; /* usually extent in the path covers blocks smaller * then *logical, but it can be that extent is the * first one in the file */ ex = path[depth].p_ext; |
b939e3766 ext4: Use the ext... |
1411 |
ee_len = ext4_ext_get_actual_len(ex); |
1988b51e4 ext4: Add new fun... |
1412 |
if (*logical < le32_to_cpu(ex->ee_block)) { |
273df556b ext4: Convert BUG... |
1413 1414 1415 1416 |
if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) { EXT4_ERROR_INODE(inode, "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!", *logical, le32_to_cpu(ex->ee_block)); |
6a797d273 ext4: call out CR... |
1417 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1418 |
} |
1988b51e4 ext4: Add new fun... |
1419 1420 |
while (--depth >= 0) { ix = path[depth].p_idx; |
273df556b ext4: Convert BUG... |
1421 1422 1423 |
if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) { EXT4_ERROR_INODE(inode, "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!", |
6ee3b2122 ext4: use le32_to... |
1424 |
ix != NULL ? le32_to_cpu(ix->ei_block) : 0, |
273df556b ext4: Convert BUG... |
1425 |
EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ? |
6ee3b2122 ext4: use le32_to... |
1426 |
le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0, |
273df556b ext4: Convert BUG... |
1427 |
depth); |
6a797d273 ext4: call out CR... |
1428 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1429 |
} |
1988b51e4 ext4: Add new fun... |
1430 1431 1432 |
} return 0; } |
273df556b ext4: Convert BUG... |
1433 1434 1435 1436 |
if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) { EXT4_ERROR_INODE(inode, "logical %d < ee_block %d + ee_len %d!", *logical, le32_to_cpu(ex->ee_block), ee_len); |
6a797d273 ext4: call out CR... |
1437 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1438 |
} |
1988b51e4 ext4: Add new fun... |
1439 |
|
b939e3766 ext4: Use the ext... |
1440 |
*logical = le32_to_cpu(ex->ee_block) + ee_len - 1; |
bf89d16f6 ext4: rename {ext... |
1441 |
*phys = ext4_ext_pblock(ex) + ee_len - 1; |
1988b51e4 ext4: Add new fun... |
1442 1443 1444 1445 1446 1447 |
return 0; } /* * search the closest allocated block to the right for *logical * and returns it at @logical + it's physical address at @phys |
df3ab1707 ext4: fix the com... |
1448 |
* if *logical is the largest allocated block, the function |
1988b51e4 ext4: Add new fun... |
1449 1450 1451 |
* returns 0 at @phys * return value contains 0 (success) or error code */ |
1f109d5a1 ext4: make variou... |
1452 1453 |
static int ext4_ext_search_right(struct inode *inode, struct ext4_ext_path *path, |
4d33b1ef1 ext4: teach ext4_... |
1454 1455 |
ext4_lblk_t *logical, ext4_fsblk_t *phys, struct ext4_extent **ret_ex) |
1988b51e4 ext4: Add new fun... |
1456 1457 1458 1459 1460 1461 |
{ struct buffer_head *bh = NULL; struct ext4_extent_header *eh; struct ext4_extent_idx *ix; struct ext4_extent *ex; ext4_fsblk_t block; |
395a87bfe ext4: fix header ... |
1462 1463 |
int depth; /* Note, NOT eh_depth; depth from top of tree */ int ee_len; |
1988b51e4 ext4: Add new fun... |
1464 |
|
273df556b ext4: Convert BUG... |
1465 1466 |
if (unlikely(path == NULL)) { EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); |
6a797d273 ext4: call out CR... |
1467 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1468 |
} |
1988b51e4 ext4: Add new fun... |
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 |
depth = path->p_depth; *phys = 0; if (depth == 0 && path->p_ext == NULL) return 0; /* usually extent in the path covers blocks smaller * then *logical, but it can be that extent is the * first one in the file */ ex = path[depth].p_ext; |
b939e3766 ext4: Use the ext... |
1480 |
ee_len = ext4_ext_get_actual_len(ex); |
1988b51e4 ext4: Add new fun... |
1481 |
if (*logical < le32_to_cpu(ex->ee_block)) { |
273df556b ext4: Convert BUG... |
1482 1483 1484 1485 |
if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) { EXT4_ERROR_INODE(inode, "first_extent(path[%d].p_hdr) != ex", depth); |
6a797d273 ext4: call out CR... |
1486 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1487 |
} |
1988b51e4 ext4: Add new fun... |
1488 1489 |
while (--depth >= 0) { ix = path[depth].p_idx; |
273df556b ext4: Convert BUG... |
1490 1491 1492 1493 |
if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) { EXT4_ERROR_INODE(inode, "ix != EXT_FIRST_INDEX *logical %d!", *logical); |
6a797d273 ext4: call out CR... |
1494 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1495 |
} |
1988b51e4 ext4: Add new fun... |
1496 |
} |
4d33b1ef1 ext4: teach ext4_... |
1497 |
goto found_extent; |
1988b51e4 ext4: Add new fun... |
1498 |
} |
273df556b ext4: Convert BUG... |
1499 1500 1501 1502 |
if (unlikely(*logical < (le32_to_cpu(ex->ee_block) + ee_len))) { EXT4_ERROR_INODE(inode, "logical %d < ee_block %d + ee_len %d!", *logical, le32_to_cpu(ex->ee_block), ee_len); |
6a797d273 ext4: call out CR... |
1503 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1504 |
} |
1988b51e4 ext4: Add new fun... |
1505 1506 1507 1508 |
if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) { /* next allocated block in this leaf */ ex++; |
4d33b1ef1 ext4: teach ext4_... |
1509 |
goto found_extent; |
1988b51e4 ext4: Add new fun... |
1510 1511 1512 1513 1514 1515 |
} /* go up and search for index to the right */ while (--depth >= 0) { ix = path[depth].p_idx; if (ix != EXT_LAST_INDEX(path[depth].p_hdr)) |
25f1ee3ab ext4: fix build w... |
1516 |
goto got_index; |
1988b51e4 ext4: Add new fun... |
1517 |
} |
25f1ee3ab ext4: fix build w... |
1518 1519 |
/* we've gone up to the root and found no index to the right */ return 0; |
1988b51e4 ext4: Add new fun... |
1520 |
|
25f1ee3ab ext4: fix build w... |
1521 |
got_index: |
1988b51e4 ext4: Add new fun... |
1522 1523 1524 1525 |
/* we've found index to the right, let's * follow it and find the closest allocated * block to the right */ ix++; |
bf89d16f6 ext4: rename {ext... |
1526 |
block = ext4_idx_pblock(ix); |
1988b51e4 ext4: Add new fun... |
1527 |
while (++depth < path->p_depth) { |
395a87bfe ext4: fix header ... |
1528 |
/* subtract from p_depth to get proper eh_depth */ |
7d7ea89e7 ext4: refactor co... |
1529 |
bh = read_extent_tree_block(inode, block, |
107a7bd31 ext4: cache all o... |
1530 |
path->p_depth - depth, 0); |
7d7ea89e7 ext4: refactor co... |
1531 1532 1533 |
if (IS_ERR(bh)) return PTR_ERR(bh); eh = ext_block_hdr(bh); |
1988b51e4 ext4: Add new fun... |
1534 |
ix = EXT_FIRST_INDEX(eh); |
bf89d16f6 ext4: rename {ext... |
1535 |
block = ext4_idx_pblock(ix); |
1988b51e4 ext4: Add new fun... |
1536 1537 |
put_bh(bh); } |
107a7bd31 ext4: cache all o... |
1538 |
bh = read_extent_tree_block(inode, block, path->p_depth - depth, 0); |
7d7ea89e7 ext4: refactor co... |
1539 1540 |
if (IS_ERR(bh)) return PTR_ERR(bh); |
1988b51e4 ext4: Add new fun... |
1541 |
eh = ext_block_hdr(bh); |
1988b51e4 ext4: Add new fun... |
1542 |
ex = EXT_FIRST_EXTENT(eh); |
4d33b1ef1 ext4: teach ext4_... |
1543 |
found_extent: |
1988b51e4 ext4: Add new fun... |
1544 |
*logical = le32_to_cpu(ex->ee_block); |
bf89d16f6 ext4: rename {ext... |
1545 |
*phys = ext4_ext_pblock(ex); |
4d33b1ef1 ext4: teach ext4_... |
1546 1547 1548 |
*ret_ex = ex; if (bh) put_bh(bh); |
1988b51e4 ext4: Add new fun... |
1549 |
return 0; |
1988b51e4 ext4: Add new fun... |
1550 1551 1552 |
} /* |
d0d856e8b [PATCH] ext4: cle... |
1553 |
* ext4_ext_next_allocated_block: |
f17722f91 ext4: Fix max fil... |
1554 |
* returns allocated block in subsequent extent or EXT_MAX_BLOCKS. |
d0d856e8b [PATCH] ext4: cle... |
1555 1556 1557 |
* NOTE: it considers block number from index entry as * allocated block. Thus, index entries have to be consistent * with leaves. |
a86c61812 [PATCH] ext3: add... |
1558 |
*/ |
fcf6b1b72 ext4: refactor ex... |
1559 |
ext4_lblk_t |
a86c61812 [PATCH] ext3: add... |
1560 1561 1562 1563 1564 1565 1566 1567 |
ext4_ext_next_allocated_block(struct ext4_ext_path *path) { int depth; BUG_ON(path == NULL); depth = path->p_depth; if (depth == 0 && path->p_ext == NULL) |
f17722f91 ext4: Fix max fil... |
1568 |
return EXT_MAX_BLOCKS; |
a86c61812 [PATCH] ext3: add... |
1569 1570 1571 1572 |
while (depth >= 0) { if (depth == path->p_depth) { /* leaf */ |
6f8ff5372 ext4: handle NULL... |
1573 1574 |
if (path[depth].p_ext && path[depth].p_ext != |
a86c61812 [PATCH] ext3: add... |
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 |
EXT_LAST_EXTENT(path[depth].p_hdr)) return le32_to_cpu(path[depth].p_ext[1].ee_block); } else { /* index */ if (path[depth].p_idx != EXT_LAST_INDEX(path[depth].p_hdr)) return le32_to_cpu(path[depth].p_idx[1].ei_block); } depth--; } |
f17722f91 ext4: Fix max fil... |
1585 |
return EXT_MAX_BLOCKS; |
a86c61812 [PATCH] ext3: add... |
1586 1587 1588 |
} /* |
d0d856e8b [PATCH] ext4: cle... |
1589 |
* ext4_ext_next_leaf_block: |
f17722f91 ext4: Fix max fil... |
1590 |
* returns first allocated block from next leaf or EXT_MAX_BLOCKS |
a86c61812 [PATCH] ext3: add... |
1591 |
*/ |
5718789da ext4: remove unus... |
1592 |
static ext4_lblk_t ext4_ext_next_leaf_block(struct ext4_ext_path *path) |
a86c61812 [PATCH] ext3: add... |
1593 1594 1595 1596 1597 1598 1599 1600 |
{ int depth; BUG_ON(path == NULL); depth = path->p_depth; /* zero-tree has no leaf blocks at all */ if (depth == 0) |
f17722f91 ext4: Fix max fil... |
1601 |
return EXT_MAX_BLOCKS; |
a86c61812 [PATCH] ext3: add... |
1602 1603 1604 1605 1606 1607 1608 |
/* go to index block */ depth--; while (depth >= 0) { if (path[depth].p_idx != EXT_LAST_INDEX(path[depth].p_hdr)) |
725d26d3f ext4: Introduce e... |
1609 1610 |
return (ext4_lblk_t) le32_to_cpu(path[depth].p_idx[1].ei_block); |
a86c61812 [PATCH] ext3: add... |
1611 1612 |
depth--; } |
f17722f91 ext4: Fix max fil... |
1613 |
return EXT_MAX_BLOCKS; |
a86c61812 [PATCH] ext3: add... |
1614 1615 1616 |
} /* |
d0d856e8b [PATCH] ext4: cle... |
1617 1618 1619 |
* ext4_ext_correct_indexes: * if leaf gets modified and modified extent is first in the leaf, * then we have to correct all indexes above. |
a86c61812 [PATCH] ext3: add... |
1620 1621 |
* TODO: do we need to correct tree in all cases? */ |
1d03ec984 ext4: Fix sparse... |
1622 |
static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode, |
a86c61812 [PATCH] ext3: add... |
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 |
struct ext4_ext_path *path) { struct ext4_extent_header *eh; int depth = ext_depth(inode); struct ext4_extent *ex; __le32 border; int k, err = 0; eh = path[depth].p_hdr; ex = path[depth].p_ext; |
273df556b ext4: Convert BUG... |
1633 1634 1635 1636 |
if (unlikely(ex == NULL || eh == NULL)) { EXT4_ERROR_INODE(inode, "ex %p == NULL or eh %p == NULL", ex, eh); |
6a797d273 ext4: call out CR... |
1637 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1638 |
} |
a86c61812 [PATCH] ext3: add... |
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 |
if (depth == 0) { /* there is no tree at all */ return 0; } if (ex != EXT_FIRST_EXTENT(eh)) { /* we correct tree if first leaf got modified only */ return 0; } /* |
d0d856e8b [PATCH] ext4: cle... |
1651 |
* TODO: we need correction if border is smaller than current one |
a86c61812 [PATCH] ext3: add... |
1652 1653 1654 |
*/ k = depth - 1; border = path[depth].p_ext->ee_block; |
7e0289766 [PATCH] ext4: if ... |
1655 1656 |
err = ext4_ext_get_access(handle, inode, path + k); if (err) |
a86c61812 [PATCH] ext3: add... |
1657 1658 |
return err; path[k].p_idx->ei_block = border; |
7e0289766 [PATCH] ext4: if ... |
1659 1660 |
err = ext4_ext_dirty(handle, inode, path + k); if (err) |
a86c61812 [PATCH] ext3: add... |
1661 1662 1663 1664 1665 1666 |
return err; while (k--) { /* change all left-side indexes */ if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr)) break; |
7e0289766 [PATCH] ext4: if ... |
1667 1668 |
err = ext4_ext_get_access(handle, inode, path + k); if (err) |
a86c61812 [PATCH] ext3: add... |
1669 1670 |
break; path[k].p_idx->ei_block = border; |
7e0289766 [PATCH] ext4: if ... |
1671 1672 |
err = ext4_ext_dirty(handle, inode, path + k); if (err) |
a86c61812 [PATCH] ext3: add... |
1673 1674 1675 1676 1677 |
break; } return err; } |
748de6736 ext4: online defr... |
1678 |
int |
a86c61812 [PATCH] ext3: add... |
1679 1680 1681 |
ext4_can_extents_be_merged(struct inode *inode, struct ext4_extent *ex1, struct ext4_extent *ex2) { |
da0169b3b ext4: remove unre... |
1682 |
unsigned short ext1_ee_len, ext2_ee_len; |
a2df2a634 fallocate support... |
1683 |
|
556615dcb ext4: rename unin... |
1684 |
if (ext4_ext_is_unwritten(ex1) != ext4_ext_is_unwritten(ex2)) |
a2df2a634 fallocate support... |
1685 1686 1687 1688 1689 1690 |
return 0; ext1_ee_len = ext4_ext_get_actual_len(ex1); ext2_ee_len = ext4_ext_get_actual_len(ex2); if (le32_to_cpu(ex1->ee_block) + ext1_ee_len != |
63f579335 [PATCH] ext4 whit... |
1691 |
le32_to_cpu(ex2->ee_block)) |
a86c61812 [PATCH] ext3: add... |
1692 |
return 0; |
471d4011a [PATCH] ext4: uni... |
1693 1694 1695 |
/* * To allow future support for preallocated extents to be added * as an RO_COMPAT feature, refuse to merge to extents if |
d0d856e8b [PATCH] ext4: cle... |
1696 |
* this can result in the top bit of ee_len being set. |
471d4011a [PATCH] ext4: uni... |
1697 |
*/ |
da0169b3b ext4: remove unre... |
1698 |
if (ext1_ee_len + ext2_ee_len > EXT_INIT_MAX_LEN) |
471d4011a [PATCH] ext4: uni... |
1699 |
return 0; |
109811c20 ext4: simplify io... |
1700 1701 1702 1703 1704 1705 |
/* * The check for IO to unwritten extent is somewhat racy as we * increment i_unwritten / set EXT4_STATE_DIO_UNWRITTEN only after * dropping i_data_sem. But reserved blocks should save us in that * case. */ |
556615dcb ext4: rename unin... |
1706 |
if (ext4_ext_is_unwritten(ex1) && |
a9b824159 ext4: merge unini... |
1707 1708 |
(ext4_test_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN) || atomic_read(&EXT4_I(inode)->i_unwritten) || |
556615dcb ext4: rename unin... |
1709 |
(ext1_ee_len + ext2_ee_len > EXT_UNWRITTEN_MAX_LEN))) |
a9b824159 ext4: merge unini... |
1710 |
return 0; |
bbf2f9fb1 Fix misspellings ... |
1711 |
#ifdef AGGRESSIVE_TEST |
b939e3766 ext4: Use the ext... |
1712 |
if (ext1_ee_len >= 4) |
a86c61812 [PATCH] ext3: add... |
1713 1714 |
return 0; #endif |
bf89d16f6 ext4: rename {ext... |
1715 |
if (ext4_ext_pblock(ex1) + ext1_ee_len == ext4_ext_pblock(ex2)) |
a86c61812 [PATCH] ext3: add... |
1716 1717 1718 1719 1720 |
return 1; return 0; } /* |
56055d3ae write support for... |
1721 1722 1723 1724 1725 1726 |
* This function tries to merge the "ex" extent to the next extent in the tree. * It always tries to merge towards right. If you want to merge towards * left, pass "ex - 1" as argument instead of "ex". * Returns 0 if the extents (ex and ex+1) were _not_ merged and returns * 1 if they got merged. */ |
197217a5a ext4: add a funct... |
1727 |
static int ext4_ext_try_to_merge_right(struct inode *inode, |
1f109d5a1 ext4: make variou... |
1728 1729 |
struct ext4_ext_path *path, struct ext4_extent *ex) |
56055d3ae write support for... |
1730 1731 1732 |
{ struct ext4_extent_header *eh; unsigned int depth, len; |
556615dcb ext4: rename unin... |
1733 |
int merge_done = 0, unwritten; |
56055d3ae write support for... |
1734 1735 1736 1737 1738 1739 1740 1741 1742 |
depth = ext_depth(inode); BUG_ON(path[depth].p_hdr == NULL); eh = path[depth].p_hdr; while (ex < EXT_LAST_EXTENT(eh)) { if (!ext4_can_extents_be_merged(inode, ex, ex + 1)) break; /* merge with next extent! */ |
556615dcb ext4: rename unin... |
1743 |
unwritten = ext4_ext_is_unwritten(ex); |
56055d3ae write support for... |
1744 1745 |
ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) + ext4_ext_get_actual_len(ex + 1)); |
556615dcb ext4: rename unin... |
1746 1747 |
if (unwritten) ext4_ext_mark_unwritten(ex); |
56055d3ae write support for... |
1748 1749 1750 1751 1752 1753 |
if (ex + 1 < EXT_LAST_EXTENT(eh)) { len = (EXT_LAST_EXTENT(eh) - ex - 1) * sizeof(struct ext4_extent); memmove(ex + 1, ex + 2, len); } |
e8546d061 ext4: le*_add_cpu... |
1754 |
le16_add_cpu(&eh->eh_entries, -1); |
56055d3ae write support for... |
1755 1756 1757 |
merge_done = 1; WARN_ON(eh->eh_entries == 0); if (!eh->eh_entries) |
24676da46 ext4: Convert cal... |
1758 |
EXT4_ERROR_INODE(inode, "eh->eh_entries = 0!"); |
56055d3ae write support for... |
1759 1760 1761 1762 1763 1764 |
} return merge_done; } /* |
ecb94f5fd ext4: collapse a ... |
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 |
* This function does a very simple check to see if we can collapse * an extent tree with a single extent tree leaf block into the inode. */ static void ext4_ext_try_to_merge_up(handle_t *handle, struct inode *inode, struct ext4_ext_path *path) { size_t s; unsigned max_root = ext4_ext_space_root(inode, 0); ext4_fsblk_t blk; if ((path[0].p_depth != 1) || (le16_to_cpu(path[0].p_hdr->eh_entries) != 1) || (le16_to_cpu(path[1].p_hdr->eh_entries) > max_root)) return; /* * We need to modify the block allocation bitmap and the block * group descriptor to release the extent tree block. If we * can't get the journal credits, give up. */ if (ext4_journal_extend(handle, 2)) return; /* * Copy the extent data up to the inode */ blk = ext4_idx_pblock(path[0].p_idx); s = le16_to_cpu(path[1].p_hdr->eh_entries) * sizeof(struct ext4_extent_idx); s += sizeof(struct ext4_extent_header); |
10809df84 ext4: teach ext4_... |
1796 |
path[1].p_maxdepth = path[0].p_maxdepth; |
ecb94f5fd ext4: collapse a ... |
1797 1798 1799 1800 1801 1802 1803 1804 |
memcpy(path[0].p_hdr, path[1].p_hdr, s); path[0].p_depth = 0; path[0].p_ext = EXT_FIRST_EXTENT(path[0].p_hdr) + (path[1].p_ext - EXT_FIRST_EXTENT(path[1].p_hdr)); path[0].p_hdr->eh_max = cpu_to_le16(max_root); brelse(path[1].p_bh); ext4_free_blocks(handle, inode, NULL, blk, 1, |
71d4f7d03 ext4: remove meta... |
1805 |
EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET); |
ecb94f5fd ext4: collapse a ... |
1806 1807 1808 |
} /* |
197217a5a ext4: add a funct... |
1809 1810 1811 |
* This function tries to merge the @ex extent to neighbours in the tree. * return 1 if merge left else 0. */ |
ecb94f5fd ext4: collapse a ... |
1812 1813 |
static void ext4_ext_try_to_merge(handle_t *handle, struct inode *inode, |
197217a5a ext4: add a funct... |
1814 1815 1816 1817 1818 |
struct ext4_ext_path *path, struct ext4_extent *ex) { struct ext4_extent_header *eh; unsigned int depth; int merge_done = 0; |
197217a5a ext4: add a funct... |
1819 1820 1821 1822 1823 1824 1825 1826 1827 |
depth = ext_depth(inode); BUG_ON(path[depth].p_hdr == NULL); eh = path[depth].p_hdr; if (ex > EXT_FIRST_EXTENT(eh)) merge_done = ext4_ext_try_to_merge_right(inode, path, ex - 1); if (!merge_done) |
ecb94f5fd ext4: collapse a ... |
1828 |
(void) ext4_ext_try_to_merge_right(inode, path, ex); |
197217a5a ext4: add a funct... |
1829 |
|
ecb94f5fd ext4: collapse a ... |
1830 |
ext4_ext_try_to_merge_up(handle, inode, path); |
197217a5a ext4: add a funct... |
1831 1832 1833 |
} /* |
25d14f983 ext4: Extent over... |
1834 1835 1836 1837 1838 1839 1840 |
* check if a portion of the "newext" extent overlaps with an * existing extent. * * If there is an overlap discovered, it updates the length of the newext * such that there will be no overlap, and then returns 1. * If there is no overlap found, it returns 0. */ |
4d33b1ef1 ext4: teach ext4_... |
1841 1842 |
static unsigned int ext4_ext_check_overlap(struct ext4_sb_info *sbi, struct inode *inode, |
1f109d5a1 ext4: make variou... |
1843 1844 |
struct ext4_extent *newext, struct ext4_ext_path *path) |
25d14f983 ext4: Extent over... |
1845 |
{ |
725d26d3f ext4: Introduce e... |
1846 |
ext4_lblk_t b1, b2; |
25d14f983 ext4: Extent over... |
1847 1848 1849 1850 |
unsigned int depth, len1; unsigned int ret = 0; b1 = le32_to_cpu(newext->ee_block); |
a2df2a634 fallocate support... |
1851 |
len1 = ext4_ext_get_actual_len(newext); |
25d14f983 ext4: Extent over... |
1852 1853 1854 |
depth = ext_depth(inode); if (!path[depth].p_ext) goto out; |
f5a44db5d ext4: add explici... |
1855 |
b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block)); |
25d14f983 ext4: Extent over... |
1856 1857 1858 |
/* * get the next allocated block if the extent in the path |
2b2d6d019 ext4: Cleanup whi... |
1859 |
* is before the requested block(s) |
25d14f983 ext4: Extent over... |
1860 1861 1862 |
*/ if (b2 < b1) { b2 = ext4_ext_next_allocated_block(path); |
f17722f91 ext4: Fix max fil... |
1863 |
if (b2 == EXT_MAX_BLOCKS) |
25d14f983 ext4: Extent over... |
1864 |
goto out; |
f5a44db5d ext4: add explici... |
1865 |
b2 = EXT4_LBLK_CMASK(sbi, b2); |
25d14f983 ext4: Extent over... |
1866 |
} |
725d26d3f ext4: Introduce e... |
1867 |
/* check for wrap through zero on extent logical start block*/ |
25d14f983 ext4: Extent over... |
1868 |
if (b1 + len1 < b1) { |
f17722f91 ext4: Fix max fil... |
1869 |
len1 = EXT_MAX_BLOCKS - b1; |
25d14f983 ext4: Extent over... |
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 |
newext->ee_len = cpu_to_le16(len1); ret = 1; } /* check for overlap */ if (b1 + len1 > b2) { newext->ee_len = cpu_to_le16(b2 - b1); ret = 1; } out: return ret; } /* |
d0d856e8b [PATCH] ext4: cle... |
1884 1885 1886 1887 |
* ext4_ext_insert_extent: * tries to merge requsted extent into the existing extent or * inserts requested extent as new one into the tree, * creating new leaf in the no-space case. |
a86c61812 [PATCH] ext3: add... |
1888 1889 |
*/ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode, |
dfe508093 ext4: drop EXT4_E... |
1890 |
struct ext4_ext_path **ppath, |
107a7bd31 ext4: cache all o... |
1891 |
struct ext4_extent *newext, int gb_flags) |
a86c61812 [PATCH] ext3: add... |
1892 |
{ |
dfe508093 ext4: drop EXT4_E... |
1893 |
struct ext4_ext_path *path = *ppath; |
af5bc92dd ext4: Fix whitesp... |
1894 |
struct ext4_extent_header *eh; |
a86c61812 [PATCH] ext3: add... |
1895 1896 1897 |
struct ext4_extent *ex, *fex; struct ext4_extent *nearex; /* nearest extent */ struct ext4_ext_path *npath = NULL; |
725d26d3f ext4: Introduce e... |
1898 1899 |
int depth, len, err; ext4_lblk_t next; |
556615dcb ext4: rename unin... |
1900 |
int mb_flags = 0, unwritten; |
a86c61812 [PATCH] ext3: add... |
1901 |
|
e3cf5d5d9 ext4: prepare to ... |
1902 1903 |
if (gb_flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) mb_flags |= EXT4_MB_DELALLOC_RESERVED; |
273df556b ext4: Convert BUG... |
1904 1905 |
if (unlikely(ext4_ext_get_actual_len(newext) == 0)) { EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0"); |
6a797d273 ext4: call out CR... |
1906 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1907 |
} |
a86c61812 [PATCH] ext3: add... |
1908 1909 |
depth = ext_depth(inode); ex = path[depth].p_ext; |
be8981be6 ext4: try to prep... |
1910 |
eh = path[depth].p_hdr; |
273df556b ext4: Convert BUG... |
1911 1912 |
if (unlikely(path[depth].p_hdr == NULL)) { EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); |
6a797d273 ext4: call out CR... |
1913 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
1914 |
} |
a86c61812 [PATCH] ext3: add... |
1915 1916 |
/* try to insert block into found extent and return */ |
107a7bd31 ext4: cache all o... |
1917 |
if (ex && !(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) { |
a2df2a634 fallocate support... |
1918 1919 |
/* |
be8981be6 ext4: try to prep... |
1920 1921 |
* Try to see whether we should rather test the extent on * right from ex, or from the left of ex. This is because |
ed8a1a766 ext4: rename ext4... |
1922 |
* ext4_find_extent() can return either extent on the |
be8981be6 ext4: try to prep... |
1923 1924 |
* left, or on the right from the searched position. This * will make merging more effective. |
a2df2a634 fallocate support... |
1925 |
*/ |
be8981be6 ext4: try to prep... |
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 |
if (ex < EXT_LAST_EXTENT(eh) && (le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex) < le32_to_cpu(newext->ee_block))) { ex += 1; goto prepend; } else if ((ex > EXT_FIRST_EXTENT(eh)) && (le32_to_cpu(newext->ee_block) + ext4_ext_get_actual_len(newext) < le32_to_cpu(ex->ee_block))) ex -= 1; /* Try to append newex to the ex */ if (ext4_can_extents_be_merged(inode, ex, newext)) { ext_debug("append [%d]%d block to %u:[%d]%d" "(from %llu) ", |
556615dcb ext4: rename unin... |
1943 |
ext4_ext_is_unwritten(newext), |
be8981be6 ext4: try to prep... |
1944 1945 |
ext4_ext_get_actual_len(newext), le32_to_cpu(ex->ee_block), |
556615dcb ext4: rename unin... |
1946 |
ext4_ext_is_unwritten(ex), |
be8981be6 ext4: try to prep... |
1947 1948 1949 1950 1951 1952 |
ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex)); err = ext4_ext_get_access(handle, inode, path + depth); if (err) return err; |
556615dcb ext4: rename unin... |
1953 |
unwritten = ext4_ext_is_unwritten(ex); |
be8981be6 ext4: try to prep... |
1954 |
ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) |
a2df2a634 fallocate support... |
1955 |
+ ext4_ext_get_actual_len(newext)); |
556615dcb ext4: rename unin... |
1956 1957 |
if (unwritten) ext4_ext_mark_unwritten(ex); |
be8981be6 ext4: try to prep... |
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 |
eh = path[depth].p_hdr; nearex = ex; goto merge; } prepend: /* Try to prepend newex to the ex */ if (ext4_can_extents_be_merged(inode, newext, ex)) { ext_debug("prepend %u[%d]%d block to %u:[%d]%d" "(from %llu) ", le32_to_cpu(newext->ee_block), |
556615dcb ext4: rename unin... |
1970 |
ext4_ext_is_unwritten(newext), |
be8981be6 ext4: try to prep... |
1971 1972 |
ext4_ext_get_actual_len(newext), le32_to_cpu(ex->ee_block), |
556615dcb ext4: rename unin... |
1973 |
ext4_ext_is_unwritten(ex), |
be8981be6 ext4: try to prep... |
1974 1975 1976 1977 1978 1979 |
ext4_ext_get_actual_len(ex), ext4_ext_pblock(ex)); err = ext4_ext_get_access(handle, inode, path + depth); if (err) return err; |
556615dcb ext4: rename unin... |
1980 |
unwritten = ext4_ext_is_unwritten(ex); |
be8981be6 ext4: try to prep... |
1981 1982 1983 1984 |
ex->ee_block = newext->ee_block; ext4_ext_store_pblock(ex, ext4_ext_pblock(newext)); ex->ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex) + ext4_ext_get_actual_len(newext)); |
556615dcb ext4: rename unin... |
1985 1986 |
if (unwritten) ext4_ext_mark_unwritten(ex); |
be8981be6 ext4: try to prep... |
1987 1988 1989 1990 |
eh = path[depth].p_hdr; nearex = ex; goto merge; } |
a86c61812 [PATCH] ext3: add... |
1991 |
} |
a86c61812 [PATCH] ext3: add... |
1992 1993 1994 1995 1996 1997 1998 |
depth = ext_depth(inode); eh = path[depth].p_hdr; if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) goto has_space; /* probably next leaf has space for us? */ fex = EXT_LAST_EXTENT(eh); |
598dbdf24 ext4: avoid unnee... |
1999 2000 |
next = EXT_MAX_BLOCKS; if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)) |
5718789da ext4: remove unus... |
2001 |
next = ext4_ext_next_leaf_block(path); |
598dbdf24 ext4: avoid unnee... |
2002 |
if (next != EXT_MAX_BLOCKS) { |
32de67569 ext4: fix a synta... |
2003 2004 |
ext_debug("next leaf block - %u ", next); |
a86c61812 [PATCH] ext3: add... |
2005 |
BUG_ON(npath != NULL); |
ed8a1a766 ext4: rename ext4... |
2006 |
npath = ext4_find_extent(inode, next, NULL, 0); |
a86c61812 [PATCH] ext3: add... |
2007 2008 2009 2010 2011 |
if (IS_ERR(npath)) return PTR_ERR(npath); BUG_ON(npath->p_depth != path->p_depth); eh = npath[depth].p_hdr; if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) { |
25985edce Fix common misspe... |
2012 2013 |
ext_debug("next leaf isn't full(%d) ", |
a86c61812 [PATCH] ext3: add... |
2014 2015 |
le16_to_cpu(eh->eh_entries)); path = npath; |
ffb505ff0 ext4: remove redu... |
2016 |
goto has_space; |
a86c61812 [PATCH] ext3: add... |
2017 2018 2019 2020 2021 2022 2023 |
} ext_debug("next leaf has no free space(%d,%d) ", le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max)); } /* |
d0d856e8b [PATCH] ext4: cle... |
2024 2025 |
* There is no free space in the found leaf. * We're gonna add a new leaf in the tree. |
a86c61812 [PATCH] ext3: add... |
2026 |
*/ |
107a7bd31 ext4: cache all o... |
2027 |
if (gb_flags & EXT4_GET_BLOCKS_METADATA_NOFAIL) |
e3cf5d5d9 ext4: prepare to ... |
2028 |
mb_flags |= EXT4_MB_USE_RESERVED; |
107a7bd31 ext4: cache all o... |
2029 |
err = ext4_ext_create_new_leaf(handle, inode, mb_flags, gb_flags, |
dfe508093 ext4: drop EXT4_E... |
2030 |
ppath, newext); |
a86c61812 [PATCH] ext3: add... |
2031 2032 2033 2034 2035 2036 2037 |
if (err) goto cleanup; depth = ext_depth(inode); eh = path[depth].p_hdr; has_space: nearex = path[depth].p_ext; |
7e0289766 [PATCH] ext4: if ... |
2038 2039 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) |
a86c61812 [PATCH] ext3: add... |
2040 2041 2042 2043 |
goto cleanup; if (!nearex) { /* there is no extent in this leaf, create first one */ |
32de67569 ext4: fix a synta... |
2044 2045 |
ext_debug("first extent in the leaf: %u:%llu:[%d]%d ", |
8c55e2041 EXT4: Fix whitespace |
2046 |
le32_to_cpu(newext->ee_block), |
bf89d16f6 ext4: rename {ext... |
2047 |
ext4_ext_pblock(newext), |
556615dcb ext4: rename unin... |
2048 |
ext4_ext_is_unwritten(newext), |
a2df2a634 fallocate support... |
2049 |
ext4_ext_get_actual_len(newext)); |
80e675f90 ext4: optimize me... |
2050 2051 2052 |
nearex = EXT_FIRST_EXTENT(eh); } else { if (le32_to_cpu(newext->ee_block) |
8c55e2041 EXT4: Fix whitespace |
2053 |
> le32_to_cpu(nearex->ee_block)) { |
80e675f90 ext4: optimize me... |
2054 |
/* Insert after */ |
32de67569 ext4: fix a synta... |
2055 2056 2057 |
ext_debug("insert %u:%llu:[%d]%d before: " "nearest %p ", |
80e675f90 ext4: optimize me... |
2058 2059 |
le32_to_cpu(newext->ee_block), ext4_ext_pblock(newext), |
556615dcb ext4: rename unin... |
2060 |
ext4_ext_is_unwritten(newext), |
80e675f90 ext4: optimize me... |
2061 2062 2063 2064 2065 2066 |
ext4_ext_get_actual_len(newext), nearex); nearex++; } else { /* Insert before */ BUG_ON(newext->ee_block == nearex->ee_block); |
32de67569 ext4: fix a synta... |
2067 2068 2069 |
ext_debug("insert %u:%llu:[%d]%d after: " "nearest %p ", |
8c55e2041 EXT4: Fix whitespace |
2070 |
le32_to_cpu(newext->ee_block), |
bf89d16f6 ext4: rename {ext... |
2071 |
ext4_ext_pblock(newext), |
556615dcb ext4: rename unin... |
2072 |
ext4_ext_is_unwritten(newext), |
a2df2a634 fallocate support... |
2073 |
ext4_ext_get_actual_len(newext), |
80e675f90 ext4: optimize me... |
2074 2075 2076 2077 |
nearex); } len = EXT_LAST_EXTENT(eh) - nearex + 1; if (len > 0) { |
32de67569 ext4: fix a synta... |
2078 |
ext_debug("insert %u:%llu:[%d]%d: " |
80e675f90 ext4: optimize me... |
2079 2080 2081 2082 |
"move %d extents from 0x%p to 0x%p ", le32_to_cpu(newext->ee_block), ext4_ext_pblock(newext), |
556615dcb ext4: rename unin... |
2083 |
ext4_ext_is_unwritten(newext), |
80e675f90 ext4: optimize me... |
2084 2085 2086 2087 |
ext4_ext_get_actual_len(newext), len, nearex, nearex + 1); memmove(nearex + 1, nearex, len * sizeof(struct ext4_extent)); |
a86c61812 [PATCH] ext3: add... |
2088 |
} |
a86c61812 [PATCH] ext3: add... |
2089 |
} |
e8546d061 ext4: le*_add_cpu... |
2090 |
le16_add_cpu(&eh->eh_entries, 1); |
80e675f90 ext4: optimize me... |
2091 |
path[depth].p_ext = nearex; |
a86c61812 [PATCH] ext3: add... |
2092 |
nearex->ee_block = newext->ee_block; |
bf89d16f6 ext4: rename {ext... |
2093 |
ext4_ext_store_pblock(nearex, ext4_ext_pblock(newext)); |
a86c61812 [PATCH] ext3: add... |
2094 |
nearex->ee_len = newext->ee_len; |
a86c61812 [PATCH] ext3: add... |
2095 2096 |
merge: |
e7bcf8230 ext4: fix out-of-... |
2097 |
/* try to merge extents */ |
107a7bd31 ext4: cache all o... |
2098 |
if (!(gb_flags & EXT4_GET_BLOCKS_PRE_IO)) |
ecb94f5fd ext4: collapse a ... |
2099 |
ext4_ext_try_to_merge(handle, inode, path, nearex); |
a86c61812 [PATCH] ext3: add... |
2100 |
|
a86c61812 [PATCH] ext3: add... |
2101 2102 2103 2104 2105 |
/* time to correct all indexes above */ err = ext4_ext_correct_indexes(handle, inode, path); if (err) goto cleanup; |
ecb94f5fd ext4: collapse a ... |
2106 |
err = ext4_ext_dirty(handle, inode, path + path->p_depth); |
a86c61812 [PATCH] ext3: add... |
2107 2108 |
cleanup: |
b7ea89ad0 ext4: allow a NUL... |
2109 2110 |
ext4_ext_drop_refs(npath); kfree(npath); |
a86c61812 [PATCH] ext3: add... |
2111 2112 |
return err; } |
91dd8c114 ext4: prevent rac... |
2113 2114 2115 |
static int ext4_fill_fiemap_extents(struct inode *inode, ext4_lblk_t block, ext4_lblk_t num, struct fiemap_extent_info *fieinfo) |
6873fa0de Hook ext4 to the ... |
2116 2117 |
{ struct ext4_ext_path *path = NULL; |
6873fa0de Hook ext4 to the ... |
2118 |
struct ext4_extent *ex; |
69eb33dc2 ext4: remove sing... |
2119 |
struct extent_status es; |
91dd8c114 ext4: prevent rac... |
2120 |
ext4_lblk_t next, next_del, start = 0, end = 0; |
6873fa0de Hook ext4 to the ... |
2121 |
ext4_lblk_t last = block + num; |
91dd8c114 ext4: prevent rac... |
2122 2123 2124 |
int exists, depth = 0, err = 0; unsigned int flags = 0; unsigned char blksize_bits = inode->i_sb->s_blocksize_bits; |
6873fa0de Hook ext4 to the ... |
2125 |
|
f17722f91 ext4: Fix max fil... |
2126 |
while (block < last && block != EXT_MAX_BLOCKS) { |
6873fa0de Hook ext4 to the ... |
2127 2128 |
num = last - block; /* find extent for this block */ |
fab3a549e ext4: Fix potenti... |
2129 |
down_read(&EXT4_I(inode)->i_data_sem); |
91dd8c114 ext4: prevent rac... |
2130 |
|
ed8a1a766 ext4: rename ext4... |
2131 |
path = ext4_find_extent(inode, block, &path, 0); |
6873fa0de Hook ext4 to the ... |
2132 |
if (IS_ERR(path)) { |
91dd8c114 ext4: prevent rac... |
2133 |
up_read(&EXT4_I(inode)->i_data_sem); |
6873fa0de Hook ext4 to the ... |
2134 2135 2136 2137 2138 2139 |
err = PTR_ERR(path); path = NULL; break; } depth = ext_depth(inode); |
273df556b ext4: Convert BUG... |
2140 |
if (unlikely(path[depth].p_hdr == NULL)) { |
91dd8c114 ext4: prevent rac... |
2141 |
up_read(&EXT4_I(inode)->i_data_sem); |
273df556b ext4: Convert BUG... |
2142 |
EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); |
6a797d273 ext4: call out CR... |
2143 |
err = -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
2144 2145 |
break; } |
6873fa0de Hook ext4 to the ... |
2146 2147 |
ex = path[depth].p_ext; next = ext4_ext_next_allocated_block(path); |
91dd8c114 ext4: prevent rac... |
2148 |
flags = 0; |
6873fa0de Hook ext4 to the ... |
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 |
exists = 0; if (!ex) { /* there is no extent yet, so try to allocate * all requested space */ start = block; end = block + num; } else if (le32_to_cpu(ex->ee_block) > block) { /* need to allocate space before found extent */ start = block; end = le32_to_cpu(ex->ee_block); if (block + num < end) end = block + num; } else if (block >= le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex)) { /* need to allocate space after found extent */ start = block; end = block + num; if (end >= next) end = next; } else if (block >= le32_to_cpu(ex->ee_block)) { /* * some part of requested space is covered * by found extent */ start = block; end = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex); if (block + num < end) end = block + num; exists = 1; } else { BUG(); } BUG_ON(end <= start); if (!exists) { |
69eb33dc2 ext4: remove sing... |
2185 2186 2187 |
es.es_lblk = start; es.es_len = end - start; es.es_pblk = 0; |
6873fa0de Hook ext4 to the ... |
2188 |
} else { |
69eb33dc2 ext4: remove sing... |
2189 2190 2191 |
es.es_lblk = le32_to_cpu(ex->ee_block); es.es_len = ext4_ext_get_actual_len(ex); es.es_pblk = ext4_ext_pblock(ex); |
556615dcb ext4: rename unin... |
2192 |
if (ext4_ext_is_unwritten(ex)) |
91dd8c114 ext4: prevent rac... |
2193 |
flags |= FIEMAP_EXTENT_UNWRITTEN; |
6873fa0de Hook ext4 to the ... |
2194 |
} |
91dd8c114 ext4: prevent rac... |
2195 |
/* |
69eb33dc2 ext4: remove sing... |
2196 2197 |
* Find delayed extent and update es accordingly. We call * it even in !exists case to find out whether es is the |
91dd8c114 ext4: prevent rac... |
2198 2199 |
* last existing extent or not. */ |
69eb33dc2 ext4: remove sing... |
2200 |
next_del = ext4_find_delayed_extent(inode, &es); |
91dd8c114 ext4: prevent rac... |
2201 2202 |
if (!exists && next_del) { exists = 1; |
72dac95d4 ext4: return FIEM... |
2203 2204 |
flags |= (FIEMAP_EXTENT_DELALLOC | FIEMAP_EXTENT_UNKNOWN); |
91dd8c114 ext4: prevent rac... |
2205 2206 |
} up_read(&EXT4_I(inode)->i_data_sem); |
69eb33dc2 ext4: remove sing... |
2207 2208 |
if (unlikely(es.es_len == 0)) { EXT4_ERROR_INODE(inode, "es.es_len == 0"); |
6a797d273 ext4: call out CR... |
2209 |
err = -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
2210 2211 |
break; } |
6873fa0de Hook ext4 to the ... |
2212 |
|
f7fec032a ext4: track all e... |
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 |
/* * This is possible iff next == next_del == EXT_MAX_BLOCKS. * we need to check next == EXT_MAX_BLOCKS because it is * possible that an extent is with unwritten and delayed * status due to when an extent is delayed allocated and * is allocated by fallocate status tree will track both of * them in a extent. * * So we could return a unwritten and delayed extent, and * its block is equal to 'next'. */ if (next == next_del && next == EXT_MAX_BLOCKS) { |
91dd8c114 ext4: prevent rac... |
2225 2226 2227 2228 2229 2230 2231 |
flags |= FIEMAP_EXTENT_LAST; if (unlikely(next_del != EXT_MAX_BLOCKS || next != EXT_MAX_BLOCKS)) { EXT4_ERROR_INODE(inode, "next extent == %u, next " "delalloc extent = %u", next, next_del); |
6a797d273 ext4: call out CR... |
2232 |
err = -EFSCORRUPTED; |
91dd8c114 ext4: prevent rac... |
2233 2234 |
break; } |
6873fa0de Hook ext4 to the ... |
2235 |
} |
91dd8c114 ext4: prevent rac... |
2236 2237 |
if (exists) { err = fiemap_fill_next_extent(fieinfo, |
69eb33dc2 ext4: remove sing... |
2238 2239 2240 |
(__u64)es.es_lblk << blksize_bits, (__u64)es.es_pblk << blksize_bits, (__u64)es.es_len << blksize_bits, |
91dd8c114 ext4: prevent rac... |
2241 2242 2243 2244 2245 2246 2247 |
flags); if (err < 0) break; if (err == 1) { err = 0; break; } |
6873fa0de Hook ext4 to the ... |
2248 |
} |
69eb33dc2 ext4: remove sing... |
2249 |
block = es.es_lblk + es.es_len; |
6873fa0de Hook ext4 to the ... |
2250 |
} |
b7ea89ad0 ext4: allow a NUL... |
2251 2252 |
ext4_ext_drop_refs(path); kfree(path); |
6873fa0de Hook ext4 to the ... |
2253 2254 |
return err; } |
a86c61812 [PATCH] ext3: add... |
2255 |
/* |
140a52508 ext4: factor out ... |
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 |
* ext4_ext_determine_hole - determine hole around given block * @inode: inode we lookup in * @path: path in extent tree to @lblk * @lblk: pointer to logical block around which we want to determine hole * * Determine hole length (and start if easily possible) around given logical * block. We don't try too hard to find the beginning of the hole but @path * actually points to extent before @lblk, we provide it. * * The function returns the length of a hole starting at @lblk. We update @lblk * to the beginning of the hole if we managed to find it. |
a86c61812 [PATCH] ext3: add... |
2267 |
*/ |
140a52508 ext4: factor out ... |
2268 2269 2270 |
static ext4_lblk_t ext4_ext_determine_hole(struct inode *inode, struct ext4_ext_path *path, ext4_lblk_t *lblk) |
a86c61812 [PATCH] ext3: add... |
2271 2272 |
{ int depth = ext_depth(inode); |
a86c61812 [PATCH] ext3: add... |
2273 |
struct ext4_extent *ex; |
140a52508 ext4: factor out ... |
2274 |
ext4_lblk_t len; |
a86c61812 [PATCH] ext3: add... |
2275 2276 2277 |
ex = path[depth].p_ext; if (ex == NULL) { |
2f8e0a7c6 ext4: cache exten... |
2278 |
/* there is no extent yet, so gap is [0;-] */ |
140a52508 ext4: factor out ... |
2279 |
*lblk = 0; |
2f8e0a7c6 ext4: cache exten... |
2280 |
len = EXT_MAX_BLOCKS; |
140a52508 ext4: factor out ... |
2281 2282 2283 |
} else if (*lblk < le32_to_cpu(ex->ee_block)) { len = le32_to_cpu(ex->ee_block) - *lblk; } else if (*lblk >= le32_to_cpu(ex->ee_block) |
a2df2a634 fallocate support... |
2284 |
+ ext4_ext_get_actual_len(ex)) { |
725d26d3f ext4: Introduce e... |
2285 |
ext4_lblk_t next; |
725d26d3f ext4: Introduce e... |
2286 |
|
140a52508 ext4: factor out ... |
2287 |
*lblk = le32_to_cpu(ex->ee_block) + ext4_ext_get_actual_len(ex); |
725d26d3f ext4: Introduce e... |
2288 |
next = ext4_ext_next_allocated_block(path); |
140a52508 ext4: factor out ... |
2289 2290 |
BUG_ON(next == *lblk); len = next - *lblk; |
a86c61812 [PATCH] ext3: add... |
2291 |
} else { |
a86c61812 [PATCH] ext3: add... |
2292 2293 |
BUG(); } |
140a52508 ext4: factor out ... |
2294 2295 |
return len; } |
a86c61812 [PATCH] ext3: add... |
2296 |
|
140a52508 ext4: factor out ... |
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 |
/* * ext4_ext_put_gap_in_cache: * calculate boundaries of the gap that the requested block fits into * and cache this gap */ static void ext4_ext_put_gap_in_cache(struct inode *inode, ext4_lblk_t hole_start, ext4_lblk_t hole_len) { struct extent_status es; ext4_es_find_delayed_extent_range(inode, hole_start, hole_start + hole_len - 1, &es); |
2f8e0a7c6 ext4: cache exten... |
2310 2311 |
if (es.es_len) { /* There's delayed extent containing lblock? */ |
140a52508 ext4: factor out ... |
2312 |
if (es.es_lblk <= hole_start) |
2f8e0a7c6 ext4: cache exten... |
2313 |
return; |
140a52508 ext4: factor out ... |
2314 |
hole_len = min(es.es_lblk - hole_start, hole_len); |
2f8e0a7c6 ext4: cache exten... |
2315 |
} |
140a52508 ext4: factor out ... |
2316 2317 2318 2319 |
ext_debug(" -> %u:%u ", hole_start, hole_len); ext4_es_insert_extent(inode, hole_start, hole_len, ~0, EXTENT_STATUS_HOLE); |
a86c61812 [PATCH] ext3: add... |
2320 2321 2322 |
} /* |
d0d856e8b [PATCH] ext4: cle... |
2323 2324 |
* ext4_ext_rm_idx: * removes index from the index block. |
a86c61812 [PATCH] ext3: add... |
2325 |
*/ |
1d03ec984 ext4: Fix sparse... |
2326 |
static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode, |
c36575e66 ext4: fix extent ... |
2327 |
struct ext4_ext_path *path, int depth) |
a86c61812 [PATCH] ext3: add... |
2328 |
{ |
a86c61812 [PATCH] ext3: add... |
2329 |
int err; |
f65e6fba1 [PATCH] ext4: 48b... |
2330 |
ext4_fsblk_t leaf; |
a86c61812 [PATCH] ext3: add... |
2331 2332 |
/* free index block */ |
c36575e66 ext4: fix extent ... |
2333 2334 |
depth--; path = path + depth; |
bf89d16f6 ext4: rename {ext... |
2335 |
leaf = ext4_idx_pblock(path->p_idx); |
273df556b ext4: Convert BUG... |
2336 2337 |
if (unlikely(path->p_hdr->eh_entries == 0)) { EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0"); |
6a797d273 ext4: call out CR... |
2338 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
2339 |
} |
7e0289766 [PATCH] ext4: if ... |
2340 2341 |
err = ext4_ext_get_access(handle, inode, path); if (err) |
a86c61812 [PATCH] ext3: add... |
2342 |
return err; |
0e1147b00 ext4: add action ... |
2343 2344 2345 2346 2347 2348 |
if (path->p_idx != EXT_LAST_INDEX(path->p_hdr)) { int len = EXT_LAST_INDEX(path->p_hdr) - path->p_idx; len *= sizeof(struct ext4_extent_idx); memmove(path->p_idx, path->p_idx + 1, len); } |
e8546d061 ext4: le*_add_cpu... |
2349 |
le16_add_cpu(&path->p_hdr->eh_entries, -1); |
7e0289766 [PATCH] ext4: if ... |
2350 2351 |
err = ext4_ext_dirty(handle, inode, path); if (err) |
a86c61812 [PATCH] ext3: add... |
2352 |
return err; |
2ae021076 [PATCH] ext4: blk... |
2353 2354 |
ext_debug("index is empty, remove it, free block %llu ", leaf); |
d8990240d ext4: add some tr... |
2355 |
trace_ext4_ext_rm_idx(inode, leaf); |
7dc576158 ext4: Fix sparse ... |
2356 |
ext4_free_blocks(handle, inode, NULL, leaf, 1, |
e6362609b ext4: call ext4_f... |
2357 |
EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET); |
c36575e66 ext4: fix extent ... |
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 |
while (--depth >= 0) { if (path->p_idx != EXT_FIRST_INDEX(path->p_hdr)) break; path--; err = ext4_ext_get_access(handle, inode, path); if (err) break; path->p_idx->ei_block = (path+1)->p_idx->ei_block; err = ext4_ext_dirty(handle, inode, path); if (err) break; } |
a86c61812 [PATCH] ext3: add... |
2371 2372 2373 2374 |
return err; } /* |
ee12b6306 ext4: journal cre... |
2375 2376 2377 2378 2379 |
* ext4_ext_calc_credits_for_single_extent: * This routine returns max. credits that needed to insert an extent * to the extent tree. * When pass the actual path, the caller should calculate credits * under i_data_sem. |
a86c61812 [PATCH] ext3: add... |
2380 |
*/ |
525f4ed8d ext4: journal cre... |
2381 |
int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks, |
a86c61812 [PATCH] ext3: add... |
2382 2383 |
struct ext4_ext_path *path) { |
a86c61812 [PATCH] ext3: add... |
2384 |
if (path) { |
ee12b6306 ext4: journal cre... |
2385 |
int depth = ext_depth(inode); |
f3bd1f3fa ext4: journal cre... |
2386 |
int ret = 0; |
ee12b6306 ext4: journal cre... |
2387 |
|
a86c61812 [PATCH] ext3: add... |
2388 |
/* probably there is space in leaf? */ |
a86c61812 [PATCH] ext3: add... |
2389 |
if (le16_to_cpu(path[depth].p_hdr->eh_entries) |
ee12b6306 ext4: journal cre... |
2390 |
< le16_to_cpu(path[depth].p_hdr->eh_max)) { |
a86c61812 [PATCH] ext3: add... |
2391 |
|
ee12b6306 ext4: journal cre... |
2392 2393 2394 2395 2396 |
/* * There are some space in the leaf tree, no * need to account for leaf block credit * * bitmaps and block group descriptor blocks |
df3ab1707 ext4: fix the com... |
2397 |
* and other metadata blocks still need to be |
ee12b6306 ext4: journal cre... |
2398 2399 |
* accounted. */ |
525f4ed8d ext4: journal cre... |
2400 |
/* 1 bitmap, 1 block group descriptor */ |
ee12b6306 ext4: journal cre... |
2401 |
ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb); |
5887e98b6 ext4: Calculate r... |
2402 |
return ret; |
ee12b6306 ext4: journal cre... |
2403 2404 |
} } |
a86c61812 [PATCH] ext3: add... |
2405 |
|
525f4ed8d ext4: journal cre... |
2406 |
return ext4_chunk_trans_blocks(inode, nrblocks); |
ee12b6306 ext4: journal cre... |
2407 |
} |
a86c61812 [PATCH] ext3: add... |
2408 |
|
ee12b6306 ext4: journal cre... |
2409 |
/* |
fffb27399 ext4: better esti... |
2410 |
* How many index/leaf blocks need to change/allocate to add @extents extents? |
ee12b6306 ext4: journal cre... |
2411 |
* |
fffb27399 ext4: better esti... |
2412 2413 |
* If we add a single extent, then in the worse case, each tree level * index/leaf need to be changed in case of the tree split. |
ee12b6306 ext4: journal cre... |
2414 |
* |
fffb27399 ext4: better esti... |
2415 2416 |
* If more extents are inserted, they could cause the whole tree split more * than once, but this is really rare. |
ee12b6306 ext4: journal cre... |
2417 |
*/ |
fffb27399 ext4: better esti... |
2418 |
int ext4_ext_index_trans_blocks(struct inode *inode, int extents) |
ee12b6306 ext4: journal cre... |
2419 2420 |
{ int index; |
f19d5870c ext4: add normal ... |
2421 2422 2423 2424 2425 2426 2427 |
int depth; /* If we are converting the inline data, only one is needed here. */ if (ext4_has_inline_data(inode)) return 1; depth = ext_depth(inode); |
a86c61812 [PATCH] ext3: add... |
2428 |
|
fffb27399 ext4: better esti... |
2429 |
if (extents <= 1) |
ee12b6306 ext4: journal cre... |
2430 2431 2432 |
index = depth * 2; else index = depth * 3; |
a86c61812 [PATCH] ext3: add... |
2433 |
|
ee12b6306 ext4: journal cre... |
2434 |
return index; |
a86c61812 [PATCH] ext3: add... |
2435 |
} |
981250ca8 ext4: don't use E... |
2436 2437 2438 2439 2440 2441 2442 2443 |
static inline int get_default_free_blocks_flags(struct inode *inode) { if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) return EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET; else if (ext4_should_journal_data(inode)) return EXT4_FREE_BLOCKS_FORGET; return 0; } |
a86c61812 [PATCH] ext3: add... |
2444 |
static int ext4_remove_blocks(handle_t *handle, struct inode *inode, |
0aa060000 ext4: teach ext4_... |
2445 |
struct ext4_extent *ex, |
d23142c62 ext4: make punch ... |
2446 |
long long *partial_cluster, |
0aa060000 ext4: teach ext4_... |
2447 |
ext4_lblk_t from, ext4_lblk_t to) |
a86c61812 [PATCH] ext3: add... |
2448 |
{ |
0aa060000 ext4: teach ext4_... |
2449 |
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); |
345ee9474 ext4: miscellaneo... |
2450 |
unsigned short ee_len = ext4_ext_get_actual_len(ex); |
0aa060000 ext4: teach ext4_... |
2451 |
ext4_fsblk_t pblk; |
981250ca8 ext4: don't use E... |
2452 |
int flags = get_default_free_blocks_flags(inode); |
18888cf08 ext4: speed up tr... |
2453 |
|
0aa060000 ext4: teach ext4_... |
2454 2455 2456 2457 2458 |
/* * For bigalloc file systems, we never free a partial cluster * at the beginning of the extent. Instead, we make a note * that we tried freeing the cluster, and check to see if we * need to free it on a subsequent call to ext4_remove_blocks, |
345ee9474 ext4: miscellaneo... |
2459 |
* or at the end of ext4_ext_rm_leaf or ext4_ext_remove_space. |
0aa060000 ext4: teach ext4_... |
2460 2461 |
*/ flags |= EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER; |
d8990240d ext4: add some tr... |
2462 |
trace_ext4_remove_blocks(inode, ex, from, to, *partial_cluster); |
0aa060000 ext4: teach ext4_... |
2463 2464 2465 2466 2467 2468 |
/* * If we have a partial cluster, and it's different from the * cluster of the last block, we need to explicitly free the * partial cluster here. */ pblk = ext4_ext_pblock(ex) + ee_len - 1; |
345ee9474 ext4: miscellaneo... |
2469 2470 |
if (*partial_cluster > 0 && *partial_cluster != (long long) EXT4_B2C(sbi, pblk)) { |
0aa060000 ext4: teach ext4_... |
2471 2472 2473 2474 2475 |
ext4_free_blocks(handle, inode, NULL, EXT4_C2B(sbi, *partial_cluster), sbi->s_cluster_ratio, flags); *partial_cluster = 0; } |
a86c61812 [PATCH] ext3: add... |
2476 2477 2478 |
#ifdef EXTENTS_STATS { struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); |
a86c61812 [PATCH] ext3: add... |
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 |
spin_lock(&sbi->s_ext_stats_lock); sbi->s_ext_blocks += ee_len; sbi->s_ext_extents++; if (ee_len < sbi->s_ext_min) sbi->s_ext_min = ee_len; if (ee_len > sbi->s_ext_max) sbi->s_ext_max = ee_len; if (ext_depth(inode) > sbi->s_depth_max) sbi->s_depth_max = ext_depth(inode); spin_unlock(&sbi->s_ext_stats_lock); } #endif if (from >= le32_to_cpu(ex->ee_block) |
a2df2a634 fallocate support... |
2492 |
&& to == le32_to_cpu(ex->ee_block) + ee_len - 1) { |
a86c61812 [PATCH] ext3: add... |
2493 |
/* tail removal */ |
725d26d3f ext4: Introduce e... |
2494 |
ext4_lblk_t num; |
345ee9474 ext4: miscellaneo... |
2495 |
long long first_cluster; |
725d26d3f ext4: Introduce e... |
2496 |
|
a2df2a634 fallocate support... |
2497 |
num = le32_to_cpu(ex->ee_block) + ee_len - from; |
0aa060000 ext4: teach ext4_... |
2498 |
pblk = ext4_ext_pblock(ex) + ee_len - num; |
d23142c62 ext4: make punch ... |
2499 2500 2501 2502 2503 2504 |
/* * Usually we want to free partial cluster at the end of the * extent, except for the situation when the cluster is still * used by any other extent (partial_cluster is negative). */ if (*partial_cluster < 0 && |
345ee9474 ext4: miscellaneo... |
2505 |
*partial_cluster == -(long long) EXT4_B2C(sbi, pblk+num-1)) |
d23142c62 ext4: make punch ... |
2506 2507 2508 2509 2510 |
flags |= EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER; ext_debug("free last %u blocks starting %llu partial %lld ", num, pblk, *partial_cluster); |
0aa060000 ext4: teach ext4_... |
2511 2512 2513 2514 |
ext4_free_blocks(handle, inode, NULL, pblk, num, flags); /* * If the block range to be freed didn't start at the * beginning of a cluster, and we removed the entire |
d23142c62 ext4: make punch ... |
2515 2516 |
* extent and the cluster is not used by any other extent, * save the partial cluster here, since we might need to |
345ee9474 ext4: miscellaneo... |
2517 2518 2519 2520 |
* delete if we determine that the truncate or punch hole * operation has removed all of the blocks in the cluster. * If that cluster is used by another extent, preserve its * negative value so it isn't freed later on. |
d23142c62 ext4: make punch ... |
2521 |
* |
345ee9474 ext4: miscellaneo... |
2522 2523 2524 2525 2526 |
* If the whole extent wasn't freed, we've reached the * start of the truncated/punched region and have finished * removing blocks. If there's a partial cluster here it's * shared with the remainder of the extent and is no longer * a candidate for removal. |
0aa060000 ext4: teach ext4_... |
2527 |
*/ |
345ee9474 ext4: miscellaneo... |
2528 2529 2530 2531 2532 |
if (EXT4_PBLK_COFF(sbi, pblk) && ee_len == num) { first_cluster = (long long) EXT4_B2C(sbi, pblk); if (first_cluster != -*partial_cluster) *partial_cluster = first_cluster; } else { |
0aa060000 ext4: teach ext4_... |
2533 |
*partial_cluster = 0; |
345ee9474 ext4: miscellaneo... |
2534 |
} |
78fb9cdf0 ext4: remove unus... |
2535 2536 |
} else ext4_error(sbi->s_sb, "strange request: removal(2) " |
8d2ae1cbe ext4: remove trai... |
2537 |
"%u-%u from %u:%u", |
78fb9cdf0 ext4: remove unus... |
2538 |
from, to, le32_to_cpu(ex->ee_block), ee_len); |
a86c61812 [PATCH] ext3: add... |
2539 2540 |
return 0; } |
d583fb87a ext4: punch out e... |
2541 2542 2543 |
/* * ext4_ext_rm_leaf() Removes the extents associated with the |
5bf437606 ext4: fix end of ... |
2544 2545 |
* blocks appearing between "start" and "end". Both "start" * and "end" must appear in the same extent or EIO is returned. |
d583fb87a ext4: punch out e... |
2546 2547 2548 2549 |
* * @handle: The journal handle * @inode: The files inode * @path: The path to the leaf |
d23142c62 ext4: make punch ... |
2550 |
* @partial_cluster: The cluster which we'll have to free if all extents |
5bf437606 ext4: fix end of ... |
2551 2552 2553 |
* has been released from it. However, if this value is * negative, it's a cluster just to the right of the * punched region and it must not be freed. |
d583fb87a ext4: punch out e... |
2554 2555 2556 |
* @start: The first block to remove * @end: The last block to remove */ |
a86c61812 [PATCH] ext3: add... |
2557 2558 |
static int ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, |
d23142c62 ext4: make punch ... |
2559 2560 |
struct ext4_ext_path *path, long long *partial_cluster, |
0aa060000 ext4: teach ext4_... |
2561 |
ext4_lblk_t start, ext4_lblk_t end) |
a86c61812 [PATCH] ext3: add... |
2562 |
{ |
0aa060000 ext4: teach ext4_... |
2563 |
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); |
a86c61812 [PATCH] ext3: add... |
2564 2565 2566 |
int err = 0, correct_index = 0; int depth = ext_depth(inode), credits; struct ext4_extent_header *eh; |
750c9c47a ext4: remove mess... |
2567 |
ext4_lblk_t a, b; |
725d26d3f ext4: Introduce e... |
2568 2569 |
unsigned num; ext4_lblk_t ex_ee_block; |
a86c61812 [PATCH] ext3: add... |
2570 |
unsigned short ex_ee_len; |
556615dcb ext4: rename unin... |
2571 |
unsigned unwritten = 0; |
a86c61812 [PATCH] ext3: add... |
2572 |
struct ext4_extent *ex; |
d23142c62 ext4: make punch ... |
2573 |
ext4_fsblk_t pblk; |
a86c61812 [PATCH] ext3: add... |
2574 |
|
c29c0ae7f ext4: Make extent... |
2575 |
/* the header must be checked already in ext4_ext_remove_space() */ |
5f95d21fb ext4: rewrite pun... |
2576 2577 |
ext_debug("truncate since %u in leaf to %u ", start, end); |
a86c61812 [PATCH] ext3: add... |
2578 2579 2580 |
if (!path[depth].p_hdr) path[depth].p_hdr = ext_block_hdr(path[depth].p_bh); eh = path[depth].p_hdr; |
273df556b ext4: Convert BUG... |
2581 2582 |
if (unlikely(path[depth].p_hdr == NULL)) { EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); |
6a797d273 ext4: call out CR... |
2583 |
return -EFSCORRUPTED; |
273df556b ext4: Convert BUG... |
2584 |
} |
a86c61812 [PATCH] ext3: add... |
2585 |
/* find where to start removing */ |
6ae06ff51 ext4: optimize st... |
2586 2587 2588 |
ex = path[depth].p_ext; if (!ex) ex = EXT_LAST_EXTENT(eh); |
a86c61812 [PATCH] ext3: add... |
2589 2590 |
ex_ee_block = le32_to_cpu(ex->ee_block); |
a2df2a634 fallocate support... |
2591 |
ex_ee_len = ext4_ext_get_actual_len(ex); |
a86c61812 [PATCH] ext3: add... |
2592 |
|
d8990240d ext4: add some tr... |
2593 |
trace_ext4_ext_rm_leaf(inode, start, ex, *partial_cluster); |
a86c61812 [PATCH] ext3: add... |
2594 2595 |
while (ex >= EXT_FIRST_EXTENT(eh) && ex_ee_block + ex_ee_len > start) { |
a41f20716 ext4: Avoid corru... |
2596 |
|
556615dcb ext4: rename unin... |
2597 2598 |
if (ext4_ext_is_unwritten(ex)) unwritten = 1; |
a41f20716 ext4: Avoid corru... |
2599 |
else |
556615dcb ext4: rename unin... |
2600 |
unwritten = 0; |
a41f20716 ext4: Avoid corru... |
2601 |
|
553f90089 ext4: Show unwrit... |
2602 2603 |
ext_debug("remove ext %u:[%d]%d ", ex_ee_block, |
556615dcb ext4: rename unin... |
2604 |
unwritten, ex_ee_len); |
a86c61812 [PATCH] ext3: add... |
2605 2606 2607 |
path[depth].p_ext = ex; a = ex_ee_block > start ? ex_ee_block : start; |
d583fb87a ext4: punch out e... |
2608 2609 |
b = ex_ee_block+ex_ee_len - 1 < end ? ex_ee_block+ex_ee_len - 1 : end; |
a86c61812 [PATCH] ext3: add... |
2610 2611 2612 |
ext_debug(" border %u:%u ", a, b); |
d583fb87a ext4: punch out e... |
2613 |
/* If this extent is beyond the end of the hole, skip it */ |
5f95d21fb ext4: rewrite pun... |
2614 |
if (end < ex_ee_block) { |
d23142c62 ext4: make punch ... |
2615 2616 |
/* * We're going to skip this extent and move to another, |
f4226d9ea ext4: fix partial... |
2617 2618 2619 2620 |
* so note that its first cluster is in use to avoid * freeing it when removing blocks. Eventually, the * right edge of the truncated/punched region will * be just to the left. |
d23142c62 ext4: make punch ... |
2621 |
*/ |
f4226d9ea ext4: fix partial... |
2622 2623 |
if (sbi->s_cluster_ratio > 1) { pblk = ext4_ext_pblock(ex); |
d23142c62 ext4: make punch ... |
2624 |
*partial_cluster = |
f4226d9ea ext4: fix partial... |
2625 2626 |
-(long long) EXT4_B2C(sbi, pblk); } |
d583fb87a ext4: punch out e... |
2627 2628 2629 2630 |
ex--; ex_ee_block = le32_to_cpu(ex->ee_block); ex_ee_len = ext4_ext_get_actual_len(ex); continue; |
750c9c47a ext4: remove mess... |
2631 |
} else if (b != ex_ee_block + ex_ee_len - 1) { |
dc1841d6c ext4: give more h... |
2632 2633 2634 2635 2636 |
EXT4_ERROR_INODE(inode, "can not handle truncate %u:%u " "on extent %u:%u", start, end, ex_ee_block, ex_ee_block + ex_ee_len - 1); |
6a797d273 ext4: call out CR... |
2637 |
err = -EFSCORRUPTED; |
750c9c47a ext4: remove mess... |
2638 |
goto out; |
a86c61812 [PATCH] ext3: add... |
2639 2640 |
} else if (a != ex_ee_block) { /* remove tail of the extent */ |
750c9c47a ext4: remove mess... |
2641 |
num = a - ex_ee_block; |
a86c61812 [PATCH] ext3: add... |
2642 2643 |
} else { /* remove whole extent: excellent! */ |
a86c61812 [PATCH] ext3: add... |
2644 |
num = 0; |
a86c61812 [PATCH] ext3: add... |
2645 |
} |
34071da71 ext4: don't assum... |
2646 2647 2648 2649 2650 2651 2652 |
/* * 3 for leaf, sb, and inode plus 2 (bmap and group * descriptor) for each block group; assume two block * groups plus ex_ee_len/blocks_per_block_group for * the worst case */ credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb)); |
a86c61812 [PATCH] ext3: add... |
2653 2654 2655 2656 |
if (ex == EXT_FIRST_EXTENT(eh)) { correct_index = 1; credits += (ext_depth(inode)) + 1; } |
5aca07eb7 ext4: quota macro... |
2657 |
credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); |
a86c61812 [PATCH] ext3: add... |
2658 |
|
487caeef9 ext4: Fix possibl... |
2659 |
err = ext4_ext_truncate_extend_restart(handle, inode, credits); |
9102e4fa8 ext4: Fix ext4_ex... |
2660 |
if (err) |
a86c61812 [PATCH] ext3: add... |
2661 |
goto out; |
a86c61812 [PATCH] ext3: add... |
2662 2663 2664 2665 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) goto out; |
0aa060000 ext4: teach ext4_... |
2666 2667 |
err = ext4_remove_blocks(handle, inode, ex, partial_cluster, a, b); |
a86c61812 [PATCH] ext3: add... |
2668 2669 |
if (err) goto out; |
750c9c47a ext4: remove mess... |
2670 |
if (num == 0) |
d0d856e8b [PATCH] ext4: cle... |
2671 |
/* this extent is removed; mark slot entirely unused */ |
f65e6fba1 [PATCH] ext4: 48b... |
2672 |
ext4_ext_store_pblock(ex, 0); |
a86c61812 [PATCH] ext3: add... |
2673 |
|
a86c61812 [PATCH] ext3: add... |
2674 |
ex->ee_len = cpu_to_le16(num); |
749269fac Change on-disk fo... |
2675 |
/* |
556615dcb ext4: rename unin... |
2676 |
* Do not mark unwritten if all the blocks in the |
749269fac Change on-disk fo... |
2677 2678 |
* extent have been removed. */ |
556615dcb ext4: rename unin... |
2679 2680 |
if (unwritten && num) ext4_ext_mark_unwritten(ex); |
d583fb87a ext4: punch out e... |
2681 2682 2683 2684 2685 |
/* * If the extent was completely released, * we need to remove it from the leaf */ if (num == 0) { |
f17722f91 ext4: Fix max fil... |
2686 |
if (end != EXT_MAX_BLOCKS - 1) { |
d583fb87a ext4: punch out e... |
2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 |
/* * For hole punching, we need to scoot all the * extents up when an extent is removed so that * we dont have blank extents in the middle */ memmove(ex, ex+1, (EXT_LAST_EXTENT(eh) - ex) * sizeof(struct ext4_extent)); /* Now get rid of the one at the end */ memset(EXT_LAST_EXTENT(eh), 0, sizeof(struct ext4_extent)); } le16_add_cpu(&eh->eh_entries, -1); |
5bf437606 ext4: fix end of ... |
2700 |
} |
d583fb87a ext4: punch out e... |
2701 |
|
750c9c47a ext4: remove mess... |
2702 2703 2704 |
err = ext4_ext_dirty(handle, inode, path + depth); if (err) goto out; |
bf52c6f7a ext4: let ext4_ex... |
2705 2706 |
ext_debug("new extent: %u:%u:%llu ", ex_ee_block, num, |
bf89d16f6 ext4: rename {ext... |
2707 |
ext4_ext_pblock(ex)); |
a86c61812 [PATCH] ext3: add... |
2708 2709 |
ex--; ex_ee_block = le32_to_cpu(ex->ee_block); |
a2df2a634 fallocate support... |
2710 |
ex_ee_len = ext4_ext_get_actual_len(ex); |
a86c61812 [PATCH] ext3: add... |
2711 2712 2713 2714 |
} if (correct_index && eh->eh_entries) err = ext4_ext_correct_indexes(handle, inode, path); |
0aa060000 ext4: teach ext4_... |
2715 |
/* |
ad6599ab3 ext4: fix prematu... |
2716 2717 |
* If there's a partial cluster and at least one extent remains in * the leaf, free the partial cluster if it isn't shared with the |
5bf437606 ext4: fix end of ... |
2718 2719 2720 |
* current extent. If it is shared with the current extent * we zero partial_cluster because we've reached the start of the * truncated/punched region and we're done removing blocks. |
0aa060000 ext4: teach ext4_... |
2721 |
*/ |
5bf437606 ext4: fix end of ... |
2722 2723 2724 2725 2726 2727 2728 2729 |
if (*partial_cluster > 0 && ex >= EXT_FIRST_EXTENT(eh)) { pblk = ext4_ext_pblock(ex) + ex_ee_len - 1; if (*partial_cluster != (long long) EXT4_B2C(sbi, pblk)) { ext4_free_blocks(handle, inode, NULL, EXT4_C2B(sbi, *partial_cluster), sbi->s_cluster_ratio, get_default_free_blocks_flags(inode)); } |
0aa060000 ext4: teach ext4_... |
2730 2731 |
*partial_cluster = 0; } |
a86c61812 [PATCH] ext3: add... |
2732 2733 2734 |
/* if this leaf is free, then we should * remove it from index block above */ if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL) |
c36575e66 ext4: fix extent ... |
2735 |
err = ext4_ext_rm_idx(handle, inode, path, depth); |
a86c61812 [PATCH] ext3: add... |
2736 2737 2738 2739 2740 2741 |
out: return err; } /* |
d0d856e8b [PATCH] ext4: cle... |
2742 2743 |
* ext4_ext_more_to_rm: * returns 1 if current index has to be freed (even partial) |
a86c61812 [PATCH] ext3: add... |
2744 |
*/ |
09b882520 [PATCH] ext4: Eli... |
2745 |
static int |
a86c61812 [PATCH] ext3: add... |
2746 2747 2748 2749 2750 2751 2752 2753 |
ext4_ext_more_to_rm(struct ext4_ext_path *path) { BUG_ON(path->p_idx == NULL); if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr)) return 0; /* |
d0d856e8b [PATCH] ext4: cle... |
2754 |
* if truncate on deeper level happened, it wasn't partial, |
a86c61812 [PATCH] ext3: add... |
2755 2756 2757 2758 2759 2760 |
* so we have to consider current index for truncation */ if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block) return 0; return 1; } |
26a4c0c6c ext4: refactor pu... |
2761 2762 |
int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end) |
a86c61812 [PATCH] ext3: add... |
2763 |
{ |
f4226d9ea ext4: fix partial... |
2764 |
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); |
a86c61812 [PATCH] ext3: add... |
2765 |
int depth = ext_depth(inode); |
968dee772 ext4: fix hole pu... |
2766 |
struct ext4_ext_path *path = NULL; |
d23142c62 ext4: make punch ... |
2767 |
long long partial_cluster = 0; |
a86c61812 [PATCH] ext3: add... |
2768 |
handle_t *handle; |
6f2080e64 ext4: fix ext_rem... |
2769 |
int i = 0, err = 0; |
a86c61812 [PATCH] ext3: add... |
2770 |
|
5f95d21fb ext4: rewrite pun... |
2771 2772 |
ext_debug("truncate since %u to %u ", start, end); |
a86c61812 [PATCH] ext3: add... |
2773 2774 |
/* probably first extent we're gonna free will be last in block */ |
9924a92a8 ext4: pass contex... |
2775 |
handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, depth + 1); |
a86c61812 [PATCH] ext3: add... |
2776 2777 |
if (IS_ERR(handle)) return PTR_ERR(handle); |
0617b83fa ext4: restart ext... |
2778 |
again: |
61801325f ext4: update ext4... |
2779 |
trace_ext4_ext_remove_space(inode, start, end, depth); |
d8990240d ext4: add some tr... |
2780 |
|
a86c61812 [PATCH] ext3: add... |
2781 |
/* |
5f95d21fb ext4: rewrite pun... |
2782 2783 2784 2785 2786 2787 2788 2789 |
* Check if we are removing extents inside the extent tree. If that * is the case, we are going to punch a hole inside the extent tree * so we have to check whether we need to split the extent covering * the last block to remove so we can easily remove the part of it * in ext4_ext_rm_leaf(). */ if (end < EXT_MAX_BLOCKS - 1) { struct ext4_extent *ex; |
f4226d9ea ext4: fix partial... |
2790 2791 |
ext4_lblk_t ee_block, ex_end, lblk; ext4_fsblk_t pblk; |
5f95d21fb ext4: rewrite pun... |
2792 |
|
f4226d9ea ext4: fix partial... |
2793 |
/* find extent for or closest extent to this block */ |
ed8a1a766 ext4: rename ext4... |
2794 |
path = ext4_find_extent(inode, end, NULL, EXT4_EX_NOCACHE); |
5f95d21fb ext4: rewrite pun... |
2795 2796 2797 2798 2799 |
if (IS_ERR(path)) { ext4_journal_stop(handle); return PTR_ERR(path); } depth = ext_depth(inode); |
6f2080e64 ext4: fix ext_rem... |
2800 |
/* Leaf not may not exist only if inode has no blocks at all */ |
5f95d21fb ext4: rewrite pun... |
2801 |
ex = path[depth].p_ext; |
968dee772 ext4: fix hole pu... |
2802 |
if (!ex) { |
6f2080e64 ext4: fix ext_rem... |
2803 2804 2805 2806 |
if (depth) { EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); |
6a797d273 ext4: call out CR... |
2807 |
err = -EFSCORRUPTED; |
6f2080e64 ext4: fix ext_rem... |
2808 2809 |
} goto out; |
968dee772 ext4: fix hole pu... |
2810 |
} |
5f95d21fb ext4: rewrite pun... |
2811 2812 |
ee_block = le32_to_cpu(ex->ee_block); |
f4226d9ea ext4: fix partial... |
2813 |
ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1; |
5f95d21fb ext4: rewrite pun... |
2814 2815 2816 2817 2818 2819 2820 |
/* * See if the last block is inside the extent, if so split * the extent at 'end' block so we can easily remove the * tail of the first part of the split extent in * ext4_ext_rm_leaf(). */ |
f4226d9ea ext4: fix partial... |
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 |
if (end >= ee_block && end < ex_end) { /* * If we're going to split the extent, note that * the cluster containing the block after 'end' is * in use to avoid freeing it when removing blocks. */ if (sbi->s_cluster_ratio > 1) { pblk = ext4_ext_pblock(ex) + end - ee_block + 2; partial_cluster = -(long long) EXT4_B2C(sbi, pblk); } |
5f95d21fb ext4: rewrite pun... |
2833 2834 |
/* * Split the extent in two so that 'end' is the last |
27dd43854 ext4: introduce r... |
2835 2836 2837 |
* block in the first new extent. Also we should not * fail removing space due to ENOSPC so try to use * reserved block if that happens. |
5f95d21fb ext4: rewrite pun... |
2838 |
*/ |
dfe508093 ext4: drop EXT4_E... |
2839 |
err = ext4_force_split_extent_at(handle, inode, &path, |
fcf6b1b72 ext4: refactor ex... |
2840 |
end + 1, 1); |
5f95d21fb ext4: rewrite pun... |
2841 2842 |
if (err < 0) goto out; |
f4226d9ea ext4: fix partial... |
2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 |
} else if (sbi->s_cluster_ratio > 1 && end >= ex_end) { /* * If there's an extent to the right its first cluster * contains the immediate right boundary of the * truncated/punched region. Set partial_cluster to * its negative value so it won't be freed if shared * with the current extent. The end < ee_block case * is handled in ext4_ext_rm_leaf(). */ lblk = ex_end + 1; err = ext4_ext_search_right(inode, path, &lblk, &pblk, &ex); if (err) goto out; if (pblk) partial_cluster = -(long long) EXT4_B2C(sbi, pblk); |
5f95d21fb ext4: rewrite pun... |
2861 |
} |
5f95d21fb ext4: rewrite pun... |
2862 |
} |
5f95d21fb ext4: rewrite pun... |
2863 |
/* |
d0d856e8b [PATCH] ext4: cle... |
2864 2865 |
* We start scanning from right side, freeing all the blocks * after i_size and walking into the tree depth-wise. |
a86c61812 [PATCH] ext3: add... |
2866 |
*/ |
0617b83fa ext4: restart ext... |
2867 |
depth = ext_depth(inode); |
968dee772 ext4: fix hole pu... |
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 |
if (path) { int k = i = depth; while (--k > 0) path[k].p_block = le16_to_cpu(path[k].p_hdr->eh_entries)+1; } else { path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS); if (path == NULL) { ext4_journal_stop(handle); return -ENOMEM; } |
10809df84 ext4: teach ext4_... |
2880 |
path[0].p_maxdepth = path[0].p_depth = depth; |
968dee772 ext4: fix hole pu... |
2881 |
path[0].p_hdr = ext_inode_hdr(inode); |
89a4e48f8 ext4: fix kernel ... |
2882 |
i = 0; |
5f95d21fb ext4: rewrite pun... |
2883 |
|
c349179b4 ext4: print the b... |
2884 |
if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) { |
6a797d273 ext4: call out CR... |
2885 |
err = -EFSCORRUPTED; |
968dee772 ext4: fix hole pu... |
2886 2887 |
goto out; } |
a86c61812 [PATCH] ext3: add... |
2888 |
} |
968dee772 ext4: fix hole pu... |
2889 |
err = 0; |
a86c61812 [PATCH] ext3: add... |
2890 2891 2892 2893 |
while (i >= 0 && err == 0) { if (i == depth) { /* this is leaf block */ |
d583fb87a ext4: punch out e... |
2894 |
err = ext4_ext_rm_leaf(handle, inode, path, |
0aa060000 ext4: teach ext4_... |
2895 |
&partial_cluster, start, |
5f95d21fb ext4: rewrite pun... |
2896 |
end); |
d0d856e8b [PATCH] ext4: cle... |
2897 |
/* root level has p_bh == NULL, brelse() eats this */ |
a86c61812 [PATCH] ext3: add... |
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 |
brelse(path[i].p_bh); path[i].p_bh = NULL; i--; continue; } /* this is index block */ if (!path[i].p_hdr) { ext_debug("initialize header "); path[i].p_hdr = ext_block_hdr(path[i].p_bh); |
a86c61812 [PATCH] ext3: add... |
2909 |
} |
a86c61812 [PATCH] ext3: add... |
2910 |
if (!path[i].p_idx) { |
d0d856e8b [PATCH] ext4: cle... |
2911 |
/* this level hasn't been touched yet */ |
a86c61812 [PATCH] ext3: add... |
2912 2913 2914 2915 2916 2917 2918 |
path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr); path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1; ext_debug("init index ptr: hdr 0x%p, num %d ", path[i].p_hdr, le16_to_cpu(path[i].p_hdr->eh_entries)); } else { |
d0d856e8b [PATCH] ext4: cle... |
2919 |
/* we were already here, see at next index */ |
a86c61812 [PATCH] ext3: add... |
2920 2921 2922 2923 2924 2925 2926 2927 |
path[i].p_idx--; } ext_debug("level %d - index, first 0x%p, cur 0x%p ", i, EXT_FIRST_INDEX(path[i].p_hdr), path[i].p_idx); if (ext4_ext_more_to_rm(path + i)) { |
c29c0ae7f ext4: Make extent... |
2928 |
struct buffer_head *bh; |
a86c61812 [PATCH] ext3: add... |
2929 |
/* go to the next level */ |
2ae021076 [PATCH] ext4: blk... |
2930 2931 |
ext_debug("move to level %d (block %llu) ", |
bf89d16f6 ext4: rename {ext... |
2932 |
i + 1, ext4_idx_pblock(path[i].p_idx)); |
a86c61812 [PATCH] ext3: add... |
2933 |
memset(path + i + 1, 0, sizeof(*path)); |
7d7ea89e7 ext4: refactor co... |
2934 |
bh = read_extent_tree_block(inode, |
107a7bd31 ext4: cache all o... |
2935 2936 |
ext4_idx_pblock(path[i].p_idx), depth - i - 1, EXT4_EX_NOCACHE); |
7d7ea89e7 ext4: refactor co... |
2937 |
if (IS_ERR(bh)) { |
a86c61812 [PATCH] ext3: add... |
2938 |
/* should we reset i_size? */ |
7d7ea89e7 ext4: refactor co... |
2939 |
err = PTR_ERR(bh); |
a86c61812 [PATCH] ext3: add... |
2940 2941 |
break; } |
76828c882 ext4: yield durin... |
2942 2943 2944 |
/* Yield here to deal with large extent trees. * Should be a no-op if we did IO above. */ cond_resched(); |
c29c0ae7f ext4: Make extent... |
2945 |
if (WARN_ON(i + 1 > depth)) { |
6a797d273 ext4: call out CR... |
2946 |
err = -EFSCORRUPTED; |
c29c0ae7f ext4: Make extent... |
2947 2948 2949 |
break; } path[i + 1].p_bh = bh; |
a86c61812 [PATCH] ext3: add... |
2950 |
|
d0d856e8b [PATCH] ext4: cle... |
2951 2952 |
/* save actual number of indexes since this * number is changed at the next iteration */ |
a86c61812 [PATCH] ext3: add... |
2953 2954 2955 |
path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries); i++; } else { |
d0d856e8b [PATCH] ext4: cle... |
2956 |
/* we finished processing this index, go up */ |
a86c61812 [PATCH] ext3: add... |
2957 |
if (path[i].p_hdr->eh_entries == 0 && i > 0) { |
d0d856e8b [PATCH] ext4: cle... |
2958 |
/* index is empty, remove it; |
a86c61812 [PATCH] ext3: add... |
2959 2960 |
* handle must be already prepared by the * truncatei_leaf() */ |
c36575e66 ext4: fix extent ... |
2961 |
err = ext4_ext_rm_idx(handle, inode, path, i); |
a86c61812 [PATCH] ext3: add... |
2962 |
} |
d0d856e8b [PATCH] ext4: cle... |
2963 |
/* root level has p_bh == NULL, brelse() eats this */ |
a86c61812 [PATCH] ext3: add... |
2964 2965 2966 2967 2968 2969 2970 |
brelse(path[i].p_bh); path[i].p_bh = NULL; i--; ext_debug("return to level %d ", i); } } |
61801325f ext4: update ext4... |
2971 2972 |
trace_ext4_ext_remove_space_done(inode, start, end, depth, partial_cluster, path->p_hdr->eh_entries); |
d8990240d ext4: add some tr... |
2973 |
|
0756b908a ext4: fix end of ... |
2974 2975 |
/* * If we still have something in the partial cluster and we have removed |
7b415bf60 ext4: Fix bigallo... |
2976 |
* even the first extent, then we should free the blocks in the partial |
0756b908a ext4: fix end of ... |
2977 2978 2979 2980 2981 |
* cluster as well. (This code will only run when there are no leaves * to the immediate left of the truncated/punched region.) */ if (partial_cluster > 0 && err == 0) { /* don't zero partial_cluster since it's not used afterwards */ |
7b415bf60 ext4: Fix bigallo... |
2982 |
ext4_free_blocks(handle, inode, NULL, |
f4226d9ea ext4: fix partial... |
2983 |
EXT4_C2B(sbi, partial_cluster), |
0756b908a ext4: fix end of ... |
2984 2985 |
sbi->s_cluster_ratio, get_default_free_blocks_flags(inode)); |
7b415bf60 ext4: Fix bigallo... |
2986 |
} |
a86c61812 [PATCH] ext3: add... |
2987 2988 2989 |
/* TODO: flexible tree reduction should be here */ if (path->p_hdr->eh_entries == 0) { /* |
d0d856e8b [PATCH] ext4: cle... |
2990 2991 |
* truncate to zero freed all the tree, * so we need to correct eh_depth |
a86c61812 [PATCH] ext3: add... |
2992 2993 2994 2995 2996 |
*/ err = ext4_ext_get_access(handle, inode, path); if (err == 0) { ext_inode_hdr(inode)->eh_depth = 0; ext_inode_hdr(inode)->eh_max = |
55ad63bf3 ext4: fix extent ... |
2997 |
cpu_to_le16(ext4_ext_space_root(inode, 0)); |
a86c61812 [PATCH] ext3: add... |
2998 2999 3000 3001 |
err = ext4_ext_dirty(handle, inode, path); } } out: |
b7ea89ad0 ext4: allow a NUL... |
3002 3003 3004 |
ext4_ext_drop_refs(path); kfree(path); path = NULL; |
dfe508093 ext4: drop EXT4_E... |
3005 3006 |
if (err == -EAGAIN) goto again; |
a86c61812 [PATCH] ext3: add... |
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 |
ext4_journal_stop(handle); return err; } /* * called at mount time */ void ext4_ext_init(struct super_block *sb) { /* * possible initialization would be here */ |
e2b911c53 ext4: clean up fe... |
3020 |
if (ext4_has_feature_extents(sb)) { |
90576c0b9 ext4, jbd2: Drop ... |
3021 |
#if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS) |
92b978165 ext4: change some... |
3022 |
printk(KERN_INFO "EXT4-fs: file extents enabled" |
bbf2f9fb1 Fix misspellings ... |
3023 |
#ifdef AGGRESSIVE_TEST |
92b978165 ext4: change some... |
3024 |
", aggressive tests" |
a86c61812 [PATCH] ext3: add... |
3025 3026 |
#endif #ifdef CHECK_BINSEARCH |
92b978165 ext4: change some... |
3027 |
", check binsearch" |
a86c61812 [PATCH] ext3: add... |
3028 3029 |
#endif #ifdef EXTENTS_STATS |
92b978165 ext4: change some... |
3030 |
", stats" |
a86c61812 [PATCH] ext3: add... |
3031 |
#endif |
92b978165 ext4: change some... |
3032 3033 |
" "); |
90576c0b9 ext4, jbd2: Drop ... |
3034 |
#endif |
a86c61812 [PATCH] ext3: add... |
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 |
#ifdef EXTENTS_STATS spin_lock_init(&EXT4_SB(sb)->s_ext_stats_lock); EXT4_SB(sb)->s_ext_min = 1 << 30; EXT4_SB(sb)->s_ext_max = 0; #endif } } /* * called at umount time */ void ext4_ext_release(struct super_block *sb) { |
e2b911c53 ext4: clean up fe... |
3048 |
if (!ext4_has_feature_extents(sb)) |
a86c61812 [PATCH] ext3: add... |
3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 |
return; #ifdef EXTENTS_STATS if (EXT4_SB(sb)->s_ext_blocks && EXT4_SB(sb)->s_ext_extents) { struct ext4_sb_info *sbi = EXT4_SB(sb); printk(KERN_ERR "EXT4-fs: %lu blocks in %lu extents (%lu ave) ", sbi->s_ext_blocks, sbi->s_ext_extents, sbi->s_ext_blocks / sbi->s_ext_extents); printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu ", sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max); } #endif } |
d7b2a00c2 ext4: isolate ext... |
3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 |
static int ext4_zeroout_es(struct inode *inode, struct ext4_extent *ex) { ext4_lblk_t ee_block; ext4_fsblk_t ee_pblock; unsigned int ee_len; ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); ee_pblock = ext4_ext_pblock(ex); if (ee_len == 0) return 0; return ext4_es_insert_extent(inode, ee_block, ee_len, ee_pblock, EXTENT_STATUS_WRITTEN); } |
093a088b7 ext4: ENOSPC erro... |
3080 3081 3082 |
/* FIXME!! we need to try to merge to left or right after zero-out */ static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex) { |
2407518de ext4: use sb_issu... |
3083 3084 |
ext4_fsblk_t ee_pblock; unsigned int ee_len; |
093a088b7 ext4: ENOSPC erro... |
3085 |
|
093a088b7 ext4: ENOSPC erro... |
3086 |
ee_len = ext4_ext_get_actual_len(ex); |
bf89d16f6 ext4: rename {ext... |
3087 |
ee_pblock = ext4_ext_pblock(ex); |
53085fac0 ext4: provide ext... |
3088 3089 |
return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock, ee_len); |
093a088b7 ext4: ENOSPC erro... |
3090 |
} |
47ea3bb59 ext4: add ext4_sp... |
3091 |
/* |
47ea3bb59 ext4: add ext4_sp... |
3092 3093 3094 3095 3096 3097 3098 |
* ext4_split_extent_at() splits an extent at given block. * * @handle: the journal handle * @inode: the file inode * @path: the path to the extent * @split: the logical block where the extent is splitted. * @split_flags: indicates if the extent could be zeroout if split fails, and |
556615dcb ext4: rename unin... |
3099 |
* the states(init or unwritten) of new extents. |
47ea3bb59 ext4: add ext4_sp... |
3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 |
* @flags: flags used to insert new extent to extent tree. * * * Splits extent [a, b] into two extents [a, @split) and [@split, b], states * of which are deterimined by split_flag. * * There are two cases: * a> the extent are splitted into two extent. * b> split is not needed, and just mark the extent. * * return 0 on success. */ static int ext4_split_extent_at(handle_t *handle, struct inode *inode, |
dfe508093 ext4: drop EXT4_E... |
3114 |
struct ext4_ext_path **ppath, |
47ea3bb59 ext4: add ext4_sp... |
3115 3116 3117 3118 |
ext4_lblk_t split, int split_flag, int flags) { |
dfe508093 ext4: drop EXT4_E... |
3119 |
struct ext4_ext_path *path = *ppath; |
47ea3bb59 ext4: add ext4_sp... |
3120 3121 |
ext4_fsblk_t newblock; ext4_lblk_t ee_block; |
adb235510 ext4: update exte... |
3122 |
struct ext4_extent *ex, newex, orig_ex, zero_ex; |
47ea3bb59 ext4: add ext4_sp... |
3123 3124 3125 |
struct ext4_extent *ex2 = NULL; unsigned int ee_len, depth; int err = 0; |
dee1f973c ext4: race-condit... |
3126 3127 |
BUG_ON((split_flag & (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2)) == (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2)); |
47ea3bb59 ext4: add ext4_sp... |
3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 |
ext_debug("ext4_split_extents_at: inode %lu, logical" "block %llu ", inode->i_ino, (unsigned long long)split); ext4_ext_show_leaf(inode, path); depth = ext_depth(inode); ex = path[depth].p_ext; ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); newblock = split - ee_block + ext4_ext_pblock(ex); BUG_ON(split < ee_block || split >= (ee_block + ee_len)); |
556615dcb ext4: rename unin... |
3141 |
BUG_ON(!ext4_ext_is_unwritten(ex) && |
357b66fdc ext4: ext4_split_... |
3142 |
split_flag & (EXT4_EXT_MAY_ZEROOUT | |
556615dcb ext4: rename unin... |
3143 3144 |
EXT4_EXT_MARK_UNWRIT1 | EXT4_EXT_MARK_UNWRIT2)); |
47ea3bb59 ext4: add ext4_sp... |
3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) goto out; if (split == ee_block) { /* * case b: block @split is the block that the extent begins with * then we just change the state of the extent, and splitting * is not needed. */ |
556615dcb ext4: rename unin... |
3156 3157 |
if (split_flag & EXT4_EXT_MARK_UNWRIT2) ext4_ext_mark_unwritten(ex); |
47ea3bb59 ext4: add ext4_sp... |
3158 3159 3160 3161 |
else ext4_ext_mark_initialized(ex); if (!(flags & EXT4_GET_BLOCKS_PRE_IO)) |
ecb94f5fd ext4: collapse a ... |
3162 |
ext4_ext_try_to_merge(handle, inode, path, ex); |
47ea3bb59 ext4: add ext4_sp... |
3163 |
|
ecb94f5fd ext4: collapse a ... |
3164 |
err = ext4_ext_dirty(handle, inode, path + path->p_depth); |
47ea3bb59 ext4: add ext4_sp... |
3165 3166 3167 3168 3169 3170 |
goto out; } /* case a */ memcpy(&orig_ex, ex, sizeof(orig_ex)); ex->ee_len = cpu_to_le16(split - ee_block); |
556615dcb ext4: rename unin... |
3171 3172 |
if (split_flag & EXT4_EXT_MARK_UNWRIT1) ext4_ext_mark_unwritten(ex); |
47ea3bb59 ext4: add ext4_sp... |
3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 |
/* * path may lead to new leaf, not to original leaf any more * after ext4_ext_insert_extent() returns, */ err = ext4_ext_dirty(handle, inode, path + depth); if (err) goto fix_extent_len; ex2 = &newex; ex2->ee_block = cpu_to_le32(split); ex2->ee_len = cpu_to_le16(ee_len - (split - ee_block)); ext4_ext_store_pblock(ex2, newblock); |
556615dcb ext4: rename unin... |
3186 3187 |
if (split_flag & EXT4_EXT_MARK_UNWRIT2) ext4_ext_mark_unwritten(ex2); |
47ea3bb59 ext4: add ext4_sp... |
3188 |
|
dfe508093 ext4: drop EXT4_E... |
3189 |
err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags); |
47ea3bb59 ext4: add ext4_sp... |
3190 |
if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) { |
dee1f973c ext4: race-condit... |
3191 |
if (split_flag & (EXT4_EXT_DATA_VALID1|EXT4_EXT_DATA_VALID2)) { |
adb235510 ext4: update exte... |
3192 |
if (split_flag & EXT4_EXT_DATA_VALID1) { |
dee1f973c ext4: race-condit... |
3193 |
err = ext4_ext_zeroout(inode, ex2); |
adb235510 ext4: update exte... |
3194 |
zero_ex.ee_block = ex2->ee_block; |
8cde7ad17 ext4: fix big-end... |
3195 3196 |
zero_ex.ee_len = cpu_to_le16( ext4_ext_get_actual_len(ex2)); |
adb235510 ext4: update exte... |
3197 3198 3199 |
ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(ex2)); } else { |
dee1f973c ext4: race-condit... |
3200 |
err = ext4_ext_zeroout(inode, ex); |
adb235510 ext4: update exte... |
3201 |
zero_ex.ee_block = ex->ee_block; |
8cde7ad17 ext4: fix big-end... |
3202 3203 |
zero_ex.ee_len = cpu_to_le16( ext4_ext_get_actual_len(ex)); |
adb235510 ext4: update exte... |
3204 3205 3206 3207 |
ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(ex)); } } else { |
dee1f973c ext4: race-condit... |
3208 |
err = ext4_ext_zeroout(inode, &orig_ex); |
adb235510 ext4: update exte... |
3209 |
zero_ex.ee_block = orig_ex.ee_block; |
8cde7ad17 ext4: fix big-end... |
3210 3211 |
zero_ex.ee_len = cpu_to_le16( ext4_ext_get_actual_len(&orig_ex)); |
adb235510 ext4: update exte... |
3212 3213 3214 |
ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(&orig_ex)); } |
dee1f973c ext4: race-condit... |
3215 |
|
47ea3bb59 ext4: add ext4_sp... |
3216 3217 3218 |
if (err) goto fix_extent_len; /* update the extent length and mark as initialized */ |
af1584f57 ext4: fix endiann... |
3219 |
ex->ee_len = cpu_to_le16(ee_len); |
ecb94f5fd ext4: collapse a ... |
3220 3221 |
ext4_ext_try_to_merge(handle, inode, path, ex); err = ext4_ext_dirty(handle, inode, path + path->p_depth); |
adb235510 ext4: update exte... |
3222 3223 3224 3225 |
if (err) goto fix_extent_len; /* update extent status tree */ |
d7b2a00c2 ext4: isolate ext... |
3226 |
err = ext4_zeroout_es(inode, &zero_ex); |
adb235510 ext4: update exte... |
3227 |
|
47ea3bb59 ext4: add ext4_sp... |
3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 |
goto out; } else if (err) goto fix_extent_len; out: ext4_ext_show_leaf(inode, path); return err; fix_extent_len: ex->ee_len = orig_ex.ee_len; |
29faed163 ext4: use correct... |
3238 |
ext4_ext_dirty(handle, inode, path + path->p_depth); |
47ea3bb59 ext4: add ext4_sp... |
3239 3240 3241 3242 3243 3244 3245 |
return err; } /* * ext4_split_extents() splits an extent and mark extent which is covered * by @map as split_flags indicates * |
70261f568 ext4: Fix misspel... |
3246 |
* It may result in splitting the extent into multiple extents (up to three) |
47ea3bb59 ext4: add ext4_sp... |
3247 3248 3249 3250 3251 3252 3253 3254 |
* There are three possibilities: * a> There is no split required * b> Splits in two extents: Split is happening at either end of the extent * c> Splits in three extents: Somone is splitting in middle of the extent * */ static int ext4_split_extent(handle_t *handle, struct inode *inode, |
dfe508093 ext4: drop EXT4_E... |
3255 |
struct ext4_ext_path **ppath, |
47ea3bb59 ext4: add ext4_sp... |
3256 3257 3258 3259 |
struct ext4_map_blocks *map, int split_flag, int flags) { |
dfe508093 ext4: drop EXT4_E... |
3260 |
struct ext4_ext_path *path = *ppath; |
47ea3bb59 ext4: add ext4_sp... |
3261 3262 3263 3264 |
ext4_lblk_t ee_block; struct ext4_extent *ex; unsigned int ee_len, depth; int err = 0; |
556615dcb ext4: rename unin... |
3265 |
int unwritten; |
47ea3bb59 ext4: add ext4_sp... |
3266 |
int split_flag1, flags1; |
3a2256702 ext4: fix the wro... |
3267 |
int allocated = map->m_len; |
47ea3bb59 ext4: add ext4_sp... |
3268 3269 3270 3271 3272 |
depth = ext_depth(inode); ex = path[depth].p_ext; ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); |
556615dcb ext4: rename unin... |
3273 |
unwritten = ext4_ext_is_unwritten(ex); |
47ea3bb59 ext4: add ext4_sp... |
3274 3275 |
if (map->m_lblk + map->m_len < ee_block + ee_len) { |
dee1f973c ext4: race-condit... |
3276 |
split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT; |
47ea3bb59 ext4: add ext4_sp... |
3277 |
flags1 = flags | EXT4_GET_BLOCKS_PRE_IO; |
556615dcb ext4: rename unin... |
3278 3279 3280 |
if (unwritten) split_flag1 |= EXT4_EXT_MARK_UNWRIT1 | EXT4_EXT_MARK_UNWRIT2; |
dee1f973c ext4: race-condit... |
3281 3282 |
if (split_flag & EXT4_EXT_DATA_VALID2) split_flag1 |= EXT4_EXT_DATA_VALID1; |
dfe508093 ext4: drop EXT4_E... |
3283 |
err = ext4_split_extent_at(handle, inode, ppath, |
47ea3bb59 ext4: add ext4_sp... |
3284 |
map->m_lblk + map->m_len, split_flag1, flags1); |
93917411b ext4: make ext4_s... |
3285 3286 |
if (err) goto out; |
3a2256702 ext4: fix the wro... |
3287 3288 |
} else { allocated = ee_len - (map->m_lblk - ee_block); |
47ea3bb59 ext4: add ext4_sp... |
3289 |
} |
357b66fdc ext4: ext4_split_... |
3290 3291 3292 3293 |
/* * Update path is required because previous ext4_split_extent_at() may * result in split of original leaf or extent zeroout. */ |
ed8a1a766 ext4: rename ext4... |
3294 |
path = ext4_find_extent(inode, map->m_lblk, ppath, 0); |
47ea3bb59 ext4: add ext4_sp... |
3295 3296 |
if (IS_ERR(path)) return PTR_ERR(path); |
357b66fdc ext4: ext4_split_... |
3297 3298 |
depth = ext_depth(inode); ex = path[depth].p_ext; |
a18ed359b ext4: always chec... |
3299 3300 3301 |
if (!ex) { EXT4_ERROR_INODE(inode, "unexpected hole at %lu", (unsigned long) map->m_lblk); |
6a797d273 ext4: call out CR... |
3302 |
return -EFSCORRUPTED; |
a18ed359b ext4: always chec... |
3303 |
} |
556615dcb ext4: rename unin... |
3304 |
unwritten = ext4_ext_is_unwritten(ex); |
357b66fdc ext4: ext4_split_... |
3305 |
split_flag1 = 0; |
47ea3bb59 ext4: add ext4_sp... |
3306 3307 |
if (map->m_lblk >= ee_block) { |
357b66fdc ext4: ext4_split_... |
3308 |
split_flag1 = split_flag & EXT4_EXT_DATA_VALID2; |
556615dcb ext4: rename unin... |
3309 3310 |
if (unwritten) { split_flag1 |= EXT4_EXT_MARK_UNWRIT1; |
357b66fdc ext4: ext4_split_... |
3311 |
split_flag1 |= split_flag & (EXT4_EXT_MAY_ZEROOUT | |
556615dcb ext4: rename unin... |
3312 |
EXT4_EXT_MARK_UNWRIT2); |
357b66fdc ext4: ext4_split_... |
3313 |
} |
dfe508093 ext4: drop EXT4_E... |
3314 |
err = ext4_split_extent_at(handle, inode, ppath, |
47ea3bb59 ext4: add ext4_sp... |
3315 3316 3317 3318 3319 3320 3321 |
map->m_lblk, split_flag1, flags); if (err) goto out; } ext4_ext_show_leaf(inode, path); out: |
3a2256702 ext4: fix the wro... |
3322 |
return err ? err : allocated; |
47ea3bb59 ext4: add ext4_sp... |
3323 |
} |
56055d3ae write support for... |
3324 |
/* |
e35fd6609 ext4: Add new abs... |
3325 |
* This function is called by ext4_ext_map_blocks() if someone tries to write |
556615dcb ext4: rename unin... |
3326 |
* to an unwritten extent. It may result in splitting the unwritten |
25985edce Fix common misspe... |
3327 |
* extent into multiple extents (up to three - one initialized and two |
556615dcb ext4: rename unin... |
3328 |
* unwritten). |
56055d3ae write support for... |
3329 3330 3331 3332 |
* There are three possibilities: * a> There is no split required: Entire extent should be initialized * b> Splits in two extents: Write is happening at either end of the extent * c> Splits in three extents: Somone is writing in middle of the extent |
6f91bc5fd ext4: optimize ex... |
3333 3334 |
* * Pre-conditions: |
556615dcb ext4: rename unin... |
3335 |
* - The extent pointed to by 'path' is unwritten. |
6f91bc5fd ext4: optimize ex... |
3336 3337 3338 3339 3340 3341 3342 |
* - The extent pointed to by 'path' contains a superset * of the logical span [map->m_lblk, map->m_lblk + map->m_len). * * Post-conditions on success: * - the returned value is the number of blocks beyond map->l_lblk * that are allocated and initialized. * It is guaranteed to be >= map->m_len. |
56055d3ae write support for... |
3343 |
*/ |
725d26d3f ext4: Introduce e... |
3344 |
static int ext4_ext_convert_to_initialized(handle_t *handle, |
e35fd6609 ext4: Add new abs... |
3345 3346 |
struct inode *inode, struct ext4_map_blocks *map, |
dfe508093 ext4: drop EXT4_E... |
3347 |
struct ext4_ext_path **ppath, |
27dd43854 ext4: introduce r... |
3348 |
int flags) |
56055d3ae write support for... |
3349 |
{ |
dfe508093 ext4: drop EXT4_E... |
3350 |
struct ext4_ext_path *path = *ppath; |
67a5da564 ext4: make the ze... |
3351 |
struct ext4_sb_info *sbi; |
6f91bc5fd ext4: optimize ex... |
3352 |
struct ext4_extent_header *eh; |
667eff35a ext4: reimplement... |
3353 3354 |
struct ext4_map_blocks split_map; struct ext4_extent zero_ex; |
bc2d9db48 ext4: Transfer in... |
3355 |
struct ext4_extent *ex, *abut_ex; |
21ca087a3 ext4: Do not zero... |
3356 |
ext4_lblk_t ee_block, eof_block; |
bc2d9db48 ext4: Transfer in... |
3357 3358 |
unsigned int ee_len, depth, map_len = map->m_len; int allocated = 0, max_zeroout = 0; |
56055d3ae write support for... |
3359 |
int err = 0; |
667eff35a ext4: reimplement... |
3360 |
int split_flag = 0; |
21ca087a3 ext4: Do not zero... |
3361 3362 3363 3364 |
ext_debug("ext4_ext_convert_to_initialized: inode %lu, logical" "block %llu, max_blocks %u ", inode->i_ino, |
bc2d9db48 ext4: Transfer in... |
3365 |
(unsigned long long)map->m_lblk, map_len); |
21ca087a3 ext4: Do not zero... |
3366 |
|
67a5da564 ext4: make the ze... |
3367 |
sbi = EXT4_SB(inode->i_sb); |
21ca087a3 ext4: Do not zero... |
3368 3369 |
eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits; |
bc2d9db48 ext4: Transfer in... |
3370 3371 |
if (eof_block < map->m_lblk + map_len) eof_block = map->m_lblk + map_len; |
56055d3ae write support for... |
3372 3373 |
depth = ext_depth(inode); |
6f91bc5fd ext4: optimize ex... |
3374 |
eh = path[depth].p_hdr; |
56055d3ae write support for... |
3375 3376 3377 |
ex = path[depth].p_ext; ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); |
adb235510 ext4: update exte... |
3378 |
zero_ex.ee_len = 0; |
56055d3ae write support for... |
3379 |
|
6f91bc5fd ext4: optimize ex... |
3380 3381 3382 |
trace_ext4_ext_convert_to_initialized_enter(inode, map, ex); /* Pre-conditions */ |
556615dcb ext4: rename unin... |
3383 |
BUG_ON(!ext4_ext_is_unwritten(ex)); |
6f91bc5fd ext4: optimize ex... |
3384 |
BUG_ON(!in_range(map->m_lblk, ee_block, ee_len)); |
6f91bc5fd ext4: optimize ex... |
3385 3386 3387 |
/* * Attempt to transfer newly initialized blocks from the currently |
556615dcb ext4: rename unin... |
3388 |
* unwritten extent to its neighbor. This is much cheaper |
6f91bc5fd ext4: optimize ex... |
3389 |
* than an insertion followed by a merge as those involve costly |
bc2d9db48 ext4: Transfer in... |
3390 3391 3392 |
* memmove() calls. Transferring to the left is the common case in * steady state for workloads doing fallocate(FALLOC_FL_KEEP_SIZE) * followed by append writes. |
6f91bc5fd ext4: optimize ex... |
3393 3394 |
* * Limitations of the current logic: |
bc2d9db48 ext4: Transfer in... |
3395 |
* - L1: we do not deal with writes covering the whole extent. |
6f91bc5fd ext4: optimize ex... |
3396 3397 |
* This would require removing the extent if the transfer * is possible. |
bc2d9db48 ext4: Transfer in... |
3398 |
* - L2: we only attempt to merge with an extent stored in the |
6f91bc5fd ext4: optimize ex... |
3399 3400 |
* same extent tree node. */ |
bc2d9db48 ext4: Transfer in... |
3401 3402 3403 3404 |
if ((map->m_lblk == ee_block) && /* See if we can merge left */ (map_len < ee_len) && /*L1*/ (ex > EXT_FIRST_EXTENT(eh))) { /*L2*/ |
6f91bc5fd ext4: optimize ex... |
3405 3406 |
ext4_lblk_t prev_lblk; ext4_fsblk_t prev_pblk, ee_pblk; |
bc2d9db48 ext4: Transfer in... |
3407 |
unsigned int prev_len; |
6f91bc5fd ext4: optimize ex... |
3408 |
|
bc2d9db48 ext4: Transfer in... |
3409 3410 3411 3412 |
abut_ex = ex - 1; prev_lblk = le32_to_cpu(abut_ex->ee_block); prev_len = ext4_ext_get_actual_len(abut_ex); prev_pblk = ext4_ext_pblock(abut_ex); |
6f91bc5fd ext4: optimize ex... |
3413 |
ee_pblk = ext4_ext_pblock(ex); |
6f91bc5fd ext4: optimize ex... |
3414 3415 |
/* |
bc2d9db48 ext4: Transfer in... |
3416 |
* A transfer of blocks from 'ex' to 'abut_ex' is allowed |
6f91bc5fd ext4: optimize ex... |
3417 |
* upon those conditions: |
bc2d9db48 ext4: Transfer in... |
3418 3419 3420 3421 |
* - C1: abut_ex is initialized, * - C2: abut_ex is logically abutting ex, * - C3: abut_ex is physically abutting ex, * - C4: abut_ex can receive the additional blocks without |
6f91bc5fd ext4: optimize ex... |
3422 3423 |
* overflowing the (initialized) length limit. */ |
556615dcb ext4: rename unin... |
3424 |
if ((!ext4_ext_is_unwritten(abut_ex)) && /*C1*/ |
6f91bc5fd ext4: optimize ex... |
3425 3426 |
((prev_lblk + prev_len) == ee_block) && /*C2*/ ((prev_pblk + prev_len) == ee_pblk) && /*C3*/ |
bc2d9db48 ext4: Transfer in... |
3427 |
(prev_len < (EXT_INIT_MAX_LEN - map_len))) { /*C4*/ |
6f91bc5fd ext4: optimize ex... |
3428 3429 3430 3431 3432 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) goto out; trace_ext4_ext_convert_to_initialized_fastpath(inode, |
bc2d9db48 ext4: Transfer in... |
3433 |
map, ex, abut_ex); |
6f91bc5fd ext4: optimize ex... |
3434 |
|
bc2d9db48 ext4: Transfer in... |
3435 3436 3437 3438 |
/* Shift the start of ex by 'map_len' blocks */ ex->ee_block = cpu_to_le32(ee_block + map_len); ext4_ext_store_pblock(ex, ee_pblk + map_len); ex->ee_len = cpu_to_le16(ee_len - map_len); |
556615dcb ext4: rename unin... |
3439 |
ext4_ext_mark_unwritten(ex); /* Restore the flag */ |
6f91bc5fd ext4: optimize ex... |
3440 |
|
bc2d9db48 ext4: Transfer in... |
3441 3442 |
/* Extend abut_ex by 'map_len' blocks */ abut_ex->ee_len = cpu_to_le16(prev_len + map_len); |
6f91bc5fd ext4: optimize ex... |
3443 |
|
bc2d9db48 ext4: Transfer in... |
3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 |
/* Result: number of initialized blocks past m_lblk */ allocated = map_len; } } else if (((map->m_lblk + map_len) == (ee_block + ee_len)) && (map_len < ee_len) && /*L1*/ ex < EXT_LAST_EXTENT(eh)) { /*L2*/ /* See if we can merge right */ ext4_lblk_t next_lblk; ext4_fsblk_t next_pblk, ee_pblk; unsigned int next_len; abut_ex = ex + 1; next_lblk = le32_to_cpu(abut_ex->ee_block); next_len = ext4_ext_get_actual_len(abut_ex); next_pblk = ext4_ext_pblock(abut_ex); ee_pblk = ext4_ext_pblock(ex); |
6f91bc5fd ext4: optimize ex... |
3460 |
|
bc2d9db48 ext4: Transfer in... |
3461 3462 3463 3464 3465 3466 3467 3468 3469 |
/* * A transfer of blocks from 'ex' to 'abut_ex' is allowed * upon those conditions: * - C1: abut_ex is initialized, * - C2: abut_ex is logically abutting ex, * - C3: abut_ex is physically abutting ex, * - C4: abut_ex can receive the additional blocks without * overflowing the (initialized) length limit. */ |
556615dcb ext4: rename unin... |
3470 |
if ((!ext4_ext_is_unwritten(abut_ex)) && /*C1*/ |
bc2d9db48 ext4: Transfer in... |
3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 |
((map->m_lblk + map_len) == next_lblk) && /*C2*/ ((ee_pblk + ee_len) == next_pblk) && /*C3*/ (next_len < (EXT_INIT_MAX_LEN - map_len))) { /*C4*/ err = ext4_ext_get_access(handle, inode, path + depth); if (err) goto out; trace_ext4_ext_convert_to_initialized_fastpath(inode, map, ex, abut_ex); /* Shift the start of abut_ex by 'map_len' blocks */ abut_ex->ee_block = cpu_to_le32(next_lblk - map_len); ext4_ext_store_pblock(abut_ex, next_pblk - map_len); ex->ee_len = cpu_to_le16(ee_len - map_len); |
556615dcb ext4: rename unin... |
3485 |
ext4_ext_mark_unwritten(ex); /* Restore the flag */ |
bc2d9db48 ext4: Transfer in... |
3486 3487 3488 |
/* Extend abut_ex by 'map_len' blocks */ abut_ex->ee_len = cpu_to_le16(next_len + map_len); |
6f91bc5fd ext4: optimize ex... |
3489 3490 |
/* Result: number of initialized blocks past m_lblk */ |
bc2d9db48 ext4: Transfer in... |
3491 |
allocated = map_len; |
6f91bc5fd ext4: optimize ex... |
3492 3493 |
} } |
bc2d9db48 ext4: Transfer in... |
3494 3495 3496 3497 3498 3499 3500 3501 3502 |
if (allocated) { /* Mark the block containing both extents as dirty */ ext4_ext_dirty(handle, inode, path + depth); /* Update path to point to the right extent */ path[depth].p_ext = abut_ex; goto out; } else allocated = ee_len - (map->m_lblk - ee_block); |
6f91bc5fd ext4: optimize ex... |
3503 |
|
667eff35a ext4: reimplement... |
3504 |
WARN_ON(map->m_lblk < ee_block); |
21ca087a3 ext4: Do not zero... |
3505 3506 |
/* * It is safe to convert extent to initialized via explicit |
9e740568b ext4: fix a typo ... |
3507 |
* zeroout only if extent is fully inside i_size or new_size. |
21ca087a3 ext4: Do not zero... |
3508 |
*/ |
667eff35a ext4: reimplement... |
3509 |
split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0; |
21ca087a3 ext4: Do not zero... |
3510 |
|
67a5da564 ext4: make the ze... |
3511 3512 |
if (EXT4_EXT_MAY_ZEROOUT & split_flag) max_zeroout = sbi->s_extent_max_zeroout_kb >> |
4f42f80a8 ext4: use s_exten... |
3513 |
(inode->i_sb->s_blocksize_bits - 10); |
67a5da564 ext4: make the ze... |
3514 |
|
36086d43f ext4 crypto: fix ... |
3515 3516 |
if (ext4_encrypted_inode(inode)) max_zeroout = 0; |
67a5da564 ext4: make the ze... |
3517 3518 |
/* If extent is less than s_max_zeroout_kb, zeroout directly */ if (max_zeroout && (ee_len <= max_zeroout)) { |
667eff35a ext4: reimplement... |
3519 |
err = ext4_ext_zeroout(inode, ex); |
3977c965e ext4: zero out sm... |
3520 |
if (err) |
d03856bd5 ext4: Fix data co... |
3521 |
goto out; |
adb235510 ext4: update exte... |
3522 |
zero_ex.ee_block = ex->ee_block; |
8cde7ad17 ext4: fix big-end... |
3523 |
zero_ex.ee_len = cpu_to_le16(ext4_ext_get_actual_len(ex)); |
adb235510 ext4: update exte... |
3524 |
ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(ex)); |
d03856bd5 ext4: Fix data co... |
3525 3526 3527 3528 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) goto out; |
667eff35a ext4: reimplement... |
3529 |
ext4_ext_mark_initialized(ex); |
ecb94f5fd ext4: collapse a ... |
3530 3531 |
ext4_ext_try_to_merge(handle, inode, path, ex); err = ext4_ext_dirty(handle, inode, path + path->p_depth); |
667eff35a ext4: reimplement... |
3532 |
goto out; |
56055d3ae write support for... |
3533 |
} |
667eff35a ext4: reimplement... |
3534 |
|
56055d3ae write support for... |
3535 |
/* |
667eff35a ext4: reimplement... |
3536 3537 3538 3539 3540 |
* four cases: * 1. split the extent into three extents. * 2. split the extent into two extents, zeroout the first half. * 3. split the extent into two extents, zeroout the second half. * 4. split the extent into two extents with out zeroout. |
56055d3ae write support for... |
3541 |
*/ |
667eff35a ext4: reimplement... |
3542 3543 |
split_map.m_lblk = map->m_lblk; split_map.m_len = map->m_len; |
67a5da564 ext4: make the ze... |
3544 3545 |
if (max_zeroout && (allocated > map->m_len)) { if (allocated <= max_zeroout) { |
667eff35a ext4: reimplement... |
3546 3547 |
/* case 3 */ zero_ex.ee_block = |
9b940f8e8 ext4: ext4_ext_co... |
3548 3549 |
cpu_to_le32(map->m_lblk); zero_ex.ee_len = cpu_to_le16(allocated); |
667eff35a ext4: reimplement... |
3550 3551 3552 |
ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(ex) + map->m_lblk - ee_block); err = ext4_ext_zeroout(inode, &zero_ex); |
56055d3ae write support for... |
3553 3554 |
if (err) goto out; |
667eff35a ext4: reimplement... |
3555 3556 |
split_map.m_lblk = map->m_lblk; split_map.m_len = allocated; |
67a5da564 ext4: make the ze... |
3557 |
} else if (map->m_lblk - ee_block + map->m_len < max_zeroout) { |
667eff35a ext4: reimplement... |
3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 |
/* case 2 */ if (map->m_lblk != ee_block) { zero_ex.ee_block = ex->ee_block; zero_ex.ee_len = cpu_to_le16(map->m_lblk - ee_block); ext4_ext_store_pblock(&zero_ex, ext4_ext_pblock(ex)); err = ext4_ext_zeroout(inode, &zero_ex); if (err) goto out; } |
667eff35a ext4: reimplement... |
3569 |
split_map.m_lblk = ee_block; |
9b940f8e8 ext4: ext4_ext_co... |
3570 3571 |
split_map.m_len = map->m_lblk - ee_block + map->m_len; allocated = map->m_len; |
56055d3ae write support for... |
3572 3573 |
} } |
667eff35a ext4: reimplement... |
3574 |
|
ae9e9c6ae ext4: make ext4_e... |
3575 3576 3577 3578 |
err = ext4_split_extent(handle, inode, ppath, &split_map, split_flag, flags); if (err > 0) err = 0; |
56055d3ae write support for... |
3579 |
out: |
adb235510 ext4: update exte... |
3580 3581 |
/* If we have gotten a failure, don't zero out status tree */ if (!err) |
d7b2a00c2 ext4: isolate ext... |
3582 |
err = ext4_zeroout_es(inode, &zero_ex); |
56055d3ae write support for... |
3583 3584 |
return err ? err : allocated; } |
c278bfece ext4: Make ext4_g... |
3585 |
/* |
e35fd6609 ext4: Add new abs... |
3586 |
* This function is called by ext4_ext_map_blocks() from |
0031462b5 ext4: Split unini... |
3587 |
* ext4_get_blocks_dio_write() when DIO to write |
556615dcb ext4: rename unin... |
3588 |
* to an unwritten extent. |
0031462b5 ext4: Split unini... |
3589 |
* |
556615dcb ext4: rename unin... |
3590 3591 |
* Writing to an unwritten extent may result in splitting the unwritten * extent into multiple initialized/unwritten extents (up to three) |
0031462b5 ext4: Split unini... |
3592 |
* There are three possibilities: |
556615dcb ext4: rename unin... |
3593 |
* a> There is no split required: Entire extent should be unwritten |
0031462b5 ext4: Split unini... |
3594 3595 3596 |
* b> Splits in two extents: Write is happening at either end of the extent * c> Splits in three extents: Somone is writing in middle of the extent * |
b8a868450 ext4: Introduce F... |
3597 3598 |
* This works the same way in the case of initialized -> unwritten conversion. * |
0031462b5 ext4: Split unini... |
3599 |
* One of more index blocks maybe needed if the extent tree grow after |
556615dcb ext4: rename unin... |
3600 3601 3602 3603 |
* the unwritten extent split. To prevent ENOSPC occur at the IO * complete, we need to split the unwritten extent before DIO submit * the IO. The unwritten extent called at this time will be split * into three unwritten extent(at most). After IO complete, the part |
0031462b5 ext4: Split unini... |
3604 3605 |
* being filled will be convert to initialized by the end_io callback function * via ext4_convert_unwritten_extents(). |
ba230c3f6 ext4: Fix return ... |
3606 |
* |
556615dcb ext4: rename unin... |
3607 |
* Returns the size of unwritten extent to be written on success. |
0031462b5 ext4: Split unini... |
3608 |
*/ |
b8a868450 ext4: Introduce F... |
3609 |
static int ext4_split_convert_extents(handle_t *handle, |
0031462b5 ext4: Split unini... |
3610 |
struct inode *inode, |
e35fd6609 ext4: Add new abs... |
3611 |
struct ext4_map_blocks *map, |
dfe508093 ext4: drop EXT4_E... |
3612 |
struct ext4_ext_path **ppath, |
0031462b5 ext4: Split unini... |
3613 3614 |
int flags) { |
dfe508093 ext4: drop EXT4_E... |
3615 |
struct ext4_ext_path *path = *ppath; |
667eff35a ext4: reimplement... |
3616 3617 3618 3619 3620 |
ext4_lblk_t eof_block; ext4_lblk_t ee_block; struct ext4_extent *ex; unsigned int ee_len; int split_flag = 0, depth; |
21ca087a3 ext4: Do not zero... |
3621 |
|
b8a868450 ext4: Introduce F... |
3622 3623 3624 3625 |
ext_debug("%s: inode %lu, logical block %llu, max_blocks %u ", __func__, inode->i_ino, (unsigned long long)map->m_lblk, map->m_len); |
21ca087a3 ext4: Do not zero... |
3626 3627 3628 |
eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits; |
e35fd6609 ext4: Add new abs... |
3629 3630 |
if (eof_block < map->m_lblk + map->m_len) eof_block = map->m_lblk + map->m_len; |
0031462b5 ext4: Split unini... |
3631 |
/* |
21ca087a3 ext4: Do not zero... |
3632 3633 3634 |
* It is safe to convert extent to initialized via explicit * zeroout only if extent is fully insde i_size or new_size. */ |
667eff35a ext4: reimplement... |
3635 3636 3637 3638 |
depth = ext_depth(inode); ex = path[depth].p_ext; ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); |
0031462b5 ext4: Split unini... |
3639 |
|
b8a868450 ext4: Introduce F... |
3640 3641 3642 3643 3644 3645 3646 |
/* Convert to unwritten */ if (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN) { split_flag |= EXT4_EXT_DATA_VALID1; /* Convert to initialized */ } else if (flags & EXT4_GET_BLOCKS_CONVERT) { split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0; |
556615dcb ext4: rename unin... |
3647 |
split_flag |= (EXT4_EXT_MARK_UNWRIT2 | EXT4_EXT_DATA_VALID2); |
b8a868450 ext4: Introduce F... |
3648 |
} |
667eff35a ext4: reimplement... |
3649 |
flags |= EXT4_GET_BLOCKS_PRE_IO; |
dfe508093 ext4: drop EXT4_E... |
3650 |
return ext4_split_extent(handle, inode, ppath, map, split_flag, flags); |
0031462b5 ext4: Split unini... |
3651 |
} |
197217a5a ext4: add a funct... |
3652 |
|
c7064ef13 ext4: mechanical ... |
3653 |
static int ext4_convert_unwritten_extents_endio(handle_t *handle, |
dee1f973c ext4: race-condit... |
3654 3655 |
struct inode *inode, struct ext4_map_blocks *map, |
dfe508093 ext4: drop EXT4_E... |
3656 |
struct ext4_ext_path **ppath) |
0031462b5 ext4: Split unini... |
3657 |
{ |
dfe508093 ext4: drop EXT4_E... |
3658 |
struct ext4_ext_path *path = *ppath; |
0031462b5 ext4: Split unini... |
3659 |
struct ext4_extent *ex; |
dee1f973c ext4: race-condit... |
3660 3661 |
ext4_lblk_t ee_block; unsigned int ee_len; |
0031462b5 ext4: Split unini... |
3662 3663 |
int depth; int err = 0; |
0031462b5 ext4: Split unini... |
3664 3665 |
depth = ext_depth(inode); |
0031462b5 ext4: Split unini... |
3666 |
ex = path[depth].p_ext; |
dee1f973c ext4: race-condit... |
3667 3668 |
ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); |
0031462b5 ext4: Split unini... |
3669 |
|
197217a5a ext4: add a funct... |
3670 3671 3672 |
ext_debug("ext4_convert_unwritten_extents_endio: inode %lu, logical" "block %llu, max_blocks %u ", inode->i_ino, |
dee1f973c ext4: race-condit... |
3673 |
(unsigned long long)ee_block, ee_len); |
ff95ec22c ext4: add warning... |
3674 3675 3676 3677 3678 3679 |
/* If extent is larger than requested it is a clear sign that we still * have some extent state machine issues left. So extent_split is still * required. * TODO: Once all related issues will be fixed this situation should be * illegal. */ |
dee1f973c ext4: race-condit... |
3680 |
if (ee_block != map->m_lblk || ee_len > map->m_len) { |
ff95ec22c ext4: add warning... |
3681 3682 |
#ifdef EXT4_DEBUG ext4_warning("Inode (%ld) finished: extent logical block %llu," |
8d2ae1cbe ext4: remove trai... |
3683 |
" len %u; IO logical block %llu, len %u", |
ff95ec22c ext4: add warning... |
3684 3685 3686 |
inode->i_ino, (unsigned long long)ee_block, ee_len, (unsigned long long)map->m_lblk, map->m_len); #endif |
dfe508093 ext4: drop EXT4_E... |
3687 |
err = ext4_split_convert_extents(handle, inode, map, ppath, |
b8a868450 ext4: Introduce F... |
3688 |
EXT4_GET_BLOCKS_CONVERT); |
dee1f973c ext4: race-condit... |
3689 |
if (err < 0) |
dfe508093 ext4: drop EXT4_E... |
3690 |
return err; |
ed8a1a766 ext4: rename ext4... |
3691 |
path = ext4_find_extent(inode, map->m_lblk, ppath, 0); |
dfe508093 ext4: drop EXT4_E... |
3692 3693 |
if (IS_ERR(path)) return PTR_ERR(path); |
dee1f973c ext4: race-condit... |
3694 3695 3696 |
depth = ext_depth(inode); ex = path[depth].p_ext; } |
197217a5a ext4: add a funct... |
3697 |
|
0031462b5 ext4: Split unini... |
3698 3699 3700 3701 3702 |
err = ext4_ext_get_access(handle, inode, path + depth); if (err) goto out; /* first mark the extent as initialized */ ext4_ext_mark_initialized(ex); |
197217a5a ext4: add a funct... |
3703 3704 |
/* note: ext4_ext_correct_indexes() isn't needed here because * borders are not changed |
0031462b5 ext4: Split unini... |
3705 |
*/ |
ecb94f5fd ext4: collapse a ... |
3706 |
ext4_ext_try_to_merge(handle, inode, path, ex); |
197217a5a ext4: add a funct... |
3707 |
|
0031462b5 ext4: Split unini... |
3708 |
/* Mark modified extent as dirty */ |
ecb94f5fd ext4: collapse a ... |
3709 |
err = ext4_ext_dirty(handle, inode, path + path->p_depth); |
0031462b5 ext4: Split unini... |
3710 3711 3712 3713 |
out: ext4_ext_show_leaf(inode, path); return err; } |
515f41c33 ext4: Ensure zero... |
3714 3715 3716 3717 3718 3719 3720 |
static void unmap_underlying_metadata_blocks(struct block_device *bdev, sector_t block, int count) { int i; for (i = 0; i < count; i++) unmap_underlying_metadata(bdev, block + i); } |
58590b06d ext4: fix EOFBLOC... |
3721 3722 3723 3724 |
/* * Handle EOFBLOCKS_FL flag, clearing it if necessary */ static int check_eofblocks_fl(handle_t *handle, struct inode *inode, |
d002ebf1d ext4: don't pass ... |
3725 |
ext4_lblk_t lblk, |
58590b06d ext4: fix EOFBLOC... |
3726 3727 3728 3729 3730 |
struct ext4_ext_path *path, unsigned int len) { int i, depth; struct ext4_extent_header *eh; |
65922cb5c ext4: unused vari... |
3731 |
struct ext4_extent *last_ex; |
58590b06d ext4: fix EOFBLOC... |
3732 3733 3734 3735 3736 3737 |
if (!ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS)) return 0; depth = ext_depth(inode); eh = path[depth].p_hdr; |
58590b06d ext4: fix EOFBLOC... |
3738 |
|
afcff5d80 ext4: remove rest... |
3739 3740 3741 3742 3743 3744 3745 |
/* * We're going to remove EOFBLOCKS_FL entirely in future so we * do not care for this case anymore. Simply remove the flag * if there are no extents. */ if (unlikely(!eh->eh_entries)) goto out; |
58590b06d ext4: fix EOFBLOC... |
3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 |
last_ex = EXT_LAST_EXTENT(eh); /* * We should clear the EOFBLOCKS_FL flag if we are writing the * last block in the last extent in the file. We test this by * first checking to see if the caller to * ext4_ext_get_blocks() was interested in the last block (or * a block beyond the last block) in the current extent. If * this turns out to be false, we can bail out from this * function immediately. */ |
d002ebf1d ext4: don't pass ... |
3756 |
if (lblk + len < le32_to_cpu(last_ex->ee_block) + |
58590b06d ext4: fix EOFBLOC... |
3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 |
ext4_ext_get_actual_len(last_ex)) return 0; /* * If the caller does appear to be planning to write at or * beyond the end of the current extent, we then test to see * if the current extent is the last extent in the file, by * checking to make sure it was reached via the rightmost node * at each level of the tree. */ for (i = depth-1; i >= 0; i--) if (path[i].p_idx != EXT_LAST_INDEX(path[i].p_hdr)) return 0; |
afcff5d80 ext4: remove rest... |
3769 |
out: |
58590b06d ext4: fix EOFBLOC... |
3770 3771 3772 |
ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS); return ext4_mark_inode_dirty(handle, inode); } |
7b415bf60 ext4: Fix bigallo... |
3773 3774 3775 |
/** * ext4_find_delalloc_range: find delayed allocated block in the given range. * |
7d1b1fbc9 ext4: reimplement... |
3776 |
* Return 1 if there is a delalloc block in the range, otherwise 0. |
7b415bf60 ext4: Fix bigallo... |
3777 |
*/ |
f7fec032a ext4: track all e... |
3778 3779 3780 |
int ext4_find_delalloc_range(struct inode *inode, ext4_lblk_t lblk_start, ext4_lblk_t lblk_end) |
7b415bf60 ext4: Fix bigallo... |
3781 |
{ |
7d1b1fbc9 ext4: reimplement... |
3782 |
struct extent_status es; |
7b415bf60 ext4: Fix bigallo... |
3783 |
|
e30b5dca1 ext4: fix fio reg... |
3784 |
ext4_es_find_delayed_extent_range(inode, lblk_start, lblk_end, &es); |
06b0c8862 ext4: refine exte... |
3785 |
if (es.es_len == 0) |
7d1b1fbc9 ext4: reimplement... |
3786 |
return 0; /* there is no delay extent in this tree */ |
06b0c8862 ext4: refine exte... |
3787 3788 |
else if (es.es_lblk <= lblk_start && lblk_start < es.es_lblk + es.es_len) |
7d1b1fbc9 ext4: reimplement... |
3789 |
return 1; |
06b0c8862 ext4: refine exte... |
3790 |
else if (lblk_start <= es.es_lblk && es.es_lblk <= lblk_end) |
7d1b1fbc9 ext4: reimplement... |
3791 |
return 1; |
7b415bf60 ext4: Fix bigallo... |
3792 |
else |
7d1b1fbc9 ext4: reimplement... |
3793 |
return 0; |
7b415bf60 ext4: Fix bigallo... |
3794 |
} |
7d1b1fbc9 ext4: reimplement... |
3795 |
int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk) |
7b415bf60 ext4: Fix bigallo... |
3796 3797 3798 |
{ struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_lblk_t lblk_start, lblk_end; |
f5a44db5d ext4: add explici... |
3799 |
lblk_start = EXT4_LBLK_CMASK(sbi, lblk); |
7b415bf60 ext4: Fix bigallo... |
3800 |
lblk_end = lblk_start + sbi->s_cluster_ratio - 1; |
7d1b1fbc9 ext4: reimplement... |
3801 |
return ext4_find_delalloc_range(inode, lblk_start, lblk_end); |
7b415bf60 ext4: Fix bigallo... |
3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 |
} /** * Determines how many complete clusters (out of those specified by the 'map') * are under delalloc and were reserved quota for. * This function is called when we are writing out the blocks that were * originally written with their allocation delayed, but then the space was * allocated using fallocate() before the delayed allocation could be resolved. * The cases to look for are: * ('=' indicated delayed allocated blocks * '-' indicates non-delayed allocated blocks) * (a) partial clusters towards beginning and/or end outside of allocated range * are not delalloc'ed. * Ex: * |----c---=|====c====|====c====|===-c----| * |++++++ allocated ++++++| * ==> 4 complete clusters in above example * * (b) partial cluster (outside of allocated range) towards either end is * marked for delayed allocation. In this case, we will exclude that * cluster. * Ex: * |----====c========|========c========| * |++++++ allocated ++++++| * ==> 1 complete clusters in above example * * Ex: * |================c================| * |++++++ allocated ++++++| * ==> 0 complete clusters in above example * * The ext4_da_update_reserve_space will be called only if we * determine here that there were some "entire" clusters that span * this 'allocated' range. * In the non-bigalloc case, this function will just end up returning num_blks * without ever calling ext4_find_delalloc_range. */ static unsigned int get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start, unsigned int num_blks) { struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_lblk_t alloc_cluster_start, alloc_cluster_end; ext4_lblk_t lblk_from, lblk_to, c_offset; unsigned int allocated_clusters = 0; alloc_cluster_start = EXT4_B2C(sbi, lblk_start); alloc_cluster_end = EXT4_B2C(sbi, lblk_start + num_blks - 1); /* max possible clusters for this allocation */ allocated_clusters = alloc_cluster_end - alloc_cluster_start + 1; |
d8990240d ext4: add some tr... |
3853 |
trace_ext4_get_reserved_cluster_alloc(inode, lblk_start, num_blks); |
7b415bf60 ext4: Fix bigallo... |
3854 |
/* Check towards left side */ |
f5a44db5d ext4: add explici... |
3855 |
c_offset = EXT4_LBLK_COFF(sbi, lblk_start); |
7b415bf60 ext4: Fix bigallo... |
3856 |
if (c_offset) { |
f5a44db5d ext4: add explici... |
3857 |
lblk_from = EXT4_LBLK_CMASK(sbi, lblk_start); |
7b415bf60 ext4: Fix bigallo... |
3858 |
lblk_to = lblk_from + c_offset - 1; |
7d1b1fbc9 ext4: reimplement... |
3859 |
if (ext4_find_delalloc_range(inode, lblk_from, lblk_to)) |
7b415bf60 ext4: Fix bigallo... |
3860 3861 3862 3863 |
allocated_clusters--; } /* Now check towards right. */ |
f5a44db5d ext4: add explici... |
3864 |
c_offset = EXT4_LBLK_COFF(sbi, lblk_start + num_blks); |
7b415bf60 ext4: Fix bigallo... |
3865 3866 3867 |
if (allocated_clusters && c_offset) { lblk_from = lblk_start + num_blks; lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1; |
7d1b1fbc9 ext4: reimplement... |
3868 |
if (ext4_find_delalloc_range(inode, lblk_from, lblk_to)) |
7b415bf60 ext4: Fix bigallo... |
3869 3870 3871 3872 3873 |
allocated_clusters--; } return allocated_clusters; } |
0031462b5 ext4: Split unini... |
3874 |
static int |
e8b83d930 ext4: collapse ex... |
3875 3876 |
convert_initialized_extent(handle_t *handle, struct inode *inode, struct ext4_map_blocks *map, |
29c6eaffc ext4: trim unused... |
3877 |
struct ext4_ext_path **ppath, |
56263b4ce ext4: remove unus... |
3878 |
unsigned int allocated) |
b8a868450 ext4: Introduce F... |
3879 |
{ |
4f224b8b7 ext4: drop EXT4_E... |
3880 |
struct ext4_ext_path *path = *ppath; |
e8b83d930 ext4: collapse ex... |
3881 3882 3883 3884 |
struct ext4_extent *ex; ext4_lblk_t ee_block; unsigned int ee_len; int depth; |
b8a868450 ext4: Introduce F... |
3885 3886 3887 3888 |
int err = 0; /* * Make sure that the extent is no bigger than we support with |
556615dcb ext4: rename unin... |
3889 |
* unwritten extent |
b8a868450 ext4: Introduce F... |
3890 |
*/ |
556615dcb ext4: rename unin... |
3891 3892 |
if (map->m_len > EXT_UNWRITTEN_MAX_LEN) map->m_len = EXT_UNWRITTEN_MAX_LEN / 2; |
b8a868450 ext4: Introduce F... |
3893 |
|
e8b83d930 ext4: collapse ex... |
3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 |
depth = ext_depth(inode); ex = path[depth].p_ext; ee_block = le32_to_cpu(ex->ee_block); ee_len = ext4_ext_get_actual_len(ex); ext_debug("%s: inode %lu, logical" "block %llu, max_blocks %u ", __func__, inode->i_ino, (unsigned long long)ee_block, ee_len); if (ee_block != map->m_lblk || ee_len > map->m_len) { |
dfe508093 ext4: drop EXT4_E... |
3905 |
err = ext4_split_convert_extents(handle, inode, map, ppath, |
e8b83d930 ext4: collapse ex... |
3906 3907 3908 |
EXT4_GET_BLOCKS_CONVERT_UNWRITTEN); if (err < 0) return err; |
ed8a1a766 ext4: rename ext4... |
3909 |
path = ext4_find_extent(inode, map->m_lblk, ppath, 0); |
e8b83d930 ext4: collapse ex... |
3910 3911 3912 3913 3914 3915 3916 |
if (IS_ERR(path)) return PTR_ERR(path); depth = ext_depth(inode); ex = path[depth].p_ext; if (!ex) { EXT4_ERROR_INODE(inode, "unexpected hole at %lu", (unsigned long) map->m_lblk); |
6a797d273 ext4: call out CR... |
3917 |
return -EFSCORRUPTED; |
e8b83d930 ext4: collapse ex... |
3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 |
} } err = ext4_ext_get_access(handle, inode, path + depth); if (err) return err; /* first mark the extent as unwritten */ ext4_ext_mark_unwritten(ex); /* note: ext4_ext_correct_indexes() isn't needed here because * borders are not changed */ ext4_ext_try_to_merge(handle, inode, path, ex); /* Mark modified extent as dirty */ err = ext4_ext_dirty(handle, inode, path + path->p_depth); if (err) return err; ext4_ext_show_leaf(inode, path); ext4_update_inode_fsync_trans(handle, inode, 1); err = check_eofblocks_fl(handle, inode, map->m_lblk, path, map->m_len); if (err) return err; |
b8a868450 ext4: Introduce F... |
3942 3943 3944 3945 |
map->m_flags |= EXT4_MAP_UNWRITTEN; if (allocated > map->m_len) allocated = map->m_len; map->m_len = allocated; |
e8b83d930 ext4: collapse ex... |
3946 |
return allocated; |
b8a868450 ext4: Introduce F... |
3947 3948 3949 |
} static int |
556615dcb ext4: rename unin... |
3950 |
ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode, |
e35fd6609 ext4: Add new abs... |
3951 |
struct ext4_map_blocks *map, |
dfe508093 ext4: drop EXT4_E... |
3952 |
struct ext4_ext_path **ppath, int flags, |
e35fd6609 ext4: Add new abs... |
3953 |
unsigned int allocated, ext4_fsblk_t newblock) |
0031462b5 ext4: Split unini... |
3954 |
{ |
dfe508093 ext4: drop EXT4_E... |
3955 |
struct ext4_ext_path *path = *ppath; |
0031462b5 ext4: Split unini... |
3956 3957 |
int ret = 0; int err = 0; |
556615dcb ext4: rename unin... |
3958 |
ext_debug("ext4_ext_handle_unwritten_extents: inode %lu, logical " |
88635ca27 ext4: add missing... |
3959 3960 |
"block %llu, max_blocks %u, flags %x, allocated %u ", |
e35fd6609 ext4: Add new abs... |
3961 |
inode->i_ino, (unsigned long long)map->m_lblk, map->m_len, |
0031462b5 ext4: Split unini... |
3962 3963 |
flags, allocated); ext4_ext_show_leaf(inode, path); |
27dd43854 ext4: introduce r... |
3964 |
/* |
556615dcb ext4: rename unin... |
3965 |
* When writing into unwritten space, we should not fail to |
27dd43854 ext4: introduce r... |
3966 3967 3968 |
* allocate metadata blocks for the new extent block if needed. */ flags |= EXT4_GET_BLOCKS_METADATA_NOFAIL; |
556615dcb ext4: rename unin... |
3969 |
trace_ext4_ext_handle_unwritten_extents(inode, map, flags, |
b5645534c ext4: print 'flag... |
3970 |
allocated, newblock); |
d8990240d ext4: add some tr... |
3971 |
|
c7064ef13 ext4: mechanical ... |
3972 |
/* get_block() before submit the IO, split the extent */ |
c8b459f49 ext4: remove unne... |
3973 |
if (flags & EXT4_GET_BLOCKS_PRE_IO) { |
dfe508093 ext4: drop EXT4_E... |
3974 3975 |
ret = ext4_split_convert_extents(handle, inode, map, ppath, flags | EXT4_GET_BLOCKS_CONVERT); |
82e542291 ext4: fix unwritt... |
3976 3977 |
if (ret <= 0) goto out; |
a25a4e1a5 ext4: let ext4_ex... |
3978 |
map->m_flags |= EXT4_MAP_UNWRITTEN; |
0031462b5 ext4: Split unini... |
3979 3980 |
goto out; } |
c7064ef13 ext4: mechanical ... |
3981 |
/* IO end_io complete, convert the filled extent to written */ |
c8b459f49 ext4: remove unne... |
3982 |
if (flags & EXT4_GET_BLOCKS_CONVERT) { |
c86d8db33 ext4: implement a... |
3983 3984 3985 3986 3987 3988 3989 3990 |
if (flags & EXT4_GET_BLOCKS_ZERO) { if (allocated > map->m_len) allocated = map->m_len; err = ext4_issue_zeroout(inode, map->m_lblk, newblock, allocated); if (err < 0) goto out2; } |
dee1f973c ext4: race-condit... |
3991 |
ret = ext4_convert_unwritten_extents_endio(handle, inode, map, |
dfe508093 ext4: drop EXT4_E... |
3992 |
ppath); |
58590b06d ext4: fix EOFBLOC... |
3993 |
if (ret >= 0) { |
b436b9bef ext4: Wait for pr... |
3994 |
ext4_update_inode_fsync_trans(handle, inode, 1); |
d002ebf1d ext4: don't pass ... |
3995 3996 |
err = check_eofblocks_fl(handle, inode, map->m_lblk, path, map->m_len); |
58590b06d ext4: fix EOFBLOC... |
3997 3998 |
} else err = ret; |
cdee78433 ext4: fix wrong m... |
3999 |
map->m_flags |= EXT4_MAP_MAPPED; |
15cc17678 ext4: fix xfstest... |
4000 |
map->m_pblk = newblock; |
cdee78433 ext4: fix wrong m... |
4001 4002 4003 |
if (allocated > map->m_len) allocated = map->m_len; map->m_len = allocated; |
0031462b5 ext4: Split unini... |
4004 4005 4006 4007 4008 4009 4010 |
goto out2; } /* buffered IO case */ /* * repeat fallocate creation request * we already have an unwritten extent */ |
556615dcb ext4: rename unin... |
4011 |
if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT) { |
a25a4e1a5 ext4: let ext4_ex... |
4012 |
map->m_flags |= EXT4_MAP_UNWRITTEN; |
0031462b5 ext4: Split unini... |
4013 |
goto map_out; |
a25a4e1a5 ext4: let ext4_ex... |
4014 |
} |
0031462b5 ext4: Split unini... |
4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 |
/* buffered READ or buffered write_begin() lookup */ if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { /* * We have blocks reserved already. We * return allocated blocks so that delalloc * won't do block reservation for us. But * the buffer head will be unmapped so that * a read from the block returns 0s. */ |
e35fd6609 ext4: Add new abs... |
4025 |
map->m_flags |= EXT4_MAP_UNWRITTEN; |
0031462b5 ext4: Split unini... |
4026 4027 4028 4029 |
goto out1; } /* buffered write, writepage time, convert*/ |
dfe508093 ext4: drop EXT4_E... |
4030 |
ret = ext4_ext_convert_to_initialized(handle, inode, map, ppath, flags); |
a4e5d88b1 ext4: update EOFB... |
4031 |
if (ret >= 0) |
b436b9bef ext4: Wait for pr... |
4032 |
ext4_update_inode_fsync_trans(handle, inode, 1); |
0031462b5 ext4: Split unini... |
4033 4034 4035 4036 4037 4038 |
out: if (ret <= 0) { err = ret; goto out2; } else allocated = ret; |
e35fd6609 ext4: Add new abs... |
4039 |
map->m_flags |= EXT4_MAP_NEW; |
515f41c33 ext4: Ensure zero... |
4040 4041 4042 4043 4044 4045 4046 |
/* * if we allocated more blocks than requested * we need to make sure we unmap the extra block * allocated. The actual needed block will get * unmapped later when we find the buffer_head marked * new. */ |
e35fd6609 ext4: Add new abs... |
4047 |
if (allocated > map->m_len) { |
515f41c33 ext4: Ensure zero... |
4048 |
unmap_underlying_metadata_blocks(inode->i_sb->s_bdev, |
e35fd6609 ext4: Add new abs... |
4049 4050 4051 |
newblock + map->m_len, allocated - map->m_len); allocated = map->m_len; |
515f41c33 ext4: Ensure zero... |
4052 |
} |
3a2256702 ext4: fix the wro... |
4053 |
map->m_len = allocated; |
5f634d064 ext4: Fix quota a... |
4054 4055 4056 4057 4058 4059 4060 4061 |
/* * If we have done fallocate with the offset that is already * delayed allocated, we would have block reservation * and quota reservation done in the delayed write path. * But fallocate would have already updated quota and block * count for this offset. So cancel these reservation */ |
7b415bf60 ext4: Fix bigallo... |
4062 4063 4064 4065 4066 4067 4068 4069 4070 |
if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) { unsigned int reserved_clusters; reserved_clusters = get_reserved_cluster_alloc(inode, map->m_lblk, map->m_len); if (reserved_clusters) ext4_da_update_reserve_space(inode, reserved_clusters, 0); } |
5f634d064 ext4: Fix quota a... |
4071 |
|
0031462b5 ext4: Split unini... |
4072 |
map_out: |
e35fd6609 ext4: Add new abs... |
4073 |
map->m_flags |= EXT4_MAP_MAPPED; |
a4e5d88b1 ext4: update EOFB... |
4074 4075 4076 4077 4078 4079 |
if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0) { err = check_eofblocks_fl(handle, inode, map->m_lblk, path, map->m_len); if (err < 0) goto out2; } |
0031462b5 ext4: Split unini... |
4080 |
out1: |
e35fd6609 ext4: Add new abs... |
4081 4082 |
if (allocated > map->m_len) allocated = map->m_len; |
0031462b5 ext4: Split unini... |
4083 |
ext4_ext_show_leaf(inode, path); |
e35fd6609 ext4: Add new abs... |
4084 4085 |
map->m_pblk = newblock; map->m_len = allocated; |
0031462b5 ext4: Split unini... |
4086 |
out2: |
0031462b5 ext4: Split unini... |
4087 4088 |
return err ? err : allocated; } |
58590b06d ext4: fix EOFBLOC... |
4089 |
|
0031462b5 ext4: Split unini... |
4090 |
/* |
4d33b1ef1 ext4: teach ext4_... |
4091 4092 4093 |
* get_implied_cluster_alloc - check to see if the requested * allocation (in the map structure) overlaps with a cluster already * allocated in an extent. |
d8990240d ext4: add some tr... |
4094 |
* @sb The filesystem superblock structure |
4d33b1ef1 ext4: teach ext4_... |
4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 |
* @map The requested lblk->pblk mapping * @ex The extent structure which might contain an implied * cluster allocation * * This function is called by ext4_ext_map_blocks() after we failed to * find blocks that were already in the inode's extent tree. Hence, * we know that the beginning of the requested region cannot overlap * the extent from the inode's extent tree. There are three cases we * want to catch. The first is this case: * * |--- cluster # N--| * |--- extent ---| |---- requested region ---| * |==========| * * The second case that we need to test for is this one: * * |--------- cluster # N ----------------| * |--- requested region --| |------- extent ----| * |=======================| * * The third case is when the requested region lies between two extents * within the same cluster: * |------------- cluster # N-------------| * |----- ex -----| |---- ex_right ----| * |------ requested region ------| * |================| * * In each of the above cases, we need to set the map->m_pblk and * map->m_len so it corresponds to the return the extent labelled as * "|====|" from cluster #N, since it is already in use for data in * cluster EXT4_B2C(sbi, map->m_lblk). We will then return 1 to * signal to ext4_ext_map_blocks() that map->m_pblk should be treated * as a new "allocated" block region. Otherwise, we will return 0 and * ext4_ext_map_blocks() will then allocate one or more new clusters * by calling ext4_mb_new_blocks(). */ |
d8990240d ext4: add some tr... |
4131 |
static int get_implied_cluster_alloc(struct super_block *sb, |
4d33b1ef1 ext4: teach ext4_... |
4132 4133 4134 4135 |
struct ext4_map_blocks *map, struct ext4_extent *ex, struct ext4_ext_path *path) { |
d8990240d ext4: add some tr... |
4136 |
struct ext4_sb_info *sbi = EXT4_SB(sb); |
f5a44db5d ext4: add explici... |
4137 |
ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk); |
4d33b1ef1 ext4: teach ext4_... |
4138 |
ext4_lblk_t ex_cluster_start, ex_cluster_end; |
14d7f3efe ext4: remove unus... |
4139 |
ext4_lblk_t rr_cluster_start; |
4d33b1ef1 ext4: teach ext4_... |
4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 |
ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); ext4_fsblk_t ee_start = ext4_ext_pblock(ex); unsigned short ee_len = ext4_ext_get_actual_len(ex); /* The extent passed in that we are trying to match */ ex_cluster_start = EXT4_B2C(sbi, ee_block); ex_cluster_end = EXT4_B2C(sbi, ee_block + ee_len - 1); /* The requested region passed into ext4_map_blocks() */ rr_cluster_start = EXT4_B2C(sbi, map->m_lblk); |
4d33b1ef1 ext4: teach ext4_... |
4150 4151 4152 4153 4154 |
if ((rr_cluster_start == ex_cluster_end) || (rr_cluster_start == ex_cluster_start)) { if (rr_cluster_start == ex_cluster_end) ee_start += ee_len - 1; |
f5a44db5d ext4: add explici... |
4155 |
map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset; |
4d33b1ef1 ext4: teach ext4_... |
4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 |
map->m_len = min(map->m_len, (unsigned) sbi->s_cluster_ratio - c_offset); /* * Check for and handle this case: * * |--------- cluster # N-------------| * |------- extent ----| * |--- requested region ---| * |===========| */ if (map->m_lblk < ee_block) map->m_len = min(map->m_len, ee_block - map->m_lblk); /* * Check for the case where there is already another allocated * block to the right of 'ex' but before the end of the cluster. * * |------------- cluster # N-------------| * |----- ex -----| |---- ex_right ----| * |------ requested region ------| * |================| */ if (map->m_lblk > ee_block) { ext4_lblk_t next = ext4_ext_next_allocated_block(path); map->m_len = min(map->m_len, next - map->m_lblk); } |
d8990240d ext4: add some tr... |
4183 4184 |
trace_ext4_get_implied_cluster_alloc_exit(sb, map, 1); |
4d33b1ef1 ext4: teach ext4_... |
4185 4186 |
return 1; } |
d8990240d ext4: add some tr... |
4187 4188 |
trace_ext4_get_implied_cluster_alloc_exit(sb, map, 0); |
4d33b1ef1 ext4: teach ext4_... |
4189 4190 4191 4192 4193 |
return 0; } /* |
f5ab0d1f8 ext4: Fix BUG whe... |
4194 4195 4196 |
* Block allocation/map/preallocation routine for extents based files * * |
c278bfece ext4: Make ext4_g... |
4197 |
* Need to be called with |
0e855ac8b ext4: Convert tru... |
4198 4199 |
* down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem) |
f5ab0d1f8 ext4: Fix BUG whe... |
4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 |
* * return > 0, number of of blocks already mapped/allocated * if create == 0 and these are pre-allocated blocks * buffer head is unmapped * otherwise blocks are mapped * * return = 0, if plain look up failed (blocks have not been allocated) * buffer head is unmapped * * return < 0, error case. |
c278bfece ext4: Make ext4_g... |
4210 |
*/ |
e35fd6609 ext4: Add new abs... |
4211 4212 |
int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, struct ext4_map_blocks *map, int flags) |
a86c61812 [PATCH] ext3: add... |
4213 4214 |
{ struct ext4_ext_path *path = NULL; |
4d33b1ef1 ext4: teach ext4_... |
4215 4216 |
struct ext4_extent newex, *ex, *ex2; struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); |
0562e0bad ext4: add more tr... |
4217 |
ext4_fsblk_t newblock = 0; |
ce37c4291 ext4: fix error r... |
4218 |
int free_on_err = 0, err = 0, depth, ret; |
4d33b1ef1 ext4: teach ext4_... |
4219 |
unsigned int allocated = 0, offset = 0; |
81fdbb4a8 ext4: move variab... |
4220 |
unsigned int allocated_clusters = 0; |
c9de560de ext4: Add multi b... |
4221 |
struct ext4_allocation_request ar; |
4d33b1ef1 ext4: teach ext4_... |
4222 |
ext4_lblk_t cluster_offset; |
cbd7584e6 ext4: fix block r... |
4223 |
bool map_from_cluster = false; |
a86c61812 [PATCH] ext3: add... |
4224 |
|
84fe3bef5 ext4: Compile war... |
4225 4226 |
ext_debug("blocks %u/%u requested for inode %lu ", |
e35fd6609 ext4: Add new abs... |
4227 |
map->m_lblk, map->m_len, inode->i_ino); |
0562e0bad ext4: add more tr... |
4228 |
trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags); |
a86c61812 [PATCH] ext3: add... |
4229 |
|
a86c61812 [PATCH] ext3: add... |
4230 |
/* find extent for this block */ |
ed8a1a766 ext4: rename ext4... |
4231 |
path = ext4_find_extent(inode, map->m_lblk, NULL, 0); |
a86c61812 [PATCH] ext3: add... |
4232 4233 4234 4235 4236 4237 4238 4239 4240 |
if (IS_ERR(path)) { err = PTR_ERR(path); path = NULL; goto out2; } depth = ext_depth(inode); /* |
d0d856e8b [PATCH] ext4: cle... |
4241 4242 |
* consistent leaf must not be empty; * this situation is possible, though, _during_ tree modification; |
ed8a1a766 ext4: rename ext4... |
4243 |
* this is why assert can't be put in ext4_find_extent() |
a86c61812 [PATCH] ext3: add... |
4244 |
*/ |
273df556b ext4: Convert BUG... |
4245 4246 |
if (unlikely(path[depth].p_ext == NULL && depth != 0)) { EXT4_ERROR_INODE(inode, "bad extent address " |
f70f362b4 ext4: Avoid crash... |
4247 4248 4249 |
"lblock: %lu, depth: %d pblock %lld", (unsigned long) map->m_lblk, depth, path[depth].p_block); |
6a797d273 ext4: call out CR... |
4250 |
err = -EFSCORRUPTED; |
034fb4c95 ext4: replace BUG... |
4251 4252 |
goto out2; } |
a86c61812 [PATCH] ext3: add... |
4253 |
|
7e0289766 [PATCH] ext4: if ... |
4254 4255 |
ex = path[depth].p_ext; if (ex) { |
725d26d3f ext4: Introduce e... |
4256 |
ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); |
bf89d16f6 ext4: rename {ext... |
4257 |
ext4_fsblk_t ee_start = ext4_ext_pblock(ex); |
a2df2a634 fallocate support... |
4258 |
unsigned short ee_len; |
471d4011a [PATCH] ext4: uni... |
4259 |
|
b8a868450 ext4: Introduce F... |
4260 |
|
471d4011a [PATCH] ext4: uni... |
4261 |
/* |
556615dcb ext4: rename unin... |
4262 |
* unwritten extents are treated as holes, except that |
56055d3ae write support for... |
4263 |
* we split out initialized portions during a write. |
471d4011a [PATCH] ext4: uni... |
4264 |
*/ |
a2df2a634 fallocate support... |
4265 |
ee_len = ext4_ext_get_actual_len(ex); |
d8990240d ext4: add some tr... |
4266 4267 |
trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len); |
d0d856e8b [PATCH] ext4: cle... |
4268 |
/* if found extent covers block, simply return it */ |
e35fd6609 ext4: Add new abs... |
4269 4270 |
if (in_range(map->m_lblk, ee_block, ee_len)) { newblock = map->m_lblk - ee_block + ee_start; |
d0d856e8b [PATCH] ext4: cle... |
4271 |
/* number of remaining blocks in the extent */ |
e35fd6609 ext4: Add new abs... |
4272 4273 4274 4275 |
allocated = ee_len - (map->m_lblk - ee_block); ext_debug("%u fit into %u:%d -> %llu ", map->m_lblk, ee_block, ee_len, newblock); |
56055d3ae write support for... |
4276 |
|
b8a868450 ext4: Introduce F... |
4277 4278 4279 4280 |
/* * If the extent is initialized check whether the * caller wants to convert it to unwritten. */ |
556615dcb ext4: rename unin... |
4281 |
if ((!ext4_ext_is_unwritten(ex)) && |
b8a868450 ext4: Introduce F... |
4282 |
(flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN)) { |
e8b83d930 ext4: collapse ex... |
4283 |
allocated = convert_initialized_extent( |
4f224b8b7 ext4: drop EXT4_E... |
4284 |
handle, inode, map, &path, |
29c6eaffc ext4: trim unused... |
4285 |
allocated); |
b8a868450 ext4: Introduce F... |
4286 |
goto out2; |
556615dcb ext4: rename unin... |
4287 |
} else if (!ext4_ext_is_unwritten(ex)) |
7877191c2 ext4: remove unus... |
4288 |
goto out; |
69eb33dc2 ext4: remove sing... |
4289 |
|
556615dcb ext4: rename unin... |
4290 |
ret = ext4_ext_handle_unwritten_extents( |
dfe508093 ext4: drop EXT4_E... |
4291 |
handle, inode, map, &path, flags, |
7877191c2 ext4: remove unus... |
4292 |
allocated, newblock); |
ce37c4291 ext4: fix error r... |
4293 4294 4295 4296 |
if (ret < 0) err = ret; else allocated = ret; |
31cf0f2c3 ext4: delete path... |
4297 |
goto out2; |
a86c61812 [PATCH] ext3: add... |
4298 4299 4300 4301 |
} } /* |
d0d856e8b [PATCH] ext4: cle... |
4302 |
* requested block isn't allocated yet; |
a86c61812 [PATCH] ext3: add... |
4303 4304 |
* we couldn't try to create block if create flag is zero */ |
c21770573 ext4: Define a ne... |
4305 |
if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { |
140a52508 ext4: factor out ... |
4306 |
ext4_lblk_t hole_start, hole_len; |
facab4d97 ext4: return hole... |
4307 4308 |
hole_start = map->m_lblk; hole_len = ext4_ext_determine_hole(inode, path, &hole_start); |
56055d3ae write support for... |
4309 4310 4311 4312 |
/* * put just found gap into cache to speed up * subsequent requests */ |
140a52508 ext4: factor out ... |
4313 |
ext4_ext_put_gap_in_cache(inode, hole_start, hole_len); |
facab4d97 ext4: return hole... |
4314 4315 4316 4317 4318 4319 |
/* Update hole_len to reflect hole size after map->m_lblk */ if (hole_start != map->m_lblk) hole_len -= map->m_lblk - hole_start; map->m_pblk = 0; map->m_len = min_t(unsigned int, map->m_len, hole_len); |
a86c61812 [PATCH] ext3: add... |
4320 4321 |
goto out2; } |
4d33b1ef1 ext4: teach ext4_... |
4322 |
|
a86c61812 [PATCH] ext3: add... |
4323 |
/* |
c2ea3fde6 ext4: Remove old ... |
4324 |
* Okay, we need to do block allocation. |
63f579335 [PATCH] ext4 whit... |
4325 |
*/ |
4d33b1ef1 ext4: teach ext4_... |
4326 |
newex.ee_block = cpu_to_le32(map->m_lblk); |
d0abafac8 ext4: fix bigallo... |
4327 |
cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk); |
4d33b1ef1 ext4: teach ext4_... |
4328 4329 4330 |
/* * If we are doing bigalloc, check to see if the extent returned |
ed8a1a766 ext4: rename ext4... |
4331 |
* by ext4_find_extent() implies a cluster we can use. |
4d33b1ef1 ext4: teach ext4_... |
4332 4333 |
*/ if (cluster_offset && ex && |
d8990240d ext4: add some tr... |
4334 |
get_implied_cluster_alloc(inode->i_sb, map, ex, path)) { |
4d33b1ef1 ext4: teach ext4_... |
4335 4336 |
ar.len = allocated = map->m_len; newblock = map->m_pblk; |
cbd7584e6 ext4: fix block r... |
4337 |
map_from_cluster = true; |
4d33b1ef1 ext4: teach ext4_... |
4338 4339 |
goto got_allocated_blocks; } |
a86c61812 [PATCH] ext3: add... |
4340 |
|
c9de560de ext4: Add multi b... |
4341 |
/* find neighbour allocated blocks */ |
e35fd6609 ext4: Add new abs... |
4342 |
ar.lleft = map->m_lblk; |
c9de560de ext4: Add multi b... |
4343 4344 4345 |
err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft); if (err) goto out2; |
e35fd6609 ext4: Add new abs... |
4346 |
ar.lright = map->m_lblk; |
4d33b1ef1 ext4: teach ext4_... |
4347 4348 |
ex2 = NULL; err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2); |
c9de560de ext4: Add multi b... |
4349 4350 |
if (err) goto out2; |
25d14f983 ext4: Extent over... |
4351 |
|
4d33b1ef1 ext4: teach ext4_... |
4352 4353 4354 |
/* Check if the extent after searching to the right implies a * cluster we can use. */ if ((sbi->s_cluster_ratio > 1) && ex2 && |
d8990240d ext4: add some tr... |
4355 |
get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) { |
4d33b1ef1 ext4: teach ext4_... |
4356 4357 |
ar.len = allocated = map->m_len; newblock = map->m_pblk; |
cbd7584e6 ext4: fix block r... |
4358 |
map_from_cluster = true; |
4d33b1ef1 ext4: teach ext4_... |
4359 4360 |
goto got_allocated_blocks; } |
749269fac Change on-disk fo... |
4361 4362 4363 |
/* * See if request is beyond maximum number of blocks we can have in * a single extent. For an initialized extent this limit is |
556615dcb ext4: rename unin... |
4364 4365 |
* EXT_INIT_MAX_LEN and for an unwritten extent this limit is * EXT_UNWRITTEN_MAX_LEN. |
749269fac Change on-disk fo... |
4366 |
*/ |
e35fd6609 ext4: Add new abs... |
4367 |
if (map->m_len > EXT_INIT_MAX_LEN && |
556615dcb ext4: rename unin... |
4368 |
!(flags & EXT4_GET_BLOCKS_UNWRIT_EXT)) |
e35fd6609 ext4: Add new abs... |
4369 |
map->m_len = EXT_INIT_MAX_LEN; |
556615dcb ext4: rename unin... |
4370 4371 4372 |
else if (map->m_len > EXT_UNWRITTEN_MAX_LEN && (flags & EXT4_GET_BLOCKS_UNWRIT_EXT)) map->m_len = EXT_UNWRITTEN_MAX_LEN; |
749269fac Change on-disk fo... |
4373 |
|
e35fd6609 ext4: Add new abs... |
4374 |
/* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */ |
e35fd6609 ext4: Add new abs... |
4375 |
newex.ee_len = cpu_to_le16(map->m_len); |
4d33b1ef1 ext4: teach ext4_... |
4376 |
err = ext4_ext_check_overlap(sbi, inode, &newex, path); |
25d14f983 ext4: Extent over... |
4377 |
if (err) |
b939e3766 ext4: Use the ext... |
4378 |
allocated = ext4_ext_get_actual_len(&newex); |
25d14f983 ext4: Extent over... |
4379 |
else |
e35fd6609 ext4: Add new abs... |
4380 |
allocated = map->m_len; |
c9de560de ext4: Add multi b... |
4381 4382 4383 |
/* allocate new block */ ar.inode = inode; |
e35fd6609 ext4: Add new abs... |
4384 4385 |
ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk); ar.logical = map->m_lblk; |
4d33b1ef1 ext4: teach ext4_... |
4386 4387 4388 4389 4390 4391 4392 4393 |
/* * We calculate the offset from the beginning of the cluster * for the logical block number, since when we allocate a * physical cluster, the physical block should start at the * same offset from the beginning of the cluster. This is * needed so that future calls to get_implied_cluster_alloc() * work correctly. */ |
f5a44db5d ext4: add explici... |
4394 |
offset = EXT4_LBLK_COFF(sbi, map->m_lblk); |
4d33b1ef1 ext4: teach ext4_... |
4395 4396 4397 |
ar.len = EXT4_NUM_B2C(sbi, offset+allocated); ar.goal -= offset; ar.logical -= offset; |
c9de560de ext4: Add multi b... |
4398 4399 4400 4401 4402 |
if (S_ISREG(inode->i_mode)) ar.flags = EXT4_MB_HINT_DATA; else /* disable in-core preallocation for non-regular files */ ar.flags = 0; |
556b27abf ext4: do not norm... |
4403 4404 |
if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE) ar.flags |= EXT4_MB_HINT_NOPREALLOC; |
e3cf5d5d9 ext4: prepare to ... |
4405 4406 |
if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) ar.flags |= EXT4_MB_DELALLOC_RESERVED; |
c5e298ae5 ext4: prevent ext... |
4407 4408 |
if (flags & EXT4_GET_BLOCKS_METADATA_NOFAIL) ar.flags |= EXT4_MB_USE_RESERVED; |
c9de560de ext4: Add multi b... |
4409 |
newblock = ext4_mb_new_blocks(handle, &ar, &err); |
a86c61812 [PATCH] ext3: add... |
4410 4411 |
if (!newblock) goto out2; |
84fe3bef5 ext4: Compile war... |
4412 4413 |
ext_debug("allocate new block: goal %llu, found %llu/%u ", |
498e5f241 ext4: Change unsi... |
4414 |
ar.goal, newblock, allocated); |
4d33b1ef1 ext4: teach ext4_... |
4415 |
free_on_err = 1; |
7b415bf60 ext4: Fix bigallo... |
4416 |
allocated_clusters = ar.len; |
4d33b1ef1 ext4: teach ext4_... |
4417 4418 4419 |
ar.len = EXT4_C2B(sbi, ar.len) - offset; if (ar.len > allocated) ar.len = allocated; |
a86c61812 [PATCH] ext3: add... |
4420 |
|
4d33b1ef1 ext4: teach ext4_... |
4421 |
got_allocated_blocks: |
a86c61812 [PATCH] ext3: add... |
4422 |
/* try to insert new extent into found leaf and return */ |
4d33b1ef1 ext4: teach ext4_... |
4423 |
ext4_ext_store_pblock(&newex, newblock + offset); |
c9de560de ext4: Add multi b... |
4424 |
newex.ee_len = cpu_to_le16(ar.len); |
556615dcb ext4: rename unin... |
4425 4426 4427 |
/* Mark unwritten */ if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT){ ext4_ext_mark_unwritten(&newex); |
a25a4e1a5 ext4: let ext4_ex... |
4428 |
map->m_flags |= EXT4_MAP_UNWRITTEN; |
8d5d02e6b ext4: async direc... |
4429 |
} |
c8d46e41b ext4: Add flag to... |
4430 |
|
a4e5d88b1 ext4: update EOFB... |
4431 4432 4433 4434 |
err = 0; if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0) err = check_eofblocks_fl(handle, inode, map->m_lblk, path, ar.len); |
575a1d4bd ext4: free alloca... |
4435 |
if (!err) |
dfe508093 ext4: drop EXT4_E... |
4436 |
err = ext4_ext_insert_extent(handle, inode, &path, |
575a1d4bd ext4: free alloca... |
4437 |
&newex, flags); |
82e542291 ext4: fix unwritt... |
4438 |
|
4d33b1ef1 ext4: teach ext4_... |
4439 |
if (err && free_on_err) { |
7132de744 ext4: fix i_block... |
4440 4441 |
int fb_flags = flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ? EXT4_FREE_BLOCKS_NO_QUOT_UPDATE : 0; |
315054f02 When ext4_ext_ins... |
4442 |
/* free data blocks we just allocated */ |
c9de560de ext4: Add multi b... |
4443 4444 |
/* not a good idea to call discard here directly, * but otherwise we'd need to call it every free() */ |
c2ea3fde6 ext4: Remove old ... |
4445 |
ext4_discard_preallocations(inode); |
c8e15130e ext4: simplify ca... |
4446 4447 |
ext4_free_blocks(handle, inode, NULL, newblock, EXT4_C2B(sbi, allocated_clusters), fb_flags); |
a86c61812 [PATCH] ext3: add... |
4448 |
goto out2; |
315054f02 When ext4_ext_ins... |
4449 |
} |
a86c61812 [PATCH] ext3: add... |
4450 |
|
a86c61812 [PATCH] ext3: add... |
4451 |
/* previous routine could use block we allocated */ |
bf89d16f6 ext4: rename {ext... |
4452 |
newblock = ext4_ext_pblock(&newex); |
b939e3766 ext4: Use the ext... |
4453 |
allocated = ext4_ext_get_actual_len(&newex); |
e35fd6609 ext4: Add new abs... |
4454 4455 4456 |
if (allocated > map->m_len) allocated = map->m_len; map->m_flags |= EXT4_MAP_NEW; |
a86c61812 [PATCH] ext3: add... |
4457 |
|
b436b9bef ext4: Wait for pr... |
4458 |
/* |
5f634d064 ext4: Fix quota a... |
4459 4460 4461 |
* Update reserved blocks/metadata blocks after successful * block allocation which had been deferred till now. */ |
7b415bf60 ext4: Fix bigallo... |
4462 |
if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) { |
81fdbb4a8 ext4: move variab... |
4463 |
unsigned int reserved_clusters; |
7b415bf60 ext4: Fix bigallo... |
4464 |
/* |
81fdbb4a8 ext4: move variab... |
4465 |
* Check how many clusters we had reserved this allocated range |
7b415bf60 ext4: Fix bigallo... |
4466 4467 4468 |
*/ reserved_clusters = get_reserved_cluster_alloc(inode, map->m_lblk, allocated); |
9d21c9fa2 ext4: don't relea... |
4469 |
if (!map_from_cluster) { |
7b415bf60 ext4: Fix bigallo... |
4470 |
BUG_ON(allocated_clusters < reserved_clusters); |
7b415bf60 ext4: Fix bigallo... |
4471 |
if (reserved_clusters < allocated_clusters) { |
5356f2615 ext4: attempt to ... |
4472 |
struct ext4_inode_info *ei = EXT4_I(inode); |
7b415bf60 ext4: Fix bigallo... |
4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 |
int reservation = allocated_clusters - reserved_clusters; /* * It seems we claimed few clusters outside of * the range of this allocation. We should give * it back to the reservation pool. This can * happen in the following case: * * * Suppose s_cluster_ratio is 4 (i.e., each * cluster has 4 blocks. Thus, the clusters * are [0-3],[4-7],[8-11]... * * First comes delayed allocation write for * logical blocks 10 & 11. Since there were no * previous delayed allocated blocks in the * range [8-11], we would reserve 1 cluster * for this write. * * Next comes write for logical blocks 3 to 8. * In this case, we will reserve 2 clusters * (for [0-3] and [4-7]; and not for [8-11] as * that range has a delayed allocated blocks. * Thus total reserved clusters now becomes 3. * * Now, during the delayed allocation writeout * time, we will first write blocks [3-8] and * allocate 3 clusters for writing these * blocks. Also, we would claim all these * three clusters above. * * Now when we come here to writeout the * blocks [10-11], we would expect to claim * the reservation of 1 cluster we had made * (and we would claim it since there are no * more delayed allocated blocks in the range * [8-11]. But our reserved cluster count had * already gone to 0. * * Thus, at the step 4 above when we determine * that there are still some unwritten delayed * allocated blocks outside of our current * block range, we should increment the * reserved clusters count so that when the * remaining blocks finally gets written, we * could claim them. */ |
5356f2615 ext4: attempt to ... |
4515 4516 4517 4518 4519 |
dquot_reserve_block(inode, EXT4_C2B(sbi, reservation)); spin_lock(&ei->i_block_reservation_lock); ei->i_reserved_data_blocks += reservation; spin_unlock(&ei->i_block_reservation_lock); |
7b415bf60 ext4: Fix bigallo... |
4520 |
} |
232ec8720 ext4: update rese... |
4521 4522 4523 4524 4525 4526 4527 4528 4529 |
/* * We will claim quota for all newly allocated blocks. * We're updating the reserved space *after* the * correction above so we do not accidentally free * all the metadata reservation because we might * actually need it later on. */ ext4_da_update_reserve_space(inode, allocated_clusters, 1); |
7b415bf60 ext4: Fix bigallo... |
4530 4531 |
} } |
5f634d064 ext4: Fix quota a... |
4532 4533 |
/* |
b436b9bef ext4: Wait for pr... |
4534 |
* Cache the extent and update transaction to commit on fdatasync only |
556615dcb ext4: rename unin... |
4535 |
* when it is _not_ an unwritten extent. |
b436b9bef ext4: Wait for pr... |
4536 |
*/ |
556615dcb ext4: rename unin... |
4537 |
if ((flags & EXT4_GET_BLOCKS_UNWRIT_EXT) == 0) |
b436b9bef ext4: Wait for pr... |
4538 |
ext4_update_inode_fsync_trans(handle, inode, 1); |
69eb33dc2 ext4: remove sing... |
4539 |
else |
b436b9bef ext4: Wait for pr... |
4540 |
ext4_update_inode_fsync_trans(handle, inode, 0); |
a86c61812 [PATCH] ext3: add... |
4541 |
out: |
e35fd6609 ext4: Add new abs... |
4542 4543 |
if (allocated > map->m_len) allocated = map->m_len; |
a86c61812 [PATCH] ext3: add... |
4544 |
ext4_ext_show_leaf(inode, path); |
e35fd6609 ext4: Add new abs... |
4545 4546 4547 |
map->m_flags |= EXT4_MAP_MAPPED; map->m_pblk = newblock; map->m_len = allocated; |
a86c61812 [PATCH] ext3: add... |
4548 |
out2: |
b7ea89ad0 ext4: allow a NUL... |
4549 4550 |
ext4_ext_drop_refs(path); kfree(path); |
e861304b8 ext4: add "punch ... |
4551 |
|
63b999685 ext4: call ext4_e... |
4552 4553 |
trace_ext4_ext_map_blocks_exit(inode, flags, map, err ? err : allocated); |
7877191c2 ext4: remove unus... |
4554 |
return err ? err : allocated; |
a86c61812 [PATCH] ext3: add... |
4555 |
} |
819c4920b ext4: refactor tr... |
4556 |
void ext4_ext_truncate(handle_t *handle, struct inode *inode) |
a86c61812 [PATCH] ext3: add... |
4557 |
{ |
a86c61812 [PATCH] ext3: add... |
4558 |
struct super_block *sb = inode->i_sb; |
725d26d3f ext4: Introduce e... |
4559 |
ext4_lblk_t last_block; |
a86c61812 [PATCH] ext3: add... |
4560 4561 4562 |
int err = 0; /* |
d0d856e8b [PATCH] ext4: cle... |
4563 4564 4565 |
* TODO: optimization is possible here. * Probably we need not scan at all, * because page truncation is enough. |
a86c61812 [PATCH] ext3: add... |
4566 |
*/ |
a86c61812 [PATCH] ext3: add... |
4567 4568 4569 4570 4571 4572 4573 |
/* we have to know where to truncate from in crash case */ EXT4_I(inode)->i_disksize = inode->i_size; ext4_mark_inode_dirty(handle, inode); last_block = (inode->i_size + sb->s_blocksize - 1) >> EXT4_BLOCK_SIZE_BITS(sb); |
8acd5e9b1 ext4: fix error h... |
4574 |
retry: |
51865fda2 ext4: let ext4 ma... |
4575 4576 |
err = ext4_es_remove_extent(inode, last_block, EXT_MAX_BLOCKS - last_block); |
94eec0fc3 ext4: fix retry h... |
4577 |
if (err == -ENOMEM) { |
8acd5e9b1 ext4: fix error h... |
4578 4579 4580 4581 4582 4583 4584 4585 |
cond_resched(); congestion_wait(BLK_RW_ASYNC, HZ/50); goto retry; } if (err) { ext4_std_error(inode->i_sb, err); return; } |
5f95d21fb ext4: rewrite pun... |
4586 |
err = ext4_ext_remove_space(inode, last_block, EXT_MAX_BLOCKS - 1); |
8acd5e9b1 ext4: fix error h... |
4587 |
ext4_std_error(inode->i_sb, err); |
a86c61812 [PATCH] ext3: add... |
4588 |
} |
0e8b6879f ext4: refactor ex... |
4589 |
static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset, |
c174e6d69 ext4: fix transac... |
4590 4591 |
ext4_lblk_t len, loff_t new_size, int flags, int mode) |
0e8b6879f ext4: refactor ex... |
4592 4593 4594 4595 4596 4597 |
{ struct inode *inode = file_inode(file); handle_t *handle; int ret = 0; int ret2 = 0; int retries = 0; |
4134f5c88 ext4: recalculate... |
4598 |
int depth = 0; |
0e8b6879f ext4: refactor ex... |
4599 4600 |
struct ext4_map_blocks map; unsigned int credits; |
c174e6d69 ext4: fix transac... |
4601 |
loff_t epos; |
0e8b6879f ext4: refactor ex... |
4602 |
|
c3fe493cc ext4: remove unne... |
4603 |
BUG_ON(!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)); |
0e8b6879f ext4: refactor ex... |
4604 |
map.m_lblk = offset; |
c174e6d69 ext4: fix transac... |
4605 |
map.m_len = len; |
0e8b6879f ext4: refactor ex... |
4606 4607 4608 4609 4610 |
/* * Don't normalize the request if it can fit in one extent so * that it doesn't get unnecessarily split into multiple * extents. */ |
556615dcb ext4: rename unin... |
4611 |
if (len <= EXT_UNWRITTEN_MAX_LEN) |
0e8b6879f ext4: refactor ex... |
4612 4613 4614 4615 4616 4617 |
flags |= EXT4_GET_BLOCKS_NO_NORMALIZE; /* * credits to insert 1 extent into extent tree */ credits = ext4_chunk_trans_blocks(inode, len); |
c3fe493cc ext4: remove unne... |
4618 |
depth = ext_depth(inode); |
0e8b6879f ext4: refactor ex... |
4619 4620 |
retry: |
c174e6d69 ext4: fix transac... |
4621 |
while (ret >= 0 && len) { |
4134f5c88 ext4: recalculate... |
4622 4623 4624 4625 4626 4627 4628 |
/* * Recalculate credits when extent tree depth changes. */ if (depth >= 0 && depth != ext_depth(inode)) { credits = ext4_chunk_trans_blocks(inode, len); depth = ext_depth(inode); } |
0e8b6879f ext4: refactor ex... |
4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 |
handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits); if (IS_ERR(handle)) { ret = PTR_ERR(handle); break; } ret = ext4_map_blocks(handle, inode, &map, flags); if (ret <= 0) { ext4_debug("inode #%lu: block %u: len %u: " "ext4_ext_map_blocks returned %d", inode->i_ino, map.m_lblk, map.m_len, ret); ext4_mark_inode_dirty(handle, inode); ret2 = ext4_journal_stop(handle); break; } |
c174e6d69 ext4: fix transac... |
4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 |
map.m_lblk += ret; map.m_len = len = len - ret; epos = (loff_t)map.m_lblk << inode->i_blkbits; inode->i_ctime = ext4_current_time(inode); if (new_size) { if (epos > new_size) epos = new_size; if (ext4_update_inode_size(inode, epos) & 0x1) inode->i_mtime = inode->i_ctime; } else { if (epos > inode->i_size) ext4_set_inode_flag(inode, EXT4_INODE_EOFBLOCKS); } ext4_mark_inode_dirty(handle, inode); |
0e8b6879f ext4: refactor ex... |
4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 |
ret2 = ext4_journal_stop(handle); if (ret2) break; } if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) { ret = 0; goto retry; } return ret > 0 ? ret2 : ret; } |
b8a868450 ext4: Introduce F... |
4672 4673 4674 4675 4676 4677 4678 4679 4680 |
static long ext4_zero_range(struct file *file, loff_t offset, loff_t len, int mode) { struct inode *inode = file_inode(file); handle_t *handle = NULL; unsigned int max_blocks; loff_t new_size = 0; int ret = 0; int flags; |
69dc95364 ext4: fix incorec... |
4681 |
int credits; |
c174e6d69 ext4: fix transac... |
4682 |
int partial_begin, partial_end; |
b8a868450 ext4: Introduce F... |
4683 4684 |
loff_t start, end; ext4_lblk_t lblk; |
b8a868450 ext4: Introduce F... |
4685 4686 4687 |
unsigned int blkbits = inode->i_blkbits; trace_ext4_zero_range(inode, offset, len, mode); |
6c5e73d3a ext4: enforce we ... |
4688 4689 |
if (!S_ISREG(inode->i_mode)) return -EINVAL; |
e1ee60fd8 ext4: fix ZERO_RA... |
4690 4691 4692 4693 4694 4695 |
/* Call ext4_force_commit to flush all data in case of data=journal. */ if (ext4_should_journal_data(inode)) { ret = ext4_force_commit(inode->i_sb); if (ret) return ret; } |
b8a868450 ext4: Introduce F... |
4696 |
/* |
b8a868450 ext4: Introduce F... |
4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 |
* Round up offset. This is not fallocate, we neet to zero out * blocks, so convert interior block aligned part of the range to * unwritten and possibly manually zero out unaligned parts of the * range. */ start = round_up(offset, 1 << blkbits); end = round_down((offset + len), 1 << blkbits); if (start < offset || end > offset + len) return -EINVAL; |
c174e6d69 ext4: fix transac... |
4707 4708 |
partial_begin = offset & ((1 << blkbits) - 1); partial_end = (offset + len) & ((1 << blkbits) - 1); |
b8a868450 ext4: Introduce F... |
4709 4710 4711 4712 4713 4714 4715 |
lblk = start >> blkbits; max_blocks = (end >> blkbits); if (max_blocks < lblk) max_blocks = 0; else max_blocks -= lblk; |
5955102c9 wrappers for ->i_... |
4716 |
inode_lock(inode); |
b8a868450 ext4: Introduce F... |
4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 |
/* * Indirect files do not support unwritten extnets */ if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { ret = -EOPNOTSUPP; goto out_mutex; } if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > i_size_read(inode)) { new_size = offset + len; ret = inode_newsize_ok(inode, new_size); if (ret) goto out_mutex; |
b8a868450 ext4: Introduce F... |
4732 |
} |
0f2af21aa ext4: allocate en... |
4733 4734 4735 |
flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT; if (mode & FALLOC_FL_KEEP_SIZE) flags |= EXT4_GET_BLOCKS_KEEP_SIZE; |
17048e8a0 ext4: move unlock... |
4736 4737 4738 |
/* Wait all existing dio workers, newcomers will block on i_mutex */ ext4_inode_block_unlocked_dio(inode); inode_dio_wait(inode); |
0f2af21aa ext4: allocate en... |
4739 4740 4741 4742 4743 4744 4745 4746 |
/* Preallocate the range including the unaligned edges */ if (partial_begin || partial_end) { ret = ext4_alloc_file_blocks(file, round_down(offset, 1 << blkbits) >> blkbits, (round_up((offset + len), 1 << blkbits) - round_down(offset, 1 << blkbits)) >> blkbits, new_size, flags, mode); if (ret) |
17048e8a0 ext4: move unlock... |
4747 |
goto out_dio; |
0f2af21aa ext4: allocate en... |
4748 4749 4750 4751 |
} /* Zero range excluding the unaligned edges */ |
b8a868450 ext4: Introduce F... |
4752 |
if (max_blocks > 0) { |
0f2af21aa ext4: allocate en... |
4753 4754 |
flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN | EXT4_EX_NOCACHE); |
b8a868450 ext4: Introduce F... |
4755 |
|
ea3d7209c ext4: fix races b... |
4756 4757 4758 4759 4760 |
/* * Prevent page faults from reinstantiating pages we have * released from page cache. */ down_write(&EXT4_I(inode)->i_mmap_sem); |
011278485 ext4: fix races o... |
4761 4762 4763 4764 4765 |
ret = ext4_update_disksize_before_punch(inode, offset, len); if (ret) { up_write(&EXT4_I(inode)->i_mmap_sem); goto out_dio; } |
ea3d7209c ext4: fix races b... |
4766 4767 4768 |
/* Now release the pages and zero block aligned part of pages */ truncate_pagecache_range(inode, start, end - 1); inode->i_mtime = inode->i_ctime = ext4_current_time(inode); |
713e8dde3 ext4: fix ZERO_RA... |
4769 4770 |
ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, flags, mode); |
ea3d7209c ext4: fix races b... |
4771 |
up_write(&EXT4_I(inode)->i_mmap_sem); |
713e8dde3 ext4: fix ZERO_RA... |
4772 4773 |
if (ret) goto out_dio; |
b8a868450 ext4: Introduce F... |
4774 |
} |
c174e6d69 ext4: fix transac... |
4775 4776 |
if (!partial_begin && !partial_end) goto out_dio; |
69dc95364 ext4: fix incorec... |
4777 4778 4779 4780 4781 4782 4783 4784 |
/* * In worst case we have to writeout two nonadjacent unwritten * blocks and update the inode */ credits = (2 * ext4_ext_index_trans_blocks(inode, 2)) + 1; if (ext4_should_journal_data(inode)) credits += 2; handle = ext4_journal_start(inode, EXT4_HT_MISC, credits); |
b8a868450 ext4: Introduce F... |
4785 4786 4787 4788 4789 4790 4791 |
if (IS_ERR(handle)) { ret = PTR_ERR(handle); ext4_std_error(inode->i_sb, ret); goto out_dio; } inode->i_mtime = inode->i_ctime = ext4_current_time(inode); |
e5b30416f ext4: remove unne... |
4792 |
if (new_size) { |
4631dbf67 ext4: move i_size... |
4793 |
ext4_update_inode_size(inode, new_size); |
e5b30416f ext4: remove unne... |
4794 |
} else { |
b8a868450 ext4: Introduce F... |
4795 4796 4797 4798 4799 4800 4801 |
/* * Mark that we allocate beyond EOF so the subsequent truncate * can proceed even if the new size is the same as i_size. */ if ((offset + len) > i_size_read(inode)) ext4_set_inode_flag(inode, EXT4_INODE_EOFBLOCKS); } |
b8a868450 ext4: Introduce F... |
4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 |
ext4_mark_inode_dirty(handle, inode); /* Zero out partial block at the edges of the range */ ret = ext4_zero_partial_blocks(handle, inode, offset, len); if (file->f_flags & O_SYNC) ext4_handle_sync(handle); ext4_journal_stop(handle); out_dio: ext4_inode_resume_unlocked_dio(inode); out_mutex: |
5955102c9 wrappers for ->i_... |
4814 |
inode_unlock(inode); |
b8a868450 ext4: Introduce F... |
4815 4816 |
return ret; } |
a2df2a634 fallocate support... |
4817 |
/* |
2fe17c107 fallocate should ... |
4818 |
* preallocate space for a file. This implements ext4's fallocate file |
a2df2a634 fallocate support... |
4819 4820 4821 4822 4823 |
* operation, which gets called from sys_fallocate system call. * For block-mapped files, posix_fallocate should fall back to the method * of writing zeroes to the required new blocks (the same behavior which is * expected for file systems which do not support fallocate() system call). */ |
2fe17c107 fallocate should ... |
4824 |
long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len) |
a2df2a634 fallocate support... |
4825 |
{ |
496ad9aa8 new helper: file_... |
4826 |
struct inode *inode = file_inode(file); |
f282ac19d ext4: Update inod... |
4827 |
loff_t new_size = 0; |
498e5f241 ext4: Change unsi... |
4828 |
unsigned int max_blocks; |
a2df2a634 fallocate support... |
4829 |
int ret = 0; |
a4e5d88b1 ext4: update EOFB... |
4830 |
int flags; |
0e8b6879f ext4: refactor ex... |
4831 |
ext4_lblk_t lblk; |
0e8b6879f ext4: refactor ex... |
4832 |
unsigned int blkbits = inode->i_blkbits; |
a2df2a634 fallocate support... |
4833 |
|
2058f83a7 ext4 crypto: impl... |
4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 |
/* * Encrypted inodes can't handle collapse range or insert * range since we would need to re-encrypt blocks with a * different IV or XTS tweak (which are based on the logical * block number). * * XXX It's not clear why zero range isn't working, but we'll * leave it disabled for encrypted inodes for now. This is a * bug we should fix.... */ if (ext4_encrypted_inode(inode) && |
331573feb ext4: Add support... |
4845 4846 |
(mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE | FALLOC_FL_ZERO_RANGE))) |
2058f83a7 ext4 crypto: impl... |
4847 |
return -EOPNOTSUPP; |
a4bb6b64e ext4: enable "pun... |
4848 |
/* Return error if mode is not supported */ |
9eb79482a ext4: Add support... |
4849 |
if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | |
331573feb ext4: Add support... |
4850 4851 |
FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE | FALLOC_FL_INSERT_RANGE)) |
a4bb6b64e ext4: enable "pun... |
4852 4853 4854 |
return -EOPNOTSUPP; if (mode & FALLOC_FL_PUNCH_HOLE) |
aeb2817a4 ext4: pass inode ... |
4855 |
return ext4_punch_hole(inode, offset, len); |
a4bb6b64e ext4: enable "pun... |
4856 |
|
0c8d414f1 ext4: let falloca... |
4857 4858 4859 |
ret = ext4_convert_inline_data(inode); if (ret) return ret; |
40c406c74 ext4: COLLAPSE_RA... |
4860 4861 |
if (mode & FALLOC_FL_COLLAPSE_RANGE) return ext4_collapse_range(inode, offset, len); |
331573feb ext4: Add support... |
4862 4863 |
if (mode & FALLOC_FL_INSERT_RANGE) return ext4_insert_range(inode, offset, len); |
b8a868450 ext4: Introduce F... |
4864 4865 |
if (mode & FALLOC_FL_ZERO_RANGE) return ext4_zero_range(file, offset, len, mode); |
0562e0bad ext4: add more tr... |
4866 |
trace_ext4_fallocate_enter(inode, offset, len, mode); |
0e8b6879f ext4: refactor ex... |
4867 |
lblk = offset >> blkbits; |
0e8b6879f ext4: refactor ex... |
4868 |
|
518eaa638 ext4: create EXT4... |
4869 |
max_blocks = EXT4_MAX_BLOCKS(len, offset, blkbits); |
556615dcb ext4: rename unin... |
4870 |
flags = EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT; |
0e8b6879f ext4: refactor ex... |
4871 4872 |
if (mode & FALLOC_FL_KEEP_SIZE) flags |= EXT4_GET_BLOCKS_KEEP_SIZE; |
5955102c9 wrappers for ->i_... |
4873 |
inode_lock(inode); |
f282ac19d ext4: Update inod... |
4874 |
|
280227a75 ext4: move check ... |
4875 4876 4877 4878 4879 4880 4881 |
/* * We only support preallocation for extent-based files only */ if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { ret = -EOPNOTSUPP; goto out; } |
f282ac19d ext4: Update inod... |
4882 4883 4884 4885 4886 4887 |
if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > i_size_read(inode)) { new_size = offset + len; ret = inode_newsize_ok(inode, new_size); if (ret) goto out; |
6d19c42b7 ext4: Prevent cre... |
4888 |
} |
f282ac19d ext4: Update inod... |
4889 |
|
17048e8a0 ext4: move unlock... |
4890 4891 4892 |
/* Wait all existing dio workers, newcomers will block on i_mutex */ ext4_inode_block_unlocked_dio(inode); inode_dio_wait(inode); |
c174e6d69 ext4: fix transac... |
4893 4894 |
ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, flags, mode); |
17048e8a0 ext4: move unlock... |
4895 |
ext4_inode_resume_unlocked_dio(inode); |
0e8b6879f ext4: refactor ex... |
4896 4897 |
if (ret) goto out; |
f282ac19d ext4: Update inod... |
4898 |
|
c174e6d69 ext4: fix transac... |
4899 4900 4901 |
if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) { ret = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal, EXT4_I(inode)->i_sync_tid); |
f282ac19d ext4: Update inod... |
4902 |
} |
f282ac19d ext4: Update inod... |
4903 |
out: |
5955102c9 wrappers for ->i_... |
4904 |
inode_unlock(inode); |
0e8b6879f ext4: refactor ex... |
4905 4906 |
trace_ext4_fallocate_exit(inode, offset, max_blocks, ret); return ret; |
a2df2a634 fallocate support... |
4907 |
} |
6873fa0de Hook ext4 to the ... |
4908 4909 |
/* |
0031462b5 ext4: Split unini... |
4910 4911 4912 4913 4914 4915 4916 |
* This function convert a range of blocks to written extents * The caller of this function will pass the start offset and the size. * all unwritten extents within this range will be converted to * written extents. * * This function is called from the direct IO end io call back * function, to convert the fallocated extents after IO is completed. |
109f55651 ext4: fix ext4_ex... |
4917 |
* Returns 0 on success. |
0031462b5 ext4: Split unini... |
4918 |
*/ |
6b523df4f ext4: use transac... |
4919 4920 |
int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode, loff_t offset, ssize_t len) |
0031462b5 ext4: Split unini... |
4921 |
{ |
0031462b5 ext4: Split unini... |
4922 4923 4924 |
unsigned int max_blocks; int ret = 0; int ret2 = 0; |
2ed886852 ext4: Convert cal... |
4925 |
struct ext4_map_blocks map; |
0031462b5 ext4: Split unini... |
4926 |
unsigned int credits, blkbits = inode->i_blkbits; |
2ed886852 ext4: Convert cal... |
4927 |
map.m_lblk = offset >> blkbits; |
518eaa638 ext4: create EXT4... |
4928 |
max_blocks = EXT4_MAX_BLOCKS(len, offset, blkbits); |
0031462b5 ext4: Split unini... |
4929 |
/* |
6b523df4f ext4: use transac... |
4930 4931 4932 |
* This is somewhat ugly but the idea is clear: When transaction is * reserved, everything goes into it. Otherwise we rather start several * smaller transactions for conversion of each extent separately. |
0031462b5 ext4: Split unini... |
4933 |
*/ |
6b523df4f ext4: use transac... |
4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 |
if (handle) { handle = ext4_journal_start_reserved(handle, EXT4_HT_EXT_CONVERT); if (IS_ERR(handle)) return PTR_ERR(handle); credits = 0; } else { /* * credits to insert 1 extent into extent tree */ credits = ext4_chunk_trans_blocks(inode, max_blocks); } |
0031462b5 ext4: Split unini... |
4946 |
while (ret >= 0 && ret < max_blocks) { |
2ed886852 ext4: Convert cal... |
4947 4948 |
map.m_lblk += ret; map.m_len = (max_blocks -= ret); |
6b523df4f ext4: use transac... |
4949 4950 4951 4952 4953 4954 4955 |
if (credits) { handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits); if (IS_ERR(handle)) { ret = PTR_ERR(handle); break; } |
0031462b5 ext4: Split unini... |
4956 |
} |
2ed886852 ext4: Convert cal... |
4957 |
ret = ext4_map_blocks(handle, inode, &map, |
c7064ef13 ext4: mechanical ... |
4958 |
EXT4_GET_BLOCKS_IO_CONVERT_EXT); |
b06acd38a ext4: remove expl... |
4959 4960 4961 4962 4963 4964 |
if (ret <= 0) ext4_warning(inode->i_sb, "inode #%lu: block %u: len %u: " "ext4_ext_map_blocks returned %d", inode->i_ino, map.m_lblk, map.m_len, ret); |
0031462b5 ext4: Split unini... |
4965 |
ext4_mark_inode_dirty(handle, inode); |
6b523df4f ext4: use transac... |
4966 4967 4968 |
if (credits) ret2 = ext4_journal_stop(handle); if (ret <= 0 || ret2) |
0031462b5 ext4: Split unini... |
4969 4970 |
break; } |
6b523df4f ext4: use transac... |
4971 4972 |
if (!credits) ret2 = ext4_journal_stop(handle); |
0031462b5 ext4: Split unini... |
4973 4974 |
return ret > 0 ? ret2 : ret; } |
6d9c85eb7 ext4: make FIEMAP... |
4975 |
|
0031462b5 ext4: Split unini... |
4976 |
/* |
69eb33dc2 ext4: remove sing... |
4977 4978 |
* If newes is not existing extent (newes->ec_pblk equals zero) find * delayed extent at start of newes and update newes accordingly and |
91dd8c114 ext4: prevent rac... |
4979 4980 |
* return start of the next delayed extent. * |
69eb33dc2 ext4: remove sing... |
4981 |
* If newes is existing extent (newes->ec_pblk is not equal zero) |
91dd8c114 ext4: prevent rac... |
4982 |
* return start of next delayed extent or EXT_MAX_BLOCKS if no delayed |
69eb33dc2 ext4: remove sing... |
4983 |
* extent found. Leave newes unmodified. |
6873fa0de Hook ext4 to the ... |
4984 |
*/ |
91dd8c114 ext4: prevent rac... |
4985 |
static int ext4_find_delayed_extent(struct inode *inode, |
69eb33dc2 ext4: remove sing... |
4986 |
struct extent_status *newes) |
6873fa0de Hook ext4 to the ... |
4987 |
{ |
b3aff3e3f ext4: reimplement... |
4988 |
struct extent_status es; |
be401363a ext4: rename and ... |
4989 |
ext4_lblk_t block, next_del; |
6873fa0de Hook ext4 to the ... |
4990 |
|
69eb33dc2 ext4: remove sing... |
4991 |
if (newes->es_pblk == 0) { |
e30b5dca1 ext4: fix fio reg... |
4992 4993 |
ext4_es_find_delayed_extent_range(inode, newes->es_lblk, newes->es_lblk + newes->es_len - 1, &es); |
6d9c85eb7 ext4: make FIEMAP... |
4994 |
/* |
69eb33dc2 ext4: remove sing... |
4995 |
* No extent in extent-tree contains block @newes->es_pblk, |
6d9c85eb7 ext4: make FIEMAP... |
4996 |
* then the block may stay in 1)a hole or 2)delayed-extent. |
6d9c85eb7 ext4: make FIEMAP... |
4997 |
*/ |
06b0c8862 ext4: refine exte... |
4998 |
if (es.es_len == 0) |
b3aff3e3f ext4: reimplement... |
4999 |
/* A hole found. */ |
91dd8c114 ext4: prevent rac... |
5000 |
return 0; |
b3aff3e3f ext4: reimplement... |
5001 |
|
69eb33dc2 ext4: remove sing... |
5002 |
if (es.es_lblk > newes->es_lblk) { |
b3aff3e3f ext4: reimplement... |
5003 |
/* A hole found. */ |
69eb33dc2 ext4: remove sing... |
5004 5005 |
newes->es_len = min(es.es_lblk - newes->es_lblk, newes->es_len); |
91dd8c114 ext4: prevent rac... |
5006 |
return 0; |
6873fa0de Hook ext4 to the ... |
5007 |
} |
6d9c85eb7 ext4: make FIEMAP... |
5008 |
|
69eb33dc2 ext4: remove sing... |
5009 |
newes->es_len = es.es_lblk + es.es_len - newes->es_lblk; |
6873fa0de Hook ext4 to the ... |
5010 |
} |
69eb33dc2 ext4: remove sing... |
5011 |
block = newes->es_lblk + newes->es_len; |
e30b5dca1 ext4: fix fio reg... |
5012 |
ext4_es_find_delayed_extent_range(inode, block, EXT_MAX_BLOCKS, &es); |
be401363a ext4: rename and ... |
5013 5014 5015 5016 |
if (es.es_len == 0) next_del = EXT_MAX_BLOCKS; else next_del = es.es_lblk; |
91dd8c114 ext4: prevent rac... |
5017 |
return next_del; |
6873fa0de Hook ext4 to the ... |
5018 |
} |
6873fa0de Hook ext4 to the ... |
5019 5020 |
/* fiemap flags we can handle specified here */ #define EXT4_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR) |
3a06d778d ext4: sparse fixes |
5021 5022 |
static int ext4_xattr_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo) |
6873fa0de Hook ext4 to the ... |
5023 5024 5025 5026 5027 5028 5029 5030 |
{ __u64 physical = 0; __u64 length; __u32 flags = FIEMAP_EXTENT_LAST; int blockbits = inode->i_sb->s_blocksize_bits; int error = 0; /* in-inode? */ |
19f5fb7ad ext4: Use bitops ... |
5031 |
if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) { |
6873fa0de Hook ext4 to the ... |
5032 5033 5034 5035 5036 5037 |
struct ext4_iloc iloc; int offset; /* offset of xattr in inode */ error = ext4_get_inode_loc(inode, &iloc); if (error) return error; |
a60697f41 ext4: fix data of... |
5038 |
physical = (__u64)iloc.bh->b_blocknr << blockbits; |
6873fa0de Hook ext4 to the ... |
5039 5040 5041 5042 5043 |
offset = EXT4_GOOD_OLD_INODE_SIZE + EXT4_I(inode)->i_extra_isize; physical += offset; length = EXT4_SB(inode->i_sb)->s_inode_size - offset; flags |= FIEMAP_EXTENT_DATA_INLINE; |
fd2dd9fba ext4: Fix buffer ... |
5044 |
brelse(iloc.bh); |
6873fa0de Hook ext4 to the ... |
5045 |
} else { /* external block */ |
a60697f41 ext4: fix data of... |
5046 |
physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits; |
6873fa0de Hook ext4 to the ... |
5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 |
length = inode->i_sb->s_blocksize; } if (physical) error = fiemap_fill_next_extent(fieinfo, 0, physical, length, flags); return (error < 0 ? error : 0); } int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) { ext4_lblk_t start_blk; |
6873fa0de Hook ext4 to the ... |
5060 |
int error = 0; |
941919856 ext4: let fiemap ... |
5061 5062 |
if (ext4_has_inline_data(inode)) { int has_inline = 1; |
d952d69e2 ext4: ext4_inline... |
5063 5064 |
error = ext4_inline_data_fiemap(inode, fieinfo, &has_inline, start, len); |
941919856 ext4: let fiemap ... |
5065 5066 5067 5068 |
if (has_inline) return error; } |
7869a4a6c ext4: add support... |
5069 5070 5071 5072 5073 |
if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) { error = ext4_ext_precache(inode); if (error) return error; } |
6873fa0de Hook ext4 to the ... |
5074 |
/* fallback to generic here if not in extents fmt */ |
12e9b8920 ext4: Use bitops ... |
5075 |
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) |
ad7fefb10 Revert "ext4: fix... |
5076 5077 |
return generic_block_fiemap(inode, fieinfo, start, len, ext4_get_block); |
6873fa0de Hook ext4 to the ... |
5078 5079 5080 5081 5082 5083 5084 |
if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS)) return -EBADR; if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) { error = ext4_xattr_fiemap(inode, fieinfo); } else { |
aca92ff6f ext4: correctly c... |
5085 5086 |
ext4_lblk_t len_blks; __u64 last_blk; |
6873fa0de Hook ext4 to the ... |
5087 |
start_blk = start >> inode->i_sb->s_blocksize_bits; |
aca92ff6f ext4: correctly c... |
5088 |
last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits; |
f17722f91 ext4: Fix max fil... |
5089 5090 |
if (last_blk >= EXT_MAX_BLOCKS) last_blk = EXT_MAX_BLOCKS-1; |
aca92ff6f ext4: correctly c... |
5091 |
len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1; |
6873fa0de Hook ext4 to the ... |
5092 5093 |
/* |
91dd8c114 ext4: prevent rac... |
5094 5095 |
* Walk the extent tree gathering extent information * and pushing extents back to the user. |
6873fa0de Hook ext4 to the ... |
5096 |
*/ |
91dd8c114 ext4: prevent rac... |
5097 5098 |
error = ext4_fill_fiemap_extents(inode, start_blk, len_blks, fieinfo); |
6873fa0de Hook ext4 to the ... |
5099 |
} |
6873fa0de Hook ext4 to the ... |
5100 5101 |
return error; } |
9eb79482a ext4: Add support... |
5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 |
/* * ext4_access_path: * Function to access the path buffer for marking it dirty. * It also checks if there are sufficient credits left in the journal handle * to update path. */ static int ext4_access_path(handle_t *handle, struct inode *inode, struct ext4_ext_path *path) { int credits, err; if (!ext4_handle_valid(handle)) return 0; /* * Check if need to extend journal credits * 3 for leaf, sb, and inode plus 2 (bmap and group * descriptor) for each block group; assume two block * groups */ if (handle->h_buffer_credits < 7) { credits = ext4_writepage_trans_blocks(inode); err = ext4_ext_truncate_extend_restart(handle, inode, credits); /* EAGAIN is success */ if (err && err != -EAGAIN) return err; } err = ext4_ext_get_access(handle, inode, path); return err; } /* * ext4_ext_shift_path_extents: * Shift the extents of a path structure lying between path[depth].p_ext |
331573feb ext4: Add support... |
5139 5140 |
* and EXT_LAST_EXTENT(path[depth].p_hdr), by @shift blocks. @SHIFT tells * if it is right shift or left shift operation. |
9eb79482a ext4: Add support... |
5141 5142 5143 5144 |
*/ static int ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift, struct inode *inode, handle_t *handle, |
331573feb ext4: Add support... |
5145 |
enum SHIFT_DIRECTION SHIFT) |
9eb79482a ext4: Add support... |
5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 |
{ int depth, err = 0; struct ext4_extent *ex_start, *ex_last; bool update = 0; depth = path->p_depth; while (depth >= 0) { if (depth == path->p_depth) { ex_start = path[depth].p_ext; if (!ex_start) |
6a797d273 ext4: call out CR... |
5156 |
return -EFSCORRUPTED; |
9eb79482a ext4: Add support... |
5157 5158 |
ex_last = EXT_LAST_EXTENT(path[depth].p_hdr); |
9eb79482a ext4: Add support... |
5159 5160 5161 5162 5163 5164 5165 |
err = ext4_access_path(handle, inode, path + depth); if (err) goto out; if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr)) update = 1; |
9eb79482a ext4: Add support... |
5166 |
while (ex_start <= ex_last) { |
331573feb ext4: Add support... |
5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 |
if (SHIFT == SHIFT_LEFT) { le32_add_cpu(&ex_start->ee_block, -shift); /* Try to merge to the left. */ if ((ex_start > EXT_FIRST_EXTENT(path[depth].p_hdr)) && ext4_ext_try_to_merge_right(inode, path, ex_start - 1)) ex_last--; else ex_start++; } else { le32_add_cpu(&ex_last->ee_block, shift); ext4_ext_try_to_merge_right(inode, path, ex_last); |
6dd834eff ext4: fix extent ... |
5183 |
ex_last--; |
331573feb ext4: Add support... |
5184 |
} |
9eb79482a ext4: Add support... |
5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 |
} err = ext4_ext_dirty(handle, inode, path + depth); if (err) goto out; if (--depth < 0 || !update) break; } /* Update index too */ err = ext4_access_path(handle, inode, path + depth); if (err) goto out; |
331573feb ext4: Add support... |
5198 5199 5200 5201 |
if (SHIFT == SHIFT_LEFT) le32_add_cpu(&path[depth].p_idx->ei_block, -shift); else le32_add_cpu(&path[depth].p_idx->ei_block, shift); |
9eb79482a ext4: Add support... |
5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 |
err = ext4_ext_dirty(handle, inode, path + depth); if (err) goto out; /* we are done if current index is not a starting index */ if (path[depth].p_idx != EXT_FIRST_INDEX(path[depth].p_hdr)) break; depth--; } out: return err; } /* * ext4_ext_shift_extents: |
331573feb ext4: Add support... |
5219 5220 5221 |
* All the extents which lies in the range from @start to the last allocated * block for the @inode are shifted either towards left or right (depending * upon @SHIFT) by @shift blocks. |
9eb79482a ext4: Add support... |
5222 5223 5224 5225 |
* On success, 0 is returned, error otherwise. */ static int ext4_ext_shift_extents(struct inode *inode, handle_t *handle, |
331573feb ext4: Add support... |
5226 5227 |
ext4_lblk_t start, ext4_lblk_t shift, enum SHIFT_DIRECTION SHIFT) |
9eb79482a ext4: Add support... |
5228 5229 5230 5231 |
{ struct ext4_ext_path *path; int ret = 0, depth; struct ext4_extent *extent; |
331573feb ext4: Add support... |
5232 |
ext4_lblk_t stop, *iterator, ex_start, ex_end; |
9eb79482a ext4: Add support... |
5233 5234 |
/* Let path point to the last extent */ |
ed8a1a766 ext4: rename ext4... |
5235 |
path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL, 0); |
9eb79482a ext4: Add support... |
5236 5237 5238 5239 5240 |
if (IS_ERR(path)) return PTR_ERR(path); depth = path->p_depth; extent = path[depth].p_ext; |
ee4bd0d96 ext4: reuse path ... |
5241 5242 |
if (!extent) goto out; |
9eb79482a ext4: Add support... |
5243 |
|
331573feb ext4: Add support... |
5244 |
stop = le32_to_cpu(extent->ee_block) + |
847c6c422 ext4: fix byte or... |
5245 |
ext4_ext_get_actual_len(extent); |
9eb79482a ext4: Add support... |
5246 |
|
331573feb ext4: Add support... |
5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 |
/* * In case of left shift, Don't start shifting extents until we make * sure the hole is big enough to accommodate the shift. */ if (SHIFT == SHIFT_LEFT) { path = ext4_find_extent(inode, start - 1, &path, 0); if (IS_ERR(path)) return PTR_ERR(path); depth = path->p_depth; extent = path[depth].p_ext; if (extent) { ex_start = le32_to_cpu(extent->ee_block); ex_end = le32_to_cpu(extent->ee_block) + ext4_ext_get_actual_len(extent); } else { ex_start = 0; ex_end = 0; } |
9eb79482a ext4: Add support... |
5265 |
|
331573feb ext4: Add support... |
5266 5267 5268 5269 5270 5271 |
if ((start == ex_start && shift > ex_start) || (shift > start - ex_end)) { ext4_ext_drop_refs(path); kfree(path); return -EINVAL; } |
8dc79ec4c ext4: fix error h... |
5272 |
} |
9eb79482a ext4: Add support... |
5273 |
|
331573feb ext4: Add support... |
5274 5275 5276 5277 5278 5279 5280 5281 5282 |
/* * In case of left shift, iterator points to start and it is increased * till we reach stop. In case of right shift, iterator points to stop * and it is decreased till we reach start. */ if (SHIFT == SHIFT_LEFT) iterator = &start; else iterator = &stop; |
9eb79482a ext4: Add support... |
5283 5284 |
/* Its safe to start updating extents */ |
331573feb ext4: Add support... |
5285 5286 |
while (start < stop) { path = ext4_find_extent(inode, *iterator, &path, 0); |
9eb79482a ext4: Add support... |
5287 5288 5289 5290 |
if (IS_ERR(path)) return PTR_ERR(path); depth = path->p_depth; extent = path[depth].p_ext; |
a18ed359b ext4: always chec... |
5291 5292 |
if (!extent) { EXT4_ERROR_INODE(inode, "unexpected hole at %lu", |
331573feb ext4: Add support... |
5293 |
(unsigned long) *iterator); |
6a797d273 ext4: call out CR... |
5294 |
return -EFSCORRUPTED; |
a18ed359b ext4: always chec... |
5295 |
} |
331573feb ext4: Add support... |
5296 5297 |
if (SHIFT == SHIFT_LEFT && *iterator > le32_to_cpu(extent->ee_block)) { |
9eb79482a ext4: Add support... |
5298 |
/* Hole, move to the next extent */ |
f8fb4f415 ext4: use ext4_ex... |
5299 5300 5301 |
if (extent < EXT_LAST_EXTENT(path[depth].p_hdr)) { path[depth].p_ext++; } else { |
331573feb ext4: Add support... |
5302 |
*iterator = ext4_ext_next_allocated_block(path); |
f8fb4f415 ext4: use ext4_ex... |
5303 |
continue; |
9eb79482a ext4: Add support... |
5304 5305 |
} } |
331573feb ext4: Add support... |
5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 |
if (SHIFT == SHIFT_LEFT) { extent = EXT_LAST_EXTENT(path[depth].p_hdr); *iterator = le32_to_cpu(extent->ee_block) + ext4_ext_get_actual_len(extent); } else { extent = EXT_FIRST_EXTENT(path[depth].p_hdr); *iterator = le32_to_cpu(extent->ee_block) > 0 ? le32_to_cpu(extent->ee_block) - 1 : 0; /* Update path extent in case we need to stop */ while (le32_to_cpu(extent->ee_block) < start) extent++; path[depth].p_ext = extent; } |
9eb79482a ext4: Add support... |
5320 |
ret = ext4_ext_shift_path_extents(path, shift, inode, |
331573feb ext4: Add support... |
5321 |
handle, SHIFT); |
9eb79482a ext4: Add support... |
5322 5323 5324 |
if (ret) break; } |
ee4bd0d96 ext4: reuse path ... |
5325 5326 5327 |
out: ext4_ext_drop_refs(path); kfree(path); |
9eb79482a ext4: Add support... |
5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 |
return ret; } /* * ext4_collapse_range: * This implements the fallocate's collapse range functionality for ext4 * Returns: 0 and non-zero on error. */ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len) { struct super_block *sb = inode->i_sb; ext4_lblk_t punch_start, punch_stop; handle_t *handle; unsigned int credits; |
a8680e0d5 ext4: fix COLLAPS... |
5342 |
loff_t new_size, ioffset; |
9eb79482a ext4: Add support... |
5343 |
int ret; |
b9576fc36 ext4: fix an ext3... |
5344 5345 5346 5347 5348 5349 5350 |
/* * We need to test this early because xfstests assumes that a * collapse range of (0, 1) will return EOPNOTSUPP if the file * system does not support collapse range. */ if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) return -EOPNOTSUPP; |
9eb79482a ext4: Add support... |
5351 |
/* Collapse range works only on fs block size aligned offsets. */ |
ee98fa3a8 ext4: fix COLLAPS... |
5352 5353 |
if (offset & (EXT4_CLUSTER_SIZE(sb) - 1) || len & (EXT4_CLUSTER_SIZE(sb) - 1)) |
9eb79482a ext4: Add support... |
5354 5355 5356 |
return -EINVAL; if (!S_ISREG(inode->i_mode)) |
86f1ca388 ext4: use EINVAL ... |
5357 |
return -EINVAL; |
9eb79482a ext4: Add support... |
5358 5359 5360 5361 5362 |
trace_ext4_collapse_range(inode, offset, len); punch_start = offset >> EXT4_BLOCK_SIZE_BITS(sb); punch_stop = (offset + len) >> EXT4_BLOCK_SIZE_BITS(sb); |
1ce01c4a1 ext4: fix COLLAPS... |
5363 5364 5365 5366 5367 5368 |
/* Call ext4_force_commit to flush all data in case of data=journal. */ if (ext4_should_journal_data(inode)) { ret = ext4_force_commit(inode->i_sb); if (ret) return ret; } |
5955102c9 wrappers for ->i_... |
5369 |
inode_lock(inode); |
23fffa925 fs: move falloc c... |
5370 5371 5372 5373 5374 5375 5376 5377 |
/* * There is no need to overlap collapse range with EOF, in which case * it is effectively a truncate operation */ if (offset + len >= i_size_read(inode)) { ret = -EINVAL; goto out_mutex; } |
9eb79482a ext4: Add support... |
5378 5379 5380 5381 5382 |
/* Currently just for extent based files */ if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { ret = -EOPNOTSUPP; goto out_mutex; } |
9eb79482a ext4: Add support... |
5383 5384 5385 |
/* Wait for existing dio to complete */ ext4_inode_block_unlocked_dio(inode); inode_dio_wait(inode); |
ea3d7209c ext4: fix races b... |
5386 5387 5388 5389 5390 |
/* * Prevent page faults from reinstantiating pages we have released from * page cache. */ down_write(&EXT4_I(inode)->i_mmap_sem); |
32ebffd3b ext4: fix races b... |
5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 |
/* * Need to round down offset to be aligned with page size boundary * for page size > block size. */ ioffset = round_down(offset, PAGE_SIZE); /* * Write tail of the last page before removed range since it will get * removed from the page cache below. */ ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset); if (ret) goto out_mmap; /* * Write data that will be shifted to preserve them when discarding * page cache below. We are also protected from pages becoming dirty * by i_mmap_sem. */ ret = filemap_write_and_wait_range(inode->i_mapping, offset + len, LLONG_MAX); if (ret) goto out_mmap; |
ea3d7209c ext4: fix races b... |
5412 |
truncate_pagecache(inode, ioffset); |
9eb79482a ext4: Add support... |
5413 5414 5415 5416 |
credits = ext4_writepage_trans_blocks(inode); handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits); if (IS_ERR(handle)) { ret = PTR_ERR(handle); |
ea3d7209c ext4: fix races b... |
5417 |
goto out_mmap; |
9eb79482a ext4: Add support... |
5418 5419 5420 5421 5422 5423 |
} down_write(&EXT4_I(inode)->i_data_sem); ext4_discard_preallocations(inode); ret = ext4_es_remove_extent(inode, punch_start, |
2c1d23289 ext4: fix removin... |
5424 |
EXT_MAX_BLOCKS - punch_start); |
9eb79482a ext4: Add support... |
5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 |
if (ret) { up_write(&EXT4_I(inode)->i_data_sem); goto out_stop; } ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1); if (ret) { up_write(&EXT4_I(inode)->i_data_sem); goto out_stop; } |
ef24f6c23 ext4: discard pre... |
5435 |
ext4_discard_preallocations(inode); |
9eb79482a ext4: Add support... |
5436 5437 |
ret = ext4_ext_shift_extents(inode, handle, punch_stop, |
331573feb ext4: Add support... |
5438 |
punch_stop - punch_start, SHIFT_LEFT); |
9eb79482a ext4: Add support... |
5439 5440 5441 5442 5443 5444 |
if (ret) { up_write(&EXT4_I(inode)->i_data_sem); goto out_stop; } new_size = i_size_read(inode) - len; |
9337d5d31 ext4: no need to ... |
5445 |
i_size_write(inode, new_size); |
9eb79482a ext4: Add support... |
5446 |
EXT4_I(inode)->i_disksize = new_size; |
9eb79482a ext4: Add support... |
5447 5448 5449 5450 5451 5452 5453 5454 |
up_write(&EXT4_I(inode)->i_data_sem); if (IS_SYNC(inode)) ext4_handle_sync(handle); inode->i_mtime = inode->i_ctime = ext4_current_time(inode); ext4_mark_inode_dirty(handle, inode); out_stop: ext4_journal_stop(handle); |
ea3d7209c ext4: fix races b... |
5455 5456 |
out_mmap: up_write(&EXT4_I(inode)->i_mmap_sem); |
9eb79482a ext4: Add support... |
5457 5458 |
ext4_inode_resume_unlocked_dio(inode); out_mutex: |
5955102c9 wrappers for ->i_... |
5459 |
inode_unlock(inode); |
9eb79482a ext4: Add support... |
5460 5461 |
return ret; } |
fcf6b1b72 ext4: refactor ex... |
5462 |
|
331573feb ext4: Add support... |
5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 |
/* * ext4_insert_range: * This function implements the FALLOC_FL_INSERT_RANGE flag of fallocate. * The data blocks starting from @offset to the EOF are shifted by @len * towards right to create a hole in the @inode. Inode size is increased * by len bytes. * Returns 0 on success, error otherwise. */ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len) { struct super_block *sb = inode->i_sb; handle_t *handle; struct ext4_ext_path *path; struct ext4_extent *extent; ext4_lblk_t offset_lblk, len_lblk, ee_start_lblk = 0; unsigned int credits, ee_len; int ret = 0, depth, split_flag = 0; loff_t ioffset; /* * We need to test this early because xfstests assumes that an * insert range of (0, 1) will return EOPNOTSUPP if the file * system does not support insert range. */ if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) return -EOPNOTSUPP; /* Insert range works only on fs block size aligned offsets. */ if (offset & (EXT4_CLUSTER_SIZE(sb) - 1) || len & (EXT4_CLUSTER_SIZE(sb) - 1)) return -EINVAL; if (!S_ISREG(inode->i_mode)) return -EOPNOTSUPP; trace_ext4_insert_range(inode, offset, len); offset_lblk = offset >> EXT4_BLOCK_SIZE_BITS(sb); len_lblk = len >> EXT4_BLOCK_SIZE_BITS(sb); /* Call ext4_force_commit to flush all data in case of data=journal */ if (ext4_should_journal_data(inode)) { ret = ext4_force_commit(inode->i_sb); if (ret) return ret; } |
5955102c9 wrappers for ->i_... |
5509 |
inode_lock(inode); |
331573feb ext4: Add support... |
5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 |
/* Currently just for extent based files */ if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { ret = -EOPNOTSUPP; goto out_mutex; } /* Check for wrap through zero */ if (inode->i_size + len > inode->i_sb->s_maxbytes) { ret = -EFBIG; goto out_mutex; } /* Offset should be less than i_size */ if (offset >= i_size_read(inode)) { ret = -EINVAL; goto out_mutex; } |
331573feb ext4: Add support... |
5527 5528 5529 |
/* Wait for existing dio to complete */ ext4_inode_block_unlocked_dio(inode); inode_dio_wait(inode); |
ea3d7209c ext4: fix races b... |
5530 5531 5532 5533 5534 |
/* * Prevent page faults from reinstantiating pages we have released from * page cache. */ down_write(&EXT4_I(inode)->i_mmap_sem); |
32ebffd3b ext4: fix races b... |
5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 |
/* * Need to round down to align start offset to page size boundary * for page size > block size. */ ioffset = round_down(offset, PAGE_SIZE); /* Write out all dirty pages */ ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, LLONG_MAX); if (ret) goto out_mmap; |
ea3d7209c ext4: fix races b... |
5545 |
truncate_pagecache(inode, ioffset); |
331573feb ext4: Add support... |
5546 5547 5548 5549 |
credits = ext4_writepage_trans_blocks(inode); handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits); if (IS_ERR(handle)) { ret = PTR_ERR(handle); |
ea3d7209c ext4: fix races b... |
5550 |
goto out_mmap; |
331573feb ext4: Add support... |
5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 |
} /* Expand file to avoid data loss if there is error while shifting */ inode->i_size += len; EXT4_I(inode)->i_disksize += len; inode->i_mtime = inode->i_ctime = ext4_current_time(inode); ret = ext4_mark_inode_dirty(handle, inode); if (ret) goto out_stop; down_write(&EXT4_I(inode)->i_data_sem); ext4_discard_preallocations(inode); path = ext4_find_extent(inode, offset_lblk, NULL, 0); if (IS_ERR(path)) { up_write(&EXT4_I(inode)->i_data_sem); goto out_stop; } depth = ext_depth(inode); extent = path[depth].p_ext; if (extent) { ee_start_lblk = le32_to_cpu(extent->ee_block); ee_len = ext4_ext_get_actual_len(extent); /* * If offset_lblk is not the starting block of extent, split * the extent @offset_lblk */ if ((offset_lblk > ee_start_lblk) && (offset_lblk < (ee_start_lblk + ee_len))) { if (ext4_ext_is_unwritten(extent)) split_flag = EXT4_EXT_MARK_UNWRIT1 | EXT4_EXT_MARK_UNWRIT2; ret = ext4_split_extent_at(handle, inode, &path, offset_lblk, split_flag, EXT4_EX_NOCACHE | EXT4_GET_BLOCKS_PRE_IO | EXT4_GET_BLOCKS_METADATA_NOFAIL); } ext4_ext_drop_refs(path); kfree(path); if (ret < 0) { up_write(&EXT4_I(inode)->i_data_sem); goto out_stop; } |
edf15aa18 ext4: fix memory ... |
5598 5599 5600 |
} else { ext4_ext_drop_refs(path); kfree(path); |
331573feb ext4: Add support... |
5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 |
} ret = ext4_es_remove_extent(inode, offset_lblk, EXT_MAX_BLOCKS - offset_lblk); if (ret) { up_write(&EXT4_I(inode)->i_data_sem); goto out_stop; } /* * if offset_lblk lies in a hole which is at start of file, use * ee_start_lblk to shift extents */ ret = ext4_ext_shift_extents(inode, handle, ee_start_lblk > offset_lblk ? ee_start_lblk : offset_lblk, len_lblk, SHIFT_RIGHT); up_write(&EXT4_I(inode)->i_data_sem); if (IS_SYNC(inode)) ext4_handle_sync(handle); out_stop: ext4_journal_stop(handle); |
ea3d7209c ext4: fix races b... |
5624 5625 |
out_mmap: up_write(&EXT4_I(inode)->i_mmap_sem); |
331573feb ext4: Add support... |
5626 5627 |
ext4_inode_resume_unlocked_dio(inode); out_mutex: |
5955102c9 wrappers for ->i_... |
5628 |
inode_unlock(inode); |
331573feb ext4: Add support... |
5629 5630 |
return ret; } |
fcf6b1b72 ext4: refactor ex... |
5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 |
/** * ext4_swap_extents - Swap extents between two inodes * * @inode1: First inode * @inode2: Second inode * @lblk1: Start block for first inode * @lblk2: Start block for second inode * @count: Number of blocks to swap * @mark_unwritten: Mark second inode's extents as unwritten after swap * @erp: Pointer to save error value * * This helper routine does exactly what is promise "swap extents". All other * stuff such as page-cache locking consistency, bh mapping consistency or * extent's data copying must be performed by caller. * Locking: * i_mutex is held for both inodes * i_data_sem is locked for write for both inodes * Assumptions: * All pages from requested range are locked for both inodes */ int ext4_swap_extents(handle_t *handle, struct inode *inode1, struct inode *inode2, ext4_lblk_t lblk1, ext4_lblk_t lblk2, ext4_lblk_t count, int unwritten, int *erp) { struct ext4_ext_path *path1 = NULL; struct ext4_ext_path *path2 = NULL; int replaced_count = 0; BUG_ON(!rwsem_is_locked(&EXT4_I(inode1)->i_data_sem)); BUG_ON(!rwsem_is_locked(&EXT4_I(inode2)->i_data_sem)); |
5955102c9 wrappers for ->i_... |
5662 5663 |
BUG_ON(!inode_is_locked(inode1)); BUG_ON(!inode_is_locked(inode2)); |
fcf6b1b72 ext4: refactor ex... |
5664 5665 |
*erp = ext4_es_remove_extent(inode1, lblk1, count); |
19008f6df ext4: fix ext4_sw... |
5666 |
if (unlikely(*erp)) |
fcf6b1b72 ext4: refactor ex... |
5667 5668 |
return 0; *erp = ext4_es_remove_extent(inode2, lblk2, count); |
19008f6df ext4: fix ext4_sw... |
5669 |
if (unlikely(*erp)) |
fcf6b1b72 ext4: refactor ex... |
5670 5671 5672 5673 5674 5675 5676 |
return 0; while (count) { struct ext4_extent *ex1, *ex2, tmp_ex; ext4_lblk_t e1_blk, e2_blk; int e1_len, e2_len, len; int split = 0; |
ed8a1a766 ext4: rename ext4... |
5677 |
path1 = ext4_find_extent(inode1, lblk1, NULL, EXT4_EX_NOCACHE); |
a1c83681d fs: Drop unlikely... |
5678 |
if (IS_ERR(path1)) { |
fcf6b1b72 ext4: refactor ex... |
5679 |
*erp = PTR_ERR(path1); |
19008f6df ext4: fix ext4_sw... |
5680 5681 5682 5683 |
path1 = NULL; finish: count = 0; goto repeat; |
fcf6b1b72 ext4: refactor ex... |
5684 |
} |
ed8a1a766 ext4: rename ext4... |
5685 |
path2 = ext4_find_extent(inode2, lblk2, NULL, EXT4_EX_NOCACHE); |
a1c83681d fs: Drop unlikely... |
5686 |
if (IS_ERR(path2)) { |
fcf6b1b72 ext4: refactor ex... |
5687 |
*erp = PTR_ERR(path2); |
19008f6df ext4: fix ext4_sw... |
5688 5689 |
path2 = NULL; goto finish; |
fcf6b1b72 ext4: refactor ex... |
5690 5691 5692 5693 5694 |
} ex1 = path1[path1->p_depth].p_ext; ex2 = path2[path2->p_depth].p_ext; /* Do we have somthing to swap ? */ if (unlikely(!ex2 || !ex1)) |
19008f6df ext4: fix ext4_sw... |
5695 |
goto finish; |
fcf6b1b72 ext4: refactor ex... |
5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 |
e1_blk = le32_to_cpu(ex1->ee_block); e2_blk = le32_to_cpu(ex2->ee_block); e1_len = ext4_ext_get_actual_len(ex1); e2_len = ext4_ext_get_actual_len(ex2); /* Hole handling */ if (!in_range(lblk1, e1_blk, e1_len) || !in_range(lblk2, e2_blk, e2_len)) { ext4_lblk_t next1, next2; /* if hole after extent, then go to next extent */ next1 = ext4_ext_next_allocated_block(path1); next2 = ext4_ext_next_allocated_block(path2); /* If hole before extent, then shift to that extent */ if (e1_blk > lblk1) next1 = e1_blk; if (e2_blk > lblk2) next2 = e1_blk; /* Do we have something to swap */ if (next1 == EXT_MAX_BLOCKS || next2 == EXT_MAX_BLOCKS) |
19008f6df ext4: fix ext4_sw... |
5717 |
goto finish; |
fcf6b1b72 ext4: refactor ex... |
5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 |
/* Move to the rightest boundary */ len = next1 - lblk1; if (len < next2 - lblk2) len = next2 - lblk2; if (len > count) len = count; lblk1 += len; lblk2 += len; count -= len; goto repeat; } /* Prepare left boundary */ if (e1_blk < lblk1) { split = 1; *erp = ext4_force_split_extent_at(handle, inode1, |
dfe508093 ext4: drop EXT4_E... |
5734 |
&path1, lblk1, 0); |
19008f6df ext4: fix ext4_sw... |
5735 5736 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5737 5738 5739 5740 |
} if (e2_blk < lblk2) { split = 1; *erp = ext4_force_split_extent_at(handle, inode2, |
dfe508093 ext4: drop EXT4_E... |
5741 |
&path2, lblk2, 0); |
19008f6df ext4: fix ext4_sw... |
5742 5743 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5744 |
} |
dfe508093 ext4: drop EXT4_E... |
5745 |
/* ext4_split_extent_at() may result in leaf extent split, |
fcf6b1b72 ext4: refactor ex... |
5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 |
* path must to be revalidated. */ if (split) goto repeat; /* Prepare right boundary */ len = count; if (len > e1_blk + e1_len - lblk1) len = e1_blk + e1_len - lblk1; if (len > e2_blk + e2_len - lblk2) len = e2_blk + e2_len - lblk2; if (len != e1_len) { split = 1; *erp = ext4_force_split_extent_at(handle, inode1, |
dfe508093 ext4: drop EXT4_E... |
5760 |
&path1, lblk1 + len, 0); |
19008f6df ext4: fix ext4_sw... |
5761 5762 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5763 5764 5765 5766 |
} if (len != e2_len) { split = 1; *erp = ext4_force_split_extent_at(handle, inode2, |
dfe508093 ext4: drop EXT4_E... |
5767 |
&path2, lblk2 + len, 0); |
fcf6b1b72 ext4: refactor ex... |
5768 |
if (*erp) |
19008f6df ext4: fix ext4_sw... |
5769 |
goto finish; |
fcf6b1b72 ext4: refactor ex... |
5770 |
} |
dfe508093 ext4: drop EXT4_E... |
5771 |
/* ext4_split_extent_at() may result in leaf extent split, |
fcf6b1b72 ext4: refactor ex... |
5772 5773 5774 5775 5776 5777 |
* path must to be revalidated. */ if (split) goto repeat; BUG_ON(e2_len != e1_len); *erp = ext4_ext_get_access(handle, inode1, path1 + path1->p_depth); |
19008f6df ext4: fix ext4_sw... |
5778 5779 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5780 |
*erp = ext4_ext_get_access(handle, inode2, path2 + path2->p_depth); |
19008f6df ext4: fix ext4_sw... |
5781 5782 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 |
/* Both extents are fully inside boundaries. Swap it now */ tmp_ex = *ex1; ext4_ext_store_pblock(ex1, ext4_ext_pblock(ex2)); ext4_ext_store_pblock(ex2, ext4_ext_pblock(&tmp_ex)); ex1->ee_len = cpu_to_le16(e2_len); ex2->ee_len = cpu_to_le16(e1_len); if (unwritten) ext4_ext_mark_unwritten(ex2); if (ext4_ext_is_unwritten(&tmp_ex)) ext4_ext_mark_unwritten(ex1); ext4_ext_try_to_merge(handle, inode2, path2, ex2); ext4_ext_try_to_merge(handle, inode1, path1, ex1); *erp = ext4_ext_dirty(handle, inode2, path2 + path2->p_depth); |
19008f6df ext4: fix ext4_sw... |
5799 5800 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5801 5802 5803 5804 5805 5806 5807 5808 |
*erp = ext4_ext_dirty(handle, inode1, path1 + path1->p_depth); /* * Looks scarry ah..? second inode already points to new blocks, * and it was successfully dirtied. But luckily error may happen * only due to journal error, so full transaction will be * aborted anyway. */ |
19008f6df ext4: fix ext4_sw... |
5809 5810 |
if (unlikely(*erp)) goto finish; |
fcf6b1b72 ext4: refactor ex... |
5811 5812 5813 5814 5815 5816 |
lblk1 += len; lblk2 += len; replaced_count += len; count -= len; repeat: |
b7ea89ad0 ext4: allow a NUL... |
5817 5818 5819 5820 5821 |
ext4_ext_drop_refs(path1); kfree(path1); ext4_ext_drop_refs(path2); kfree(path2); path1 = path2 = NULL; |
fcf6b1b72 ext4: refactor ex... |
5822 |
} |
fcf6b1b72 ext4: refactor ex... |
5823 5824 |
return replaced_count; } |