1 /* 2 * linux/fs/ext4/inode.c 3 * 4 * Copyright (C) 1992, 1993, 1994, 1995 5 * Remy Card (card@masi.ibp.fr) 6 * Laboratoire MASI - Institut Blaise Pascal 7 * Universite Pierre et Marie Curie (Paris VI) 8 * 9 * from 10 * 11 * linux/fs/minix/inode.c 12 * 13 * Copyright (C) 1991, 1992 Linus Torvalds 14 * 15 * Goal-directed block allocation by Stephen Tweedie 16 * (sct@redhat.com), 1993, 1998 17 * Big-endian to little-endian byte-swapping/bitmaps by 18 * David S. Miller (davem@caip.rutgers.edu), 1995 19 * 64-bit file support on 64-bit platforms by Jakub Jelinek 20 * (jj@sunsite.ms.mff.cuni.cz) 21 * 22 * Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000 23 */ 24 25 #include <linux/module.h> 26 #include <linux/fs.h> 27 #include <linux/time.h> 28 #include <linux/jbd2.h> 29 #include <linux/highuid.h> 30 #include <linux/pagemap.h> 31 #include <linux/quotaops.h> 32 #include <linux/string.h> 33 #include <linux/buffer_head.h> 34 #include <linux/writeback.h> 35 #include <linux/pagevec.h> 36 #include <linux/mpage.h> 37 #include <linux/namei.h> 38 #include <linux/uio.h> 39 #include <linux/bio.h> 40 #include <linux/workqueue.h> 41 #include <linux/kernel.h> 42 #include <linux/printk.h> 43 #include <linux/slab.h> 44 #include <linux/ratelimit.h> 45 46 #include "ext4_jbd2.h" 47 #include "xattr.h" 48 #include "acl.h" 49 #include "ext4_extents.h" 50 51 #include <trace/events/ext4.h> 52 53 #define MPAGE_DA_EXTENT_TAIL 0x01 54 55 static inline int ext4_begin_ordered_truncate(struct inode *inode, 56 loff_t new_size) 57 { 58 trace_ext4_begin_ordered_truncate(inode, new_size); 59 /* 60 * If jinode is zero, then we never opened the file for 61 * writing, so there's no need to call 62 * jbd2_journal_begin_ordered_truncate() since there's no 63 * outstanding writes we need to flush. 64 */ 65 if (!EXT4_I(inode)->jinode) 66 return 0; 67 return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode), 68 EXT4_I(inode)->jinode, 69 new_size); 70 } 71 72 static void ext4_invalidatepage(struct page *page, unsigned long offset); 73 static int noalloc_get_block_write(struct inode *inode, sector_t iblock, 74 struct buffer_head *bh_result, int create); 75 static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode); 76 static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate); 77 static int __ext4_journalled_writepage(struct page *page, unsigned int len); 78 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh); 79 80 /* 81 * Test whether an inode is a fast symlink. 82 */ 83 static int ext4_inode_is_fast_symlink(struct inode *inode) 84 { 85 int ea_blocks = EXT4_I(inode)->i_file_acl ? 86 (inode->i_sb->s_blocksize >> 9) : 0; 87 88 return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0); 89 } 90 91 /* 92 * Work out how many blocks we need to proceed with the next chunk of a 93 * truncate transaction. 94 */ 95 static unsigned long blocks_for_truncate(struct inode *inode) 96 { 97 ext4_lblk_t needed; 98 99 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); 100 101 /* Give ourselves just enough room to cope with inodes in which 102 * i_blocks is corrupt: we've seen disk corruptions in the past 103 * which resulted in random data in an inode which looked enough 104 * like a regular file for ext4 to try to delete it. Things 105 * will go a bit crazy if that happens, but at least we should 106 * try not to panic the whole kernel. */ 107 if (needed < 2) 108 needed = 2; 109 110 /* But we need to bound the transaction so we don't overflow the 111 * journal. */ 112 if (needed > EXT4_MAX_TRANS_DATA) 113 needed = EXT4_MAX_TRANS_DATA; 114 115 return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed; 116 } 117 118 /* 119 * Truncate transactions can be complex and absolutely huge. So we need to 120 * be able to restart the transaction at a conventient checkpoint to make 121 * sure we don't overflow the journal. 122 * 123 * start_transaction gets us a new handle for a truncate transaction, 124 * and extend_transaction tries to extend the existing one a bit. If 125 * extend fails, we need to propagate the failure up and restart the 126 * transaction in the top-level truncate loop. --sct 127 */ 128 static handle_t *start_transaction(struct inode *inode) 129 { 130 handle_t *result; 131 132 result = ext4_journal_start(inode, blocks_for_truncate(inode)); 133 if (!IS_ERR(result)) 134 return result; 135 136 ext4_std_error(inode->i_sb, PTR_ERR(result)); 137 return result; 138 } 139 140 /* 141 * Try to extend this transaction for the purposes of truncation. 142 * 143 * Returns 0 if we managed to create more room. If we can't create more 144 * room, and the transaction must be restarted we return 1. 145 */ 146 static int try_to_extend_transaction(handle_t *handle, struct inode *inode) 147 { 148 if (!ext4_handle_valid(handle)) 149 return 0; 150 if (ext4_handle_has_enough_credits(handle, EXT4_RESERVE_TRANS_BLOCKS+1)) 151 return 0; 152 if (!ext4_journal_extend(handle, blocks_for_truncate(inode))) 153 return 0; 154 return 1; 155 } 156 157 /* 158 * Restart the transaction associated with *handle. This does a commit, 159 * so before we call here everything must be consistently dirtied against 160 * this transaction. 161 */ 162 int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode, 163 int nblocks) 164 { 165 int ret; 166 167 /* 168 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this 169 * moment, get_block can be called only for blocks inside i_size since 170 * page cache has been already dropped and writes are blocked by 171 * i_mutex. So we can safely drop the i_data_sem here. 172 */ 173 BUG_ON(EXT4_JOURNAL(inode) == NULL); 174 jbd_debug(2, "restarting handle %p\n", handle); 175 up_write(&EXT4_I(inode)->i_data_sem); 176 ret = ext4_journal_restart(handle, nblocks); 177 down_write(&EXT4_I(inode)->i_data_sem); 178 ext4_discard_preallocations(inode); 179 180 return ret; 181 } 182 183 /* 184 * Called at the last iput() if i_nlink is zero. 185 */ 186 void ext4_evict_inode(struct inode *inode) 187 { 188 handle_t *handle; 189 int err; 190 191 trace_ext4_evict_inode(inode); 192 if (inode->i_nlink) { 193 truncate_inode_pages(&inode->i_data, 0); 194 goto no_delete; 195 } 196 197 if (!is_bad_inode(inode)) 198 dquot_initialize(inode); 199 200 if (ext4_should_order_data(inode)) 201 ext4_begin_ordered_truncate(inode, 0); 202 truncate_inode_pages(&inode->i_data, 0); 203 204 if (is_bad_inode(inode)) 205 goto no_delete; 206 207 handle = ext4_journal_start(inode, blocks_for_truncate(inode)+3); 208 if (IS_ERR(handle)) { 209 ext4_std_error(inode->i_sb, PTR_ERR(handle)); 210 /* 211 * If we're going to skip the normal cleanup, we still need to 212 * make sure that the in-core orphan linked list is properly 213 * cleaned up. 214 */ 215 ext4_orphan_del(NULL, inode); 216 goto no_delete; 217 } 218 219 if (IS_SYNC(inode)) 220 ext4_handle_sync(handle); 221 inode->i_size = 0; 222 err = ext4_mark_inode_dirty(handle, inode); 223 if (err) { 224 ext4_warning(inode->i_sb, 225 "couldn't mark inode dirty (err %d)", err); 226 goto stop_handle; 227 } 228 if (inode->i_blocks) 229 ext4_truncate(inode); 230 231 /* 232 * ext4_ext_truncate() doesn't reserve any slop when it 233 * restarts journal transactions; therefore there may not be 234 * enough credits left in the handle to remove the inode from 235 * the orphan list and set the dtime field. 236 */ 237 if (!ext4_handle_has_enough_credits(handle, 3)) { 238 err = ext4_journal_extend(handle, 3); 239 if (err > 0) 240 err = ext4_journal_restart(handle, 3); 241 if (err != 0) { 242 ext4_warning(inode->i_sb, 243 "couldn't extend journal (err %d)", err); 244 stop_handle: 245 ext4_journal_stop(handle); 246 ext4_orphan_del(NULL, inode); 247 goto no_delete; 248 } 249 } 250 251 /* 252 * Kill off the orphan record which ext4_truncate created. 253 * AKPM: I think this can be inside the above `if'. 254 * Note that ext4_orphan_del() has to be able to cope with the 255 * deletion of a non-existent orphan - this is because we don't 256 * know if ext4_truncate() actually created an orphan record. 257 * (Well, we could do this if we need to, but heck - it works) 258 */ 259 ext4_orphan_del(handle, inode); 260 EXT4_I(inode)->i_dtime = get_seconds(); 261 262 /* 263 * One subtle ordering requirement: if anything has gone wrong 264 * (transaction abort, IO errors, whatever), then we can still 265 * do these next steps (the fs will already have been marked as 266 * having errors), but we can't free the inode if the mark_dirty 267 * fails. 268 */ 269 if (ext4_mark_inode_dirty(handle, inode)) 270 /* If that failed, just do the required in-core inode clear. */ 271 ext4_clear_inode(inode); 272 else 273 ext4_free_inode(handle, inode); 274 ext4_journal_stop(handle); 275 return; 276 no_delete: 277 ext4_clear_inode(inode); /* We must guarantee clearing of inode... */ 278 } 279 280 typedef struct { 281 __le32 *p; 282 __le32 key; 283 struct buffer_head *bh; 284 } Indirect; 285 286 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v) 287 { 288 p->key = *(p->p = v); 289 p->bh = bh; 290 } 291 292 /** 293 * ext4_block_to_path - parse the block number into array of offsets 294 * @inode: inode in question (we are only interested in its superblock) 295 * @i_block: block number to be parsed 296 * @offsets: array to store the offsets in 297 * @boundary: set this non-zero if the referred-to block is likely to be 298 * followed (on disk) by an indirect block. 299 * 300 * To store the locations of file's data ext4 uses a data structure common 301 * for UNIX filesystems - tree of pointers anchored in the inode, with 302 * data blocks at leaves and indirect blocks in intermediate nodes. 303 * This function translates the block number into path in that tree - 304 * return value is the path length and @offsets[n] is the offset of 305 * pointer to (n+1)th node in the nth one. If @block is out of range 306 * (negative or too large) warning is printed and zero returned. 307 * 308 * Note: function doesn't find node addresses, so no IO is needed. All 309 * we need to know is the capacity of indirect blocks (taken from the 310 * inode->i_sb). 311 */ 312 313 /* 314 * Portability note: the last comparison (check that we fit into triple 315 * indirect block) is spelled differently, because otherwise on an 316 * architecture with 32-bit longs and 8Kb pages we might get into trouble 317 * if our filesystem had 8Kb blocks. We might use long long, but that would 318 * kill us on x86. Oh, well, at least the sign propagation does not matter - 319 * i_block would have to be negative in the very beginning, so we would not 320 * get there at all. 321 */ 322 323 static int ext4_block_to_path(struct inode *inode, 324 ext4_lblk_t i_block, 325 ext4_lblk_t offsets[4], int *boundary) 326 { 327 int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb); 328 int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb); 329 const long direct_blocks = EXT4_NDIR_BLOCKS, 330 indirect_blocks = ptrs, 331 double_blocks = (1 << (ptrs_bits * 2)); 332 int n = 0; 333 int final = 0; 334 335 if (i_block < direct_blocks) { 336 offsets[n++] = i_block; 337 final = direct_blocks; 338 } else if ((i_block -= direct_blocks) < indirect_blocks) { 339 offsets[n++] = EXT4_IND_BLOCK; 340 offsets[n++] = i_block; 341 final = ptrs; 342 } else if ((i_block -= indirect_blocks) < double_blocks) { 343 offsets[n++] = EXT4_DIND_BLOCK; 344 offsets[n++] = i_block >> ptrs_bits; 345 offsets[n++] = i_block & (ptrs - 1); 346 final = ptrs; 347 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) { 348 offsets[n++] = EXT4_TIND_BLOCK; 349 offsets[n++] = i_block >> (ptrs_bits * 2); 350 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1); 351 offsets[n++] = i_block & (ptrs - 1); 352 final = ptrs; 353 } else { 354 ext4_warning(inode->i_sb, "block %lu > max in inode %lu", 355 i_block + direct_blocks + 356 indirect_blocks + double_blocks, inode->i_ino); 357 } 358 if (boundary) 359 *boundary = final - 1 - (i_block & (ptrs - 1)); 360 return n; 361 } 362 363 static int __ext4_check_blockref(const char *function, unsigned int line, 364 struct inode *inode, 365 __le32 *p, unsigned int max) 366 { 367 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; 368 __le32 *bref = p; 369 unsigned int blk; 370 371 while (bref < p+max) { 372 blk = le32_to_cpu(*bref++); 373 if (blk && 374 unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb), 375 blk, 1))) { 376 es->s_last_error_block = cpu_to_le64(blk); 377 ext4_error_inode(inode, function, line, blk, 378 "invalid block"); 379 return -EIO; 380 } 381 } 382 return 0; 383 } 384 385 386 #define ext4_check_indirect_blockref(inode, bh) \ 387 __ext4_check_blockref(__func__, __LINE__, inode, \ 388 (__le32 *)(bh)->b_data, \ 389 EXT4_ADDR_PER_BLOCK((inode)->i_sb)) 390 391 #define ext4_check_inode_blockref(inode) \ 392 __ext4_check_blockref(__func__, __LINE__, inode, \ 393 EXT4_I(inode)->i_data, \ 394 EXT4_NDIR_BLOCKS) 395 396 /** 397 * ext4_get_branch - read the chain of indirect blocks leading to data 398 * @inode: inode in question 399 * @depth: depth of the chain (1 - direct pointer, etc.) 400 * @offsets: offsets of pointers in inode/indirect blocks 401 * @chain: place to store the result 402 * @err: here we store the error value 403 * 404 * Function fills the array of triples <key, p, bh> and returns %NULL 405 * if everything went OK or the pointer to the last filled triple 406 * (incomplete one) otherwise. Upon the return chain[i].key contains 407 * the number of (i+1)-th block in the chain (as it is stored in memory, 408 * i.e. little-endian 32-bit), chain[i].p contains the address of that 409 * number (it points into struct inode for i==0 and into the bh->b_data 410 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect 411 * block for i>0 and NULL for i==0. In other words, it holds the block 412 * numbers of the chain, addresses they were taken from (and where we can 413 * verify that chain did not change) and buffer_heads hosting these 414 * numbers. 415 * 416 * Function stops when it stumbles upon zero pointer (absent block) 417 * (pointer to last triple returned, *@err == 0) 418 * or when it gets an IO error reading an indirect block 419 * (ditto, *@err == -EIO) 420 * or when it reads all @depth-1 indirect blocks successfully and finds 421 * the whole chain, all way to the data (returns %NULL, *err == 0). 422 * 423 * Need to be called with 424 * down_read(&EXT4_I(inode)->i_data_sem) 425 */ 426 static Indirect *ext4_get_branch(struct inode *inode, int depth, 427 ext4_lblk_t *offsets, 428 Indirect chain[4], int *err) 429 { 430 struct super_block *sb = inode->i_sb; 431 Indirect *p = chain; 432 struct buffer_head *bh; 433 434 *err = 0; 435 /* i_data is not going away, no lock needed */ 436 add_chain(chain, NULL, EXT4_I(inode)->i_data + *offsets); 437 if (!p->key) 438 goto no_block; 439 while (--depth) { 440 bh = sb_getblk(sb, le32_to_cpu(p->key)); 441 if (unlikely(!bh)) 442 goto failure; 443 444 if (!bh_uptodate_or_lock(bh)) { 445 if (bh_submit_read(bh) < 0) { 446 put_bh(bh); 447 goto failure; 448 } 449 /* validate block references */ 450 if (ext4_check_indirect_blockref(inode, bh)) { 451 put_bh(bh); 452 goto failure; 453 } 454 } 455 456 add_chain(++p, bh, (__le32 *)bh->b_data + *++offsets); 457 /* Reader: end */ 458 if (!p->key) 459 goto no_block; 460 } 461 return NULL; 462 463 failure: 464 *err = -EIO; 465 no_block: 466 return p; 467 } 468 469 /** 470 * ext4_find_near - find a place for allocation with sufficient locality 471 * @inode: owner 472 * @ind: descriptor of indirect block. 473 * 474 * This function returns the preferred place for block allocation. 475 * It is used when heuristic for sequential allocation fails. 476 * Rules are: 477 * + if there is a block to the left of our position - allocate near it. 478 * + if pointer will live in indirect block - allocate near that block. 479 * + if pointer will live in inode - allocate in the same 480 * cylinder group. 481 * 482 * In the latter case we colour the starting block by the callers PID to 483 * prevent it from clashing with concurrent allocations for a different inode 484 * in the same block group. The PID is used here so that functionally related 485 * files will be close-by on-disk. 486 * 487 * Caller must make sure that @ind is valid and will stay that way. 488 */ 489 static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind) 490 { 491 struct ext4_inode_info *ei = EXT4_I(inode); 492 __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data; 493 __le32 *p; 494 ext4_fsblk_t bg_start; 495 ext4_fsblk_t last_block; 496 ext4_grpblk_t colour; 497 ext4_group_t block_group; 498 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb)); 499 500 /* Try to find previous block */ 501 for (p = ind->p - 1; p >= start; p--) { 502 if (*p) 503 return le32_to_cpu(*p); 504 } 505 506 /* No such thing, so let's try location of indirect block */ 507 if (ind->bh) 508 return ind->bh->b_blocknr; 509 510 /* 511 * It is going to be referred to from the inode itself? OK, just put it 512 * into the same cylinder group then. 513 */ 514 block_group = ei->i_block_group; 515 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) { 516 block_group &= ~(flex_size-1); 517 if (S_ISREG(inode->i_mode)) 518 block_group++; 519 } 520 bg_start = ext4_group_first_block_no(inode->i_sb, block_group); 521 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1; 522 523 /* 524 * If we are doing delayed allocation, we don't need take 525 * colour into account. 526 */ 527 if (test_opt(inode->i_sb, DELALLOC)) 528 return bg_start; 529 530 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block) 531 colour = (current->pid % 16) * 532 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16); 533 else 534 colour = (current->pid % 16) * ((last_block - bg_start) / 16); 535 return bg_start + colour; 536 } 537 538 /** 539 * ext4_find_goal - find a preferred place for allocation. 540 * @inode: owner 541 * @block: block we want 542 * @partial: pointer to the last triple within a chain 543 * 544 * Normally this function find the preferred place for block allocation, 545 * returns it. 546 * Because this is only used for non-extent files, we limit the block nr 547 * to 32 bits. 548 */ 549 static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block, 550 Indirect *partial) 551 { 552 ext4_fsblk_t goal; 553 554 /* 555 * XXX need to get goal block from mballoc's data structures 556 */ 557 558 goal = ext4_find_near(inode, partial); 559 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS; 560 return goal; 561 } 562 563 /** 564 * ext4_blks_to_allocate - Look up the block map and count the number 565 * of direct blocks need to be allocated for the given branch. 566 * 567 * @branch: chain of indirect blocks 568 * @k: number of blocks need for indirect blocks 569 * @blks: number of data blocks to be mapped. 570 * @blocks_to_boundary: the offset in the indirect block 571 * 572 * return the total number of blocks to be allocate, including the 573 * direct and indirect blocks. 574 */ 575 static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks, 576 int blocks_to_boundary) 577 { 578 unsigned int count = 0; 579 580 /* 581 * Simple case, [t,d]Indirect block(s) has not allocated yet 582 * then it's clear blocks on that path have not allocated 583 */ 584 if (k > 0) { 585 /* right now we don't handle cross boundary allocation */ 586 if (blks < blocks_to_boundary + 1) 587 count += blks; 588 else 589 count += blocks_to_boundary + 1; 590 return count; 591 } 592 593 count++; 594 while (count < blks && count <= blocks_to_boundary && 595 le32_to_cpu(*(branch[0].p + count)) == 0) { 596 count++; 597 } 598 return count; 599 } 600 601 /** 602 * ext4_alloc_blocks: multiple allocate blocks needed for a branch 603 * @handle: handle for this transaction 604 * @inode: inode which needs allocated blocks 605 * @iblock: the logical block to start allocated at 606 * @goal: preferred physical block of allocation 607 * @indirect_blks: the number of blocks need to allocate for indirect 608 * blocks 609 * @blks: number of desired blocks 610 * @new_blocks: on return it will store the new block numbers for 611 * the indirect blocks(if needed) and the first direct block, 612 * @err: on return it will store the error code 613 * 614 * This function will return the number of blocks allocated as 615 * requested by the passed-in parameters. 616 */ 617 static int ext4_alloc_blocks(handle_t *handle, struct inode *inode, 618 ext4_lblk_t iblock, ext4_fsblk_t goal, 619 int indirect_blks, int blks, 620 ext4_fsblk_t new_blocks[4], int *err) 621 { 622 struct ext4_allocation_request ar; 623 int target, i; 624 unsigned long count = 0, blk_allocated = 0; 625 int index = 0; 626 ext4_fsblk_t current_block = 0; 627 int ret = 0; 628 629 /* 630 * Here we try to allocate the requested multiple blocks at once, 631 * on a best-effort basis. 632 * To build a branch, we should allocate blocks for 633 * the indirect blocks(if not allocated yet), and at least 634 * the first direct block of this branch. That's the 635 * minimum number of blocks need to allocate(required) 636 */ 637 /* first we try to allocate the indirect blocks */ 638 target = indirect_blks; 639 while (target > 0) { 640 count = target; 641 /* allocating blocks for indirect blocks and direct blocks */ 642 current_block = ext4_new_meta_blocks(handle, inode, 643 goal, &count, err); 644 if (*err) 645 goto failed_out; 646 647 if (unlikely(current_block + count > EXT4_MAX_BLOCK_FILE_PHYS)) { 648 EXT4_ERROR_INODE(inode, 649 "current_block %llu + count %lu > %d!", 650 current_block, count, 651 EXT4_MAX_BLOCK_FILE_PHYS); 652 *err = -EIO; 653 goto failed_out; 654 } 655 656 target -= count; 657 /* allocate blocks for indirect blocks */ 658 while (index < indirect_blks && count) { 659 new_blocks[index++] = current_block++; 660 count--; 661 } 662 if (count > 0) { 663 /* 664 * save the new block number 665 * for the first direct block 666 */ 667 new_blocks[index] = current_block; 668 printk(KERN_INFO "%s returned more blocks than " 669 "requested\n", __func__); 670 WARN_ON(1); 671 break; 672 } 673 } 674 675 target = blks - count ; 676 blk_allocated = count; 677 if (!target) 678 goto allocated; 679 /* Now allocate data blocks */ 680 memset(&ar, 0, sizeof(ar)); 681 ar.inode = inode; 682 ar.goal = goal; 683 ar.len = target; 684 ar.logical = iblock; 685 if (S_ISREG(inode->i_mode)) 686 /* enable in-core preallocation only for regular files */ 687 ar.flags = EXT4_MB_HINT_DATA; 688 689 current_block = ext4_mb_new_blocks(handle, &ar, err); 690 if (unlikely(current_block + ar.len > EXT4_MAX_BLOCK_FILE_PHYS)) { 691 EXT4_ERROR_INODE(inode, 692 "current_block %llu + ar.len %d > %d!", 693 current_block, ar.len, 694 EXT4_MAX_BLOCK_FILE_PHYS); 695 *err = -EIO; 696 goto failed_out; 697 } 698 699 if (*err && (target == blks)) { 700 /* 701 * if the allocation failed and we didn't allocate 702 * any blocks before 703 */ 704 goto failed_out; 705 } 706 if (!*err) { 707 if (target == blks) { 708 /* 709 * save the new block number 710 * for the first direct block 711 */ 712 new_blocks[index] = current_block; 713 } 714 blk_allocated += ar.len; 715 } 716 allocated: 717 /* total number of blocks allocated for direct blocks */ 718 ret = blk_allocated; 719 *err = 0; 720 return ret; 721 failed_out: 722 for (i = 0; i < index; i++) 723 ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1, 0); 724 return ret; 725 } 726 727 /** 728 * ext4_alloc_branch - allocate and set up a chain of blocks. 729 * @handle: handle for this transaction 730 * @inode: owner 731 * @indirect_blks: number of allocated indirect blocks 732 * @blks: number of allocated direct blocks 733 * @goal: preferred place for allocation 734 * @offsets: offsets (in the blocks) to store the pointers to next. 735 * @branch: place to store the chain in. 736 * 737 * This function allocates blocks, zeroes out all but the last one, 738 * links them into chain and (if we are synchronous) writes them to disk. 739 * In other words, it prepares a branch that can be spliced onto the 740 * inode. It stores the information about that chain in the branch[], in 741 * the same format as ext4_get_branch() would do. We are calling it after 742 * we had read the existing part of chain and partial points to the last 743 * triple of that (one with zero ->key). Upon the exit we have the same 744 * picture as after the successful ext4_get_block(), except that in one 745 * place chain is disconnected - *branch->p is still zero (we did not 746 * set the last link), but branch->key contains the number that should 747 * be placed into *branch->p to fill that gap. 748 * 749 * If allocation fails we free all blocks we've allocated (and forget 750 * their buffer_heads) and return the error value the from failed 751 * ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain 752 * as described above and return 0. 753 */ 754 static int ext4_alloc_branch(handle_t *handle, struct inode *inode, 755 ext4_lblk_t iblock, int indirect_blks, 756 int *blks, ext4_fsblk_t goal, 757 ext4_lblk_t *offsets, Indirect *branch) 758 { 759 int blocksize = inode->i_sb->s_blocksize; 760 int i, n = 0; 761 int err = 0; 762 struct buffer_head *bh; 763 int num; 764 ext4_fsblk_t new_blocks[4]; 765 ext4_fsblk_t current_block; 766 767 num = ext4_alloc_blocks(handle, inode, iblock, goal, indirect_blks, 768 *blks, new_blocks, &err); 769 if (err) 770 return err; 771 772 branch[0].key = cpu_to_le32(new_blocks[0]); 773 /* 774 * metadata blocks and data blocks are allocated. 775 */ 776 for (n = 1; n <= indirect_blks; n++) { 777 /* 778 * Get buffer_head for parent block, zero it out 779 * and set the pointer to new one, then send 780 * parent to disk. 781 */ 782 bh = sb_getblk(inode->i_sb, new_blocks[n-1]); 783 if (unlikely(!bh)) { 784 err = -EIO; 785 goto failed; 786 } 787 788 branch[n].bh = bh; 789 lock_buffer(bh); 790 BUFFER_TRACE(bh, "call get_create_access"); 791 err = ext4_journal_get_create_access(handle, bh); 792 if (err) { 793 /* Don't brelse(bh) here; it's done in 794 * ext4_journal_forget() below */ 795 unlock_buffer(bh); 796 goto failed; 797 } 798 799 memset(bh->b_data, 0, blocksize); 800 branch[n].p = (__le32 *) bh->b_data + offsets[n]; 801 branch[n].key = cpu_to_le32(new_blocks[n]); 802 *branch[n].p = branch[n].key; 803 if (n == indirect_blks) { 804 current_block = new_blocks[n]; 805 /* 806 * End of chain, update the last new metablock of 807 * the chain to point to the new allocated 808 * data blocks numbers 809 */ 810 for (i = 1; i < num; i++) 811 *(branch[n].p + i) = cpu_to_le32(++current_block); 812 } 813 BUFFER_TRACE(bh, "marking uptodate"); 814 set_buffer_uptodate(bh); 815 unlock_buffer(bh); 816 817 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); 818 err = ext4_handle_dirty_metadata(handle, inode, bh); 819 if (err) 820 goto failed; 821 } 822 *blks = num; 823 return err; 824 failed: 825 /* Allocation failed, free what we already allocated */ 826 ext4_free_blocks(handle, inode, NULL, new_blocks[0], 1, 0); 827 for (i = 1; i <= n ; i++) { 828 /* 829 * branch[i].bh is newly allocated, so there is no 830 * need to revoke the block, which is why we don't 831 * need to set EXT4_FREE_BLOCKS_METADATA. 832 */ 833 ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1, 834 EXT4_FREE_BLOCKS_FORGET); 835 } 836 for (i = n+1; i < indirect_blks; i++) 837 ext4_free_blocks(handle, inode, NULL, new_blocks[i], 1, 0); 838 839 ext4_free_blocks(handle, inode, NULL, new_blocks[i], num, 0); 840 841 return err; 842 } 843 844 /** 845 * ext4_splice_branch - splice the allocated branch onto inode. 846 * @handle: handle for this transaction 847 * @inode: owner 848 * @block: (logical) number of block we are adding 849 * @chain: chain of indirect blocks (with a missing link - see 850 * ext4_alloc_branch) 851 * @where: location of missing link 852 * @num: number of indirect blocks we are adding 853 * @blks: number of direct blocks we are adding 854 * 855 * This function fills the missing link and does all housekeeping needed in 856 * inode (->i_blocks, etc.). In case of success we end up with the full 857 * chain to new block and return 0. 858 */ 859 static int ext4_splice_branch(handle_t *handle, struct inode *inode, 860 ext4_lblk_t block, Indirect *where, int num, 861 int blks) 862 { 863 int i; 864 int err = 0; 865 ext4_fsblk_t current_block; 866 867 /* 868 * If we're splicing into a [td]indirect block (as opposed to the 869 * inode) then we need to get write access to the [td]indirect block 870 * before the splice. 871 */ 872 if (where->bh) { 873 BUFFER_TRACE(where->bh, "get_write_access"); 874 err = ext4_journal_get_write_access(handle, where->bh); 875 if (err) 876 goto err_out; 877 } 878 /* That's it */ 879 880 *where->p = where->key; 881 882 /* 883 * Update the host buffer_head or inode to point to more just allocated 884 * direct blocks blocks 885 */ 886 if (num == 0 && blks > 1) { 887 current_block = le32_to_cpu(where->key) + 1; 888 for (i = 1; i < blks; i++) 889 *(where->p + i) = cpu_to_le32(current_block++); 890 } 891 892 /* We are done with atomic stuff, now do the rest of housekeeping */ 893 /* had we spliced it onto indirect block? */ 894 if (where->bh) { 895 /* 896 * If we spliced it onto an indirect block, we haven't 897 * altered the inode. Note however that if it is being spliced 898 * onto an indirect block at the very end of the file (the 899 * file is growing) then we *will* alter the inode to reflect 900 * the new i_size. But that is not done here - it is done in 901 * generic_commit_write->__mark_inode_dirty->ext4_dirty_inode. 902 */ 903 jbd_debug(5, "splicing indirect only\n"); 904 BUFFER_TRACE(where->bh, "call ext4_handle_dirty_metadata"); 905 err = ext4_handle_dirty_metadata(handle, inode, where->bh); 906 if (err) 907 goto err_out; 908 } else { 909 /* 910 * OK, we spliced it into the inode itself on a direct block. 911 */ 912 ext4_mark_inode_dirty(handle, inode); 913 jbd_debug(5, "splicing direct\n"); 914 } 915 return err; 916 917 err_out: 918 for (i = 1; i <= num; i++) { 919 /* 920 * branch[i].bh is newly allocated, so there is no 921 * need to revoke the block, which is why we don't 922 * need to set EXT4_FREE_BLOCKS_METADATA. 923 */ 924 ext4_free_blocks(handle, inode, where[i].bh, 0, 1, 925 EXT4_FREE_BLOCKS_FORGET); 926 } 927 ext4_free_blocks(handle, inode, NULL, le32_to_cpu(where[num].key), 928 blks, 0); 929 930 return err; 931 } 932 933 /* 934 * The ext4_ind_map_blocks() function handles non-extents inodes 935 * (i.e., using the traditional indirect/double-indirect i_blocks 936 * scheme) for ext4_map_blocks(). 937 * 938 * Allocation strategy is simple: if we have to allocate something, we will 939 * have to go the whole way to leaf. So let's do it before attaching anything 940 * to tree, set linkage between the newborn blocks, write them if sync is 941 * required, recheck the path, free and repeat if check fails, otherwise 942 * set the last missing link (that will protect us from any truncate-generated 943 * removals - all blocks on the path are immune now) and possibly force the 944 * write on the parent block. 945 * That has a nice additional property: no special recovery from the failed 946 * allocations is needed - we simply release blocks and do not touch anything 947 * reachable from inode. 948 * 949 * `handle' can be NULL if create == 0. 950 * 951 * return > 0, # of blocks mapped or allocated. 952 * return = 0, if plain lookup failed. 953 * return < 0, error case. 954 * 955 * The ext4_ind_get_blocks() function should be called with 956 * down_write(&EXT4_I(inode)->i_data_sem) if allocating filesystem 957 * blocks (i.e., flags has EXT4_GET_BLOCKS_CREATE set) or 958 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system 959 * blocks. 960 */ 961 static int ext4_ind_map_blocks(handle_t *handle, struct inode *inode, 962 struct ext4_map_blocks *map, 963 int flags) 964 { 965 int err = -EIO; 966 ext4_lblk_t offsets[4]; 967 Indirect chain[4]; 968 Indirect *partial; 969 ext4_fsblk_t goal; 970 int indirect_blks; 971 int blocks_to_boundary = 0; 972 int depth; 973 int count = 0; 974 ext4_fsblk_t first_block = 0; 975 976 trace_ext4_ind_map_blocks_enter(inode, map->m_lblk, map->m_len, flags); 977 J_ASSERT(!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))); 978 J_ASSERT(handle != NULL || (flags & EXT4_GET_BLOCKS_CREATE) == 0); 979 depth = ext4_block_to_path(inode, map->m_lblk, offsets, 980 &blocks_to_boundary); 981 982 if (depth == 0) 983 goto out; 984 985 partial = ext4_get_branch(inode, depth, offsets, chain, &err); 986 987 /* Simplest case - block found, no allocation needed */ 988 if (!partial) { 989 first_block = le32_to_cpu(chain[depth - 1].key); 990 count++; 991 /*map more blocks*/ 992 while (count < map->m_len && count <= blocks_to_boundary) { 993 ext4_fsblk_t blk; 994 995 blk = le32_to_cpu(*(chain[depth-1].p + count)); 996 997 if (blk == first_block + count) 998 count++; 999 else 1000 break; 1001 } 1002 goto got_it; 1003 } 1004 1005 /* Next simple case - plain lookup or failed read of indirect block */ 1006 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0 || err == -EIO) 1007 goto cleanup; 1008 1009 /* 1010 * Okay, we need to do block allocation. 1011 */ 1012 goal = ext4_find_goal(inode, map->m_lblk, partial); 1013 1014 /* the number of blocks need to allocate for [d,t]indirect blocks */ 1015 indirect_blks = (chain + depth) - partial - 1; 1016 1017 /* 1018 * Next look up the indirect map to count the totoal number of 1019 * direct blocks to allocate for this branch. 1020 */ 1021 count = ext4_blks_to_allocate(partial, indirect_blks, 1022 map->m_len, blocks_to_boundary); 1023 /* 1024 * Block out ext4_truncate while we alter the tree 1025 */ 1026 err = ext4_alloc_branch(handle, inode, map->m_lblk, indirect_blks, 1027 &count, goal, 1028 offsets + (partial - chain), partial); 1029 1030 /* 1031 * The ext4_splice_branch call will free and forget any buffers 1032 * on the new chain if there is a failure, but that risks using 1033 * up transaction credits, especially for bitmaps where the 1034 * credits cannot be returned. Can we handle this somehow? We 1035 * may need to return -EAGAIN upwards in the worst case. --sct 1036 */ 1037 if (!err) 1038 err = ext4_splice_branch(handle, inode, map->m_lblk, 1039 partial, indirect_blks, count); 1040 if (err) 1041 goto cleanup; 1042 1043 map->m_flags |= EXT4_MAP_NEW; 1044 1045 ext4_update_inode_fsync_trans(handle, inode, 1); 1046 got_it: 1047 map->m_flags |= EXT4_MAP_MAPPED; 1048 map->m_pblk = le32_to_cpu(chain[depth-1].key); 1049 map->m_len = count; 1050 if (count > blocks_to_boundary) 1051 map->m_flags |= EXT4_MAP_BOUNDARY; 1052 err = count; 1053 /* Clean up and exit */ 1054 partial = chain + depth - 1; /* the whole chain */ 1055 cleanup: 1056 while (partial > chain) { 1057 BUFFER_TRACE(partial->bh, "call brelse"); 1058 brelse(partial->bh); 1059 partial--; 1060 } 1061 out: 1062 trace_ext4_ind_map_blocks_exit(inode, map->m_lblk, 1063 map->m_pblk, map->m_len, err); 1064 return err; 1065 } 1066 1067 #ifdef CONFIG_QUOTA 1068 qsize_t *ext4_get_reserved_space(struct inode *inode) 1069 { 1070 return &EXT4_I(inode)->i_reserved_quota; 1071 } 1072 #endif 1073 1074 /* 1075 * Calculate the number of metadata blocks need to reserve 1076 * to allocate a new block at @lblocks for non extent file based file 1077 */ 1078 static int ext4_indirect_calc_metadata_amount(struct inode *inode, 1079 sector_t lblock) 1080 { 1081 struct ext4_inode_info *ei = EXT4_I(inode); 1082 sector_t dind_mask = ~((sector_t)EXT4_ADDR_PER_BLOCK(inode->i_sb) - 1); 1083 int blk_bits; 1084 1085 if (lblock < EXT4_NDIR_BLOCKS) 1086 return 0; 1087 1088 lblock -= EXT4_NDIR_BLOCKS; 1089 1090 if (ei->i_da_metadata_calc_len && 1091 (lblock & dind_mask) == ei->i_da_metadata_calc_last_lblock) { 1092 ei->i_da_metadata_calc_len++; 1093 return 0; 1094 } 1095 ei->i_da_metadata_calc_last_lblock = lblock & dind_mask; 1096 ei->i_da_metadata_calc_len = 1; 1097 blk_bits = order_base_2(lblock); 1098 return (blk_bits / EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb)) + 1; 1099 } 1100 1101 /* 1102 * Calculate the number of metadata blocks need to reserve 1103 * to allocate a block located at @lblock 1104 */ 1105 static int ext4_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock) 1106 { 1107 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 1108 return ext4_ext_calc_metadata_amount(inode, lblock); 1109 1110 return ext4_indirect_calc_metadata_amount(inode, lblock); 1111 } 1112 1113 /* 1114 * Called with i_data_sem down, which is important since we can call 1115 * ext4_discard_preallocations() from here. 1116 */ 1117 void ext4_da_update_reserve_space(struct inode *inode, 1118 int used, int quota_claim) 1119 { 1120 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1121 struct ext4_inode_info *ei = EXT4_I(inode); 1122 1123 spin_lock(&ei->i_block_reservation_lock); 1124 trace_ext4_da_update_reserve_space(inode, used); 1125 if (unlikely(used > ei->i_reserved_data_blocks)) { 1126 ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d " 1127 "with only %d reserved data blocks\n", 1128 __func__, inode->i_ino, used, 1129 ei->i_reserved_data_blocks); 1130 WARN_ON(1); 1131 used = ei->i_reserved_data_blocks; 1132 } 1133 1134 /* Update per-inode reservations */ 1135 ei->i_reserved_data_blocks -= used; 1136 ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks; 1137 percpu_counter_sub(&sbi->s_dirtyblocks_counter, 1138 used + ei->i_allocated_meta_blocks); 1139 ei->i_allocated_meta_blocks = 0; 1140 1141 if (ei->i_reserved_data_blocks == 0) { 1142 /* 1143 * We can release all of the reserved metadata blocks 1144 * only when we have written all of the delayed 1145 * allocation blocks. 1146 */ 1147 percpu_counter_sub(&sbi->s_dirtyblocks_counter, 1148 ei->i_reserved_meta_blocks); 1149 ei->i_reserved_meta_blocks = 0; 1150 ei->i_da_metadata_calc_len = 0; 1151 } 1152 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 1153 1154 /* Update quota subsystem for data blocks */ 1155 if (quota_claim) 1156 dquot_claim_block(inode, used); 1157 else { 1158 /* 1159 * We did fallocate with an offset that is already delayed 1160 * allocated. So on delayed allocated writeback we should 1161 * not re-claim the quota for fallocated blocks. 1162 */ 1163 dquot_release_reservation_block(inode, used); 1164 } 1165 1166 /* 1167 * If we have done all the pending block allocations and if 1168 * there aren't any writers on the inode, we can discard the 1169 * inode's preallocations. 1170 */ 1171 if ((ei->i_reserved_data_blocks == 0) && 1172 (atomic_read(&inode->i_writecount) == 0)) 1173 ext4_discard_preallocations(inode); 1174 } 1175 1176 static int __check_block_validity(struct inode *inode, const char *func, 1177 unsigned int line, 1178 struct ext4_map_blocks *map) 1179 { 1180 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk, 1181 map->m_len)) { 1182 ext4_error_inode(inode, func, line, map->m_pblk, 1183 "lblock %lu mapped to illegal pblock " 1184 "(length %d)", (unsigned long) map->m_lblk, 1185 map->m_len); 1186 return -EIO; 1187 } 1188 return 0; 1189 } 1190 1191 #define check_block_validity(inode, map) \ 1192 __check_block_validity((inode), __func__, __LINE__, (map)) 1193 1194 /* 1195 * Return the number of contiguous dirty pages in a given inode 1196 * starting at page frame idx. 1197 */ 1198 static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx, 1199 unsigned int max_pages) 1200 { 1201 struct address_space *mapping = inode->i_mapping; 1202 pgoff_t index; 1203 struct pagevec pvec; 1204 pgoff_t num = 0; 1205 int i, nr_pages, done = 0; 1206 1207 if (max_pages == 0) 1208 return 0; 1209 pagevec_init(&pvec, 0); 1210 while (!done) { 1211 index = idx; 1212 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, 1213 PAGECACHE_TAG_DIRTY, 1214 (pgoff_t)PAGEVEC_SIZE); 1215 if (nr_pages == 0) 1216 break; 1217 for (i = 0; i < nr_pages; i++) { 1218 struct page *page = pvec.pages[i]; 1219 struct buffer_head *bh, *head; 1220 1221 lock_page(page); 1222 if (unlikely(page->mapping != mapping) || 1223 !PageDirty(page) || 1224 PageWriteback(page) || 1225 page->index != idx) { 1226 done = 1; 1227 unlock_page(page); 1228 break; 1229 } 1230 if (page_has_buffers(page)) { 1231 bh = head = page_buffers(page); 1232 do { 1233 if (!buffer_delay(bh) && 1234 !buffer_unwritten(bh)) 1235 done = 1; 1236 bh = bh->b_this_page; 1237 } while (!done && (bh != head)); 1238 } 1239 unlock_page(page); 1240 if (done) 1241 break; 1242 idx++; 1243 num++; 1244 if (num >= max_pages) { 1245 done = 1; 1246 break; 1247 } 1248 } 1249 pagevec_release(&pvec); 1250 } 1251 return num; 1252 } 1253 1254 /* 1255 * The ext4_map_blocks() function tries to look up the requested blocks, 1256 * and returns if the blocks are already mapped. 1257 * 1258 * Otherwise it takes the write lock of the i_data_sem and allocate blocks 1259 * and store the allocated blocks in the result buffer head and mark it 1260 * mapped. 1261 * 1262 * If file type is extents based, it will call ext4_ext_map_blocks(), 1263 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping 1264 * based files 1265 * 1266 * On success, it returns the number of blocks being mapped or allocate. 1267 * if create==0 and the blocks are pre-allocated and uninitialized block, 1268 * the result buffer head is unmapped. If the create ==1, it will make sure 1269 * the buffer head is mapped. 1270 * 1271 * It returns 0 if plain look up failed (blocks have not been allocated), in 1272 * that casem, buffer head is unmapped 1273 * 1274 * It returns the error in case of allocation failure. 1275 */ 1276 int ext4_map_blocks(handle_t *handle, struct inode *inode, 1277 struct ext4_map_blocks *map, int flags) 1278 { 1279 int retval; 1280 1281 map->m_flags = 0; 1282 ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u," 1283 "logical block %lu\n", inode->i_ino, flags, map->m_len, 1284 (unsigned long) map->m_lblk); 1285 /* 1286 * Try to see if we can get the block without requesting a new 1287 * file system block. 1288 */ 1289 down_read((&EXT4_I(inode)->i_data_sem)); 1290 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 1291 retval = ext4_ext_map_blocks(handle, inode, map, 0); 1292 } else { 1293 retval = ext4_ind_map_blocks(handle, inode, map, 0); 1294 } 1295 up_read((&EXT4_I(inode)->i_data_sem)); 1296 1297 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) { 1298 int ret = check_block_validity(inode, map); 1299 if (ret != 0) 1300 return ret; 1301 } 1302 1303 /* If it is only a block(s) look up */ 1304 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) 1305 return retval; 1306 1307 /* 1308 * Returns if the blocks have already allocated 1309 * 1310 * Note that if blocks have been preallocated 1311 * ext4_ext_get_block() returns th create = 0 1312 * with buffer head unmapped. 1313 */ 1314 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) 1315 return retval; 1316 1317 /* 1318 * When we call get_blocks without the create flag, the 1319 * BH_Unwritten flag could have gotten set if the blocks 1320 * requested were part of a uninitialized extent. We need to 1321 * clear this flag now that we are committed to convert all or 1322 * part of the uninitialized extent to be an initialized 1323 * extent. This is because we need to avoid the combination 1324 * of BH_Unwritten and BH_Mapped flags being simultaneously 1325 * set on the buffer_head. 1326 */ 1327 map->m_flags &= ~EXT4_MAP_UNWRITTEN; 1328 1329 /* 1330 * New blocks allocate and/or writing to uninitialized extent 1331 * will possibly result in updating i_data, so we take 1332 * the write lock of i_data_sem, and call get_blocks() 1333 * with create == 1 flag. 1334 */ 1335 down_write((&EXT4_I(inode)->i_data_sem)); 1336 1337 /* 1338 * if the caller is from delayed allocation writeout path 1339 * we have already reserved fs blocks for allocation 1340 * let the underlying get_block() function know to 1341 * avoid double accounting 1342 */ 1343 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) 1344 ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED); 1345 /* 1346 * We need to check for EXT4 here because migrate 1347 * could have changed the inode type in between 1348 */ 1349 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 1350 retval = ext4_ext_map_blocks(handle, inode, map, flags); 1351 } else { 1352 retval = ext4_ind_map_blocks(handle, inode, map, flags); 1353 1354 if (retval > 0 && map->m_flags & EXT4_MAP_NEW) { 1355 /* 1356 * We allocated new blocks which will result in 1357 * i_data's format changing. Force the migrate 1358 * to fail by clearing migrate flags 1359 */ 1360 ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE); 1361 } 1362 1363 /* 1364 * Update reserved blocks/metadata blocks after successful 1365 * block allocation which had been deferred till now. We don't 1366 * support fallocate for non extent files. So we can update 1367 * reserve space here. 1368 */ 1369 if ((retval > 0) && 1370 (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)) 1371 ext4_da_update_reserve_space(inode, retval, 1); 1372 } 1373 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) 1374 ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED); 1375 1376 up_write((&EXT4_I(inode)->i_data_sem)); 1377 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) { 1378 int ret = check_block_validity(inode, map); 1379 if (ret != 0) 1380 return ret; 1381 } 1382 return retval; 1383 } 1384 1385 /* Maximum number of blocks we map for direct IO at once. */ 1386 #define DIO_MAX_BLOCKS 4096 1387 1388 static int _ext4_get_block(struct inode *inode, sector_t iblock, 1389 struct buffer_head *bh, int flags) 1390 { 1391 handle_t *handle = ext4_journal_current_handle(); 1392 struct ext4_map_blocks map; 1393 int ret = 0, started = 0; 1394 int dio_credits; 1395 1396 map.m_lblk = iblock; 1397 map.m_len = bh->b_size >> inode->i_blkbits; 1398 1399 if (flags && !handle) { 1400 /* Direct IO write... */ 1401 if (map.m_len > DIO_MAX_BLOCKS) 1402 map.m_len = DIO_MAX_BLOCKS; 1403 dio_credits = ext4_chunk_trans_blocks(inode, map.m_len); 1404 handle = ext4_journal_start(inode, dio_credits); 1405 if (IS_ERR(handle)) { 1406 ret = PTR_ERR(handle); 1407 return ret; 1408 } 1409 started = 1; 1410 } 1411 1412 ret = ext4_map_blocks(handle, inode, &map, flags); 1413 if (ret > 0) { 1414 map_bh(bh, inode->i_sb, map.m_pblk); 1415 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags; 1416 bh->b_size = inode->i_sb->s_blocksize * map.m_len; 1417 ret = 0; 1418 } 1419 if (started) 1420 ext4_journal_stop(handle); 1421 return ret; 1422 } 1423 1424 int ext4_get_block(struct inode *inode, sector_t iblock, 1425 struct buffer_head *bh, int create) 1426 { 1427 return _ext4_get_block(inode, iblock, bh, 1428 create ? EXT4_GET_BLOCKS_CREATE : 0); 1429 } 1430 1431 /* 1432 * `handle' can be NULL if create is zero 1433 */ 1434 struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, 1435 ext4_lblk_t block, int create, int *errp) 1436 { 1437 struct ext4_map_blocks map; 1438 struct buffer_head *bh; 1439 int fatal = 0, err; 1440 1441 J_ASSERT(handle != NULL || create == 0); 1442 1443 map.m_lblk = block; 1444 map.m_len = 1; 1445 err = ext4_map_blocks(handle, inode, &map, 1446 create ? EXT4_GET_BLOCKS_CREATE : 0); 1447 1448 if (err < 0) 1449 *errp = err; 1450 if (err <= 0) 1451 return NULL; 1452 *errp = 0; 1453 1454 bh = sb_getblk(inode->i_sb, map.m_pblk); 1455 if (!bh) { 1456 *errp = -EIO; 1457 return NULL; 1458 } 1459 if (map.m_flags & EXT4_MAP_NEW) { 1460 J_ASSERT(create != 0); 1461 J_ASSERT(handle != NULL); 1462 1463 /* 1464 * Now that we do not always journal data, we should 1465 * keep in mind whether this should always journal the 1466 * new buffer as metadata. For now, regular file 1467 * writes use ext4_get_block instead, so it's not a 1468 * problem. 1469 */ 1470 lock_buffer(bh); 1471 BUFFER_TRACE(bh, "call get_create_access"); 1472 fatal = ext4_journal_get_create_access(handle, bh); 1473 if (!fatal && !buffer_uptodate(bh)) { 1474 memset(bh->b_data, 0, inode->i_sb->s_blocksize); 1475 set_buffer_uptodate(bh); 1476 } 1477 unlock_buffer(bh); 1478 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); 1479 err = ext4_handle_dirty_metadata(handle, inode, bh); 1480 if (!fatal) 1481 fatal = err; 1482 } else { 1483 BUFFER_TRACE(bh, "not a new buffer"); 1484 } 1485 if (fatal) { 1486 *errp = fatal; 1487 brelse(bh); 1488 bh = NULL; 1489 } 1490 return bh; 1491 } 1492 1493 struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode, 1494 ext4_lblk_t block, int create, int *err) 1495 { 1496 struct buffer_head *bh; 1497 1498 bh = ext4_getblk(handle, inode, block, create, err); 1499 if (!bh) 1500 return bh; 1501 if (buffer_uptodate(bh)) 1502 return bh; 1503 ll_rw_block(READ_META, 1, &bh); 1504 wait_on_buffer(bh); 1505 if (buffer_uptodate(bh)) 1506 return bh; 1507 put_bh(bh); 1508 *err = -EIO; 1509 return NULL; 1510 } 1511 1512 static int walk_page_buffers(handle_t *handle, 1513 struct buffer_head *head, 1514 unsigned from, 1515 unsigned to, 1516 int *partial, 1517 int (*fn)(handle_t *handle, 1518 struct buffer_head *bh)) 1519 { 1520 struct buffer_head *bh; 1521 unsigned block_start, block_end; 1522 unsigned blocksize = head->b_size; 1523 int err, ret = 0; 1524 struct buffer_head *next; 1525 1526 for (bh = head, block_start = 0; 1527 ret == 0 && (bh != head || !block_start); 1528 block_start = block_end, bh = next) { 1529 next = bh->b_this_page; 1530 block_end = block_start + blocksize; 1531 if (block_end <= from || block_start >= to) { 1532 if (partial && !buffer_uptodate(bh)) 1533 *partial = 1; 1534 continue; 1535 } 1536 err = (*fn)(handle, bh); 1537 if (!ret) 1538 ret = err; 1539 } 1540 return ret; 1541 } 1542 1543 /* 1544 * To preserve ordering, it is essential that the hole instantiation and 1545 * the data write be encapsulated in a single transaction. We cannot 1546 * close off a transaction and start a new one between the ext4_get_block() 1547 * and the commit_write(). So doing the jbd2_journal_start at the start of 1548 * prepare_write() is the right place. 1549 * 1550 * Also, this function can nest inside ext4_writepage() -> 1551 * block_write_full_page(). In that case, we *know* that ext4_writepage() 1552 * has generated enough buffer credits to do the whole page. So we won't 1553 * block on the journal in that case, which is good, because the caller may 1554 * be PF_MEMALLOC. 1555 * 1556 * By accident, ext4 can be reentered when a transaction is open via 1557 * quota file writes. If we were to commit the transaction while thus 1558 * reentered, there can be a deadlock - we would be holding a quota 1559 * lock, and the commit would never complete if another thread had a 1560 * transaction open and was blocking on the quota lock - a ranking 1561 * violation. 1562 * 1563 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start 1564 * will _not_ run commit under these circumstances because handle->h_ref 1565 * is elevated. We'll still have enough credits for the tiny quotafile 1566 * write. 1567 */ 1568 static int do_journal_get_write_access(handle_t *handle, 1569 struct buffer_head *bh) 1570 { 1571 int dirty = buffer_dirty(bh); 1572 int ret; 1573 1574 if (!buffer_mapped(bh) || buffer_freed(bh)) 1575 return 0; 1576 /* 1577 * __block_write_begin() could have dirtied some buffers. Clean 1578 * the dirty bit as jbd2_journal_get_write_access() could complain 1579 * otherwise about fs integrity issues. Setting of the dirty bit 1580 * by __block_write_begin() isn't a real problem here as we clear 1581 * the bit before releasing a page lock and thus writeback cannot 1582 * ever write the buffer. 1583 */ 1584 if (dirty) 1585 clear_buffer_dirty(bh); 1586 ret = ext4_journal_get_write_access(handle, bh); 1587 if (!ret && dirty) 1588 ret = ext4_handle_dirty_metadata(handle, NULL, bh); 1589 return ret; 1590 } 1591 1592 /* 1593 * Truncate blocks that were not used by write. We have to truncate the 1594 * pagecache as well so that corresponding buffers get properly unmapped. 1595 */ 1596 static void ext4_truncate_failed_write(struct inode *inode) 1597 { 1598 truncate_inode_pages(inode->i_mapping, inode->i_size); 1599 ext4_truncate(inode); 1600 } 1601 1602 static int ext4_get_block_write(struct inode *inode, sector_t iblock, 1603 struct buffer_head *bh_result, int create); 1604 static int ext4_write_begin(struct file *file, struct address_space *mapping, 1605 loff_t pos, unsigned len, unsigned flags, 1606 struct page **pagep, void **fsdata) 1607 { 1608 struct inode *inode = mapping->host; 1609 int ret, needed_blocks; 1610 handle_t *handle; 1611 int retries = 0; 1612 struct page *page; 1613 pgoff_t index; 1614 unsigned from, to; 1615 1616 trace_ext4_write_begin(inode, pos, len, flags); 1617 /* 1618 * Reserve one block more for addition to orphan list in case 1619 * we allocate blocks but write fails for some reason 1620 */ 1621 needed_blocks = ext4_writepage_trans_blocks(inode) + 1; 1622 index = pos >> PAGE_CACHE_SHIFT; 1623 from = pos & (PAGE_CACHE_SIZE - 1); 1624 to = from + len; 1625 1626 retry: 1627 handle = ext4_journal_start(inode, needed_blocks); 1628 if (IS_ERR(handle)) { 1629 ret = PTR_ERR(handle); 1630 goto out; 1631 } 1632 1633 /* We cannot recurse into the filesystem as the transaction is already 1634 * started */ 1635 flags |= AOP_FLAG_NOFS; 1636 1637 page = grab_cache_page_write_begin(mapping, index, flags); 1638 if (!page) { 1639 ext4_journal_stop(handle); 1640 ret = -ENOMEM; 1641 goto out; 1642 } 1643 *pagep = page; 1644 1645 if (ext4_should_dioread_nolock(inode)) 1646 ret = __block_write_begin(page, pos, len, ext4_get_block_write); 1647 else 1648 ret = __block_write_begin(page, pos, len, ext4_get_block); 1649 1650 if (!ret && ext4_should_journal_data(inode)) { 1651 ret = walk_page_buffers(handle, page_buffers(page), 1652 from, to, NULL, do_journal_get_write_access); 1653 } 1654 1655 if (ret) { 1656 unlock_page(page); 1657 page_cache_release(page); 1658 /* 1659 * __block_write_begin may have instantiated a few blocks 1660 * outside i_size. Trim these off again. Don't need 1661 * i_size_read because we hold i_mutex. 1662 * 1663 * Add inode to orphan list in case we crash before 1664 * truncate finishes 1665 */ 1666 if (pos + len > inode->i_size && ext4_can_truncate(inode)) 1667 ext4_orphan_add(handle, inode); 1668 1669 ext4_journal_stop(handle); 1670 if (pos + len > inode->i_size) { 1671 ext4_truncate_failed_write(inode); 1672 /* 1673 * If truncate failed early the inode might 1674 * still be on the orphan list; we need to 1675 * make sure the inode is removed from the 1676 * orphan list in that case. 1677 */ 1678 if (inode->i_nlink) 1679 ext4_orphan_del(NULL, inode); 1680 } 1681 } 1682 1683 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) 1684 goto retry; 1685 out: 1686 return ret; 1687 } 1688 1689 /* For write_end() in data=journal mode */ 1690 static int write_end_fn(handle_t *handle, struct buffer_head *bh) 1691 { 1692 if (!buffer_mapped(bh) || buffer_freed(bh)) 1693 return 0; 1694 set_buffer_uptodate(bh); 1695 return ext4_handle_dirty_metadata(handle, NULL, bh); 1696 } 1697 1698 static int ext4_generic_write_end(struct file *file, 1699 struct address_space *mapping, 1700 loff_t pos, unsigned len, unsigned copied, 1701 struct page *page, void *fsdata) 1702 { 1703 int i_size_changed = 0; 1704 struct inode *inode = mapping->host; 1705 handle_t *handle = ext4_journal_current_handle(); 1706 1707 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata); 1708 1709 /* 1710 * No need to use i_size_read() here, the i_size 1711 * cannot change under us because we hold i_mutex. 1712 * 1713 * But it's important to update i_size while still holding page lock: 1714 * page writeout could otherwise come in and zero beyond i_size. 1715 */ 1716 if (pos + copied > inode->i_size) { 1717 i_size_write(inode, pos + copied); 1718 i_size_changed = 1; 1719 } 1720 1721 if (pos + copied > EXT4_I(inode)->i_disksize) { 1722 /* We need to mark inode dirty even if 1723 * new_i_size is less that inode->i_size 1724 * bu greater than i_disksize.(hint delalloc) 1725 */ 1726 ext4_update_i_disksize(inode, (pos + copied)); 1727 i_size_changed = 1; 1728 } 1729 unlock_page(page); 1730 page_cache_release(page); 1731 1732 /* 1733 * Don't mark the inode dirty under page lock. First, it unnecessarily 1734 * makes the holding time of page lock longer. Second, it forces lock 1735 * ordering of page lock and transaction start for journaling 1736 * filesystems. 1737 */ 1738 if (i_size_changed) 1739 ext4_mark_inode_dirty(handle, inode); 1740 1741 return copied; 1742 } 1743 1744 /* 1745 * We need to pick up the new inode size which generic_commit_write gave us 1746 * `file' can be NULL - eg, when called from page_symlink(). 1747 * 1748 * ext4 never places buffers on inode->i_mapping->private_list. metadata 1749 * buffers are managed internally. 1750 */ 1751 static int ext4_ordered_write_end(struct file *file, 1752 struct address_space *mapping, 1753 loff_t pos, unsigned len, unsigned copied, 1754 struct page *page, void *fsdata) 1755 { 1756 handle_t *handle = ext4_journal_current_handle(); 1757 struct inode *inode = mapping->host; 1758 int ret = 0, ret2; 1759 1760 trace_ext4_ordered_write_end(inode, pos, len, copied); 1761 ret = ext4_jbd2_file_inode(handle, inode); 1762 1763 if (ret == 0) { 1764 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied, 1765 page, fsdata); 1766 copied = ret2; 1767 if (pos + len > inode->i_size && ext4_can_truncate(inode)) 1768 /* if we have allocated more blocks and copied 1769 * less. We will have blocks allocated outside 1770 * inode->i_size. So truncate them 1771 */ 1772 ext4_orphan_add(handle, inode); 1773 if (ret2 < 0) 1774 ret = ret2; 1775 } 1776 ret2 = ext4_journal_stop(handle); 1777 if (!ret) 1778 ret = ret2; 1779 1780 if (pos + len > inode->i_size) { 1781 ext4_truncate_failed_write(inode); 1782 /* 1783 * If truncate failed early the inode might still be 1784 * on the orphan list; we need to make sure the inode 1785 * is removed from the orphan list in that case. 1786 */ 1787 if (inode->i_nlink) 1788 ext4_orphan_del(NULL, inode); 1789 } 1790 1791 1792 return ret ? ret : copied; 1793 } 1794 1795 static int ext4_writeback_write_end(struct file *file, 1796 struct address_space *mapping, 1797 loff_t pos, unsigned len, unsigned copied, 1798 struct page *page, void *fsdata) 1799 { 1800 handle_t *handle = ext4_journal_current_handle(); 1801 struct inode *inode = mapping->host; 1802 int ret = 0, ret2; 1803 1804 trace_ext4_writeback_write_end(inode, pos, len, copied); 1805 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied, 1806 page, fsdata); 1807 copied = ret2; 1808 if (pos + len > inode->i_size && ext4_can_truncate(inode)) 1809 /* if we have allocated more blocks and copied 1810 * less. We will have blocks allocated outside 1811 * inode->i_size. So truncate them 1812 */ 1813 ext4_orphan_add(handle, inode); 1814 1815 if (ret2 < 0) 1816 ret = ret2; 1817 1818 ret2 = ext4_journal_stop(handle); 1819 if (!ret) 1820 ret = ret2; 1821 1822 if (pos + len > inode->i_size) { 1823 ext4_truncate_failed_write(inode); 1824 /* 1825 * If truncate failed early the inode might still be 1826 * on the orphan list; we need to make sure the inode 1827 * is removed from the orphan list in that case. 1828 */ 1829 if (inode->i_nlink) 1830 ext4_orphan_del(NULL, inode); 1831 } 1832 1833 return ret ? ret : copied; 1834 } 1835 1836 static int ext4_journalled_write_end(struct file *file, 1837 struct address_space *mapping, 1838 loff_t pos, unsigned len, unsigned copied, 1839 struct page *page, void *fsdata) 1840 { 1841 handle_t *handle = ext4_journal_current_handle(); 1842 struct inode *inode = mapping->host; 1843 int ret = 0, ret2; 1844 int partial = 0; 1845 unsigned from, to; 1846 loff_t new_i_size; 1847 1848 trace_ext4_journalled_write_end(inode, pos, len, copied); 1849 from = pos & (PAGE_CACHE_SIZE - 1); 1850 to = from + len; 1851 1852 if (copied < len) { 1853 if (!PageUptodate(page)) 1854 copied = 0; 1855 page_zero_new_buffers(page, from+copied, to); 1856 } 1857 1858 ret = walk_page_buffers(handle, page_buffers(page), from, 1859 to, &partial, write_end_fn); 1860 if (!partial) 1861 SetPageUptodate(page); 1862 new_i_size = pos + copied; 1863 if (new_i_size > inode->i_size) 1864 i_size_write(inode, pos+copied); 1865 ext4_set_inode_state(inode, EXT4_STATE_JDATA); 1866 if (new_i_size > EXT4_I(inode)->i_disksize) { 1867 ext4_update_i_disksize(inode, new_i_size); 1868 ret2 = ext4_mark_inode_dirty(handle, inode); 1869 if (!ret) 1870 ret = ret2; 1871 } 1872 1873 unlock_page(page); 1874 page_cache_release(page); 1875 if (pos + len > inode->i_size && ext4_can_truncate(inode)) 1876 /* if we have allocated more blocks and copied 1877 * less. We will have blocks allocated outside 1878 * inode->i_size. So truncate them 1879 */ 1880 ext4_orphan_add(handle, inode); 1881 1882 ret2 = ext4_journal_stop(handle); 1883 if (!ret) 1884 ret = ret2; 1885 if (pos + len > inode->i_size) { 1886 ext4_truncate_failed_write(inode); 1887 /* 1888 * If truncate failed early the inode might still be 1889 * on the orphan list; we need to make sure the inode 1890 * is removed from the orphan list in that case. 1891 */ 1892 if (inode->i_nlink) 1893 ext4_orphan_del(NULL, inode); 1894 } 1895 1896 return ret ? ret : copied; 1897 } 1898 1899 /* 1900 * Reserve a single block located at lblock 1901 */ 1902 static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock) 1903 { 1904 int retries = 0; 1905 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1906 struct ext4_inode_info *ei = EXT4_I(inode); 1907 unsigned long md_needed; 1908 int ret; 1909 1910 /* 1911 * recalculate the amount of metadata blocks to reserve 1912 * in order to allocate nrblocks 1913 * worse case is one extent per block 1914 */ 1915 repeat: 1916 spin_lock(&ei->i_block_reservation_lock); 1917 md_needed = ext4_calc_metadata_amount(inode, lblock); 1918 trace_ext4_da_reserve_space(inode, md_needed); 1919 spin_unlock(&ei->i_block_reservation_lock); 1920 1921 /* 1922 * We will charge metadata quota at writeout time; this saves 1923 * us from metadata over-estimation, though we may go over by 1924 * a small amount in the end. Here we just reserve for data. 1925 */ 1926 ret = dquot_reserve_block(inode, 1); 1927 if (ret) 1928 return ret; 1929 /* 1930 * We do still charge estimated metadata to the sb though; 1931 * we cannot afford to run out of free blocks. 1932 */ 1933 if (ext4_claim_free_blocks(sbi, md_needed + 1)) { 1934 dquot_release_reservation_block(inode, 1); 1935 if (ext4_should_retry_alloc(inode->i_sb, &retries)) { 1936 yield(); 1937 goto repeat; 1938 } 1939 return -ENOSPC; 1940 } 1941 spin_lock(&ei->i_block_reservation_lock); 1942 ei->i_reserved_data_blocks++; 1943 ei->i_reserved_meta_blocks += md_needed; 1944 spin_unlock(&ei->i_block_reservation_lock); 1945 1946 return 0; /* success */ 1947 } 1948 1949 static void ext4_da_release_space(struct inode *inode, int to_free) 1950 { 1951 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1952 struct ext4_inode_info *ei = EXT4_I(inode); 1953 1954 if (!to_free) 1955 return; /* Nothing to release, exit */ 1956 1957 spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 1958 1959 trace_ext4_da_release_space(inode, to_free); 1960 if (unlikely(to_free > ei->i_reserved_data_blocks)) { 1961 /* 1962 * if there aren't enough reserved blocks, then the 1963 * counter is messed up somewhere. Since this 1964 * function is called from invalidate page, it's 1965 * harmless to return without any action. 1966 */ 1967 ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: " 1968 "ino %lu, to_free %d with only %d reserved " 1969 "data blocks\n", inode->i_ino, to_free, 1970 ei->i_reserved_data_blocks); 1971 WARN_ON(1); 1972 to_free = ei->i_reserved_data_blocks; 1973 } 1974 ei->i_reserved_data_blocks -= to_free; 1975 1976 if (ei->i_reserved_data_blocks == 0) { 1977 /* 1978 * We can release all of the reserved metadata blocks 1979 * only when we have written all of the delayed 1980 * allocation blocks. 1981 */ 1982 percpu_counter_sub(&sbi->s_dirtyblocks_counter, 1983 ei->i_reserved_meta_blocks); 1984 ei->i_reserved_meta_blocks = 0; 1985 ei->i_da_metadata_calc_len = 0; 1986 } 1987 1988 /* update fs dirty data blocks counter */ 1989 percpu_counter_sub(&sbi->s_dirtyblocks_counter, to_free); 1990 1991 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 1992 1993 dquot_release_reservation_block(inode, to_free); 1994 } 1995 1996 static void ext4_da_page_release_reservation(struct page *page, 1997 unsigned long offset) 1998 { 1999 int to_release = 0; 2000 struct buffer_head *head, *bh; 2001 unsigned int curr_off = 0; 2002 2003 head = page_buffers(page); 2004 bh = head; 2005 do { 2006 unsigned int next_off = curr_off + bh->b_size; 2007 2008 if ((offset <= curr_off) && (buffer_delay(bh))) { 2009 to_release++; 2010 clear_buffer_delay(bh); 2011 } 2012 curr_off = next_off; 2013 } while ((bh = bh->b_this_page) != head); 2014 ext4_da_release_space(page->mapping->host, to_release); 2015 } 2016 2017 /* 2018 * Delayed allocation stuff 2019 */ 2020 2021 /* 2022 * mpage_da_submit_io - walks through extent of pages and try to write 2023 * them with writepage() call back 2024 * 2025 * @mpd->inode: inode 2026 * @mpd->first_page: first page of the extent 2027 * @mpd->next_page: page after the last page of the extent 2028 * 2029 * By the time mpage_da_submit_io() is called we expect all blocks 2030 * to be allocated. this may be wrong if allocation failed. 2031 * 2032 * As pages are already locked by write_cache_pages(), we can't use it 2033 */ 2034 static int mpage_da_submit_io(struct mpage_da_data *mpd, 2035 struct ext4_map_blocks *map) 2036 { 2037 struct pagevec pvec; 2038 unsigned long index, end; 2039 int ret = 0, err, nr_pages, i; 2040 struct inode *inode = mpd->inode; 2041 struct address_space *mapping = inode->i_mapping; 2042 loff_t size = i_size_read(inode); 2043 unsigned int len, block_start; 2044 struct buffer_head *bh, *page_bufs = NULL; 2045 int journal_data = ext4_should_journal_data(inode); 2046 sector_t pblock = 0, cur_logical = 0; 2047 struct ext4_io_submit io_submit; 2048 2049 BUG_ON(mpd->next_page <= mpd->first_page); 2050 memset(&io_submit, 0, sizeof(io_submit)); 2051 /* 2052 * We need to start from the first_page to the next_page - 1 2053 * to make sure we also write the mapped dirty buffer_heads. 2054 * If we look at mpd->b_blocknr we would only be looking 2055 * at the currently mapped buffer_heads. 2056 */ 2057 index = mpd->first_page; 2058 end = mpd->next_page - 1; 2059 2060 pagevec_init(&pvec, 0); 2061 while (index <= end) { 2062 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE); 2063 if (nr_pages == 0) 2064 break; 2065 for (i = 0; i < nr_pages; i++) { 2066 int commit_write = 0, skip_page = 0; 2067 struct page *page = pvec.pages[i]; 2068 2069 index = page->index; 2070 if (index > end) 2071 break; 2072 2073 if (index == size >> PAGE_CACHE_SHIFT) 2074 len = size & ~PAGE_CACHE_MASK; 2075 else 2076 len = PAGE_CACHE_SIZE; 2077 if (map) { 2078 cur_logical = index << (PAGE_CACHE_SHIFT - 2079 inode->i_blkbits); 2080 pblock = map->m_pblk + (cur_logical - 2081 map->m_lblk); 2082 } 2083 index++; 2084 2085 BUG_ON(!PageLocked(page)); 2086 BUG_ON(PageWriteback(page)); 2087 2088 /* 2089 * If the page does not have buffers (for 2090 * whatever reason), try to create them using 2091 * __block_write_begin. If this fails, 2092 * skip the page and move on. 2093 */ 2094 if (!page_has_buffers(page)) { 2095 if (__block_write_begin(page, 0, len, 2096 noalloc_get_block_write)) { 2097 skip_page: 2098 unlock_page(page); 2099 continue; 2100 } 2101 commit_write = 1; 2102 } 2103 2104 bh = page_bufs = page_buffers(page); 2105 block_start = 0; 2106 do { 2107 if (!bh) 2108 goto skip_page; 2109 if (map && (cur_logical >= map->m_lblk) && 2110 (cur_logical <= (map->m_lblk + 2111 (map->m_len - 1)))) { 2112 if (buffer_delay(bh)) { 2113 clear_buffer_delay(bh); 2114 bh->b_blocknr = pblock; 2115 } 2116 if (buffer_unwritten(bh) || 2117 buffer_mapped(bh)) 2118 BUG_ON(bh->b_blocknr != pblock); 2119 if (map->m_flags & EXT4_MAP_UNINIT) 2120 set_buffer_uninit(bh); 2121 clear_buffer_unwritten(bh); 2122 } 2123 2124 /* skip page if block allocation undone */ 2125 if (buffer_delay(bh) || buffer_unwritten(bh)) 2126 skip_page = 1; 2127 bh = bh->b_this_page; 2128 block_start += bh->b_size; 2129 cur_logical++; 2130 pblock++; 2131 } while (bh != page_bufs); 2132 2133 if (skip_page) 2134 goto skip_page; 2135 2136 if (commit_write) 2137 /* mark the buffer_heads as dirty & uptodate */ 2138 block_commit_write(page, 0, len); 2139 2140 clear_page_dirty_for_io(page); 2141 /* 2142 * Delalloc doesn't support data journalling, 2143 * but eventually maybe we'll lift this 2144 * restriction. 2145 */ 2146 if (unlikely(journal_data && PageChecked(page))) 2147 err = __ext4_journalled_writepage(page, len); 2148 else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT)) 2149 err = ext4_bio_write_page(&io_submit, page, 2150 len, mpd->wbc); 2151 else 2152 err = block_write_full_page(page, 2153 noalloc_get_block_write, mpd->wbc); 2154 2155 if (!err) 2156 mpd->pages_written++; 2157 /* 2158 * In error case, we have to continue because 2159 * remaining pages are still locked 2160 */ 2161 if (ret == 0) 2162 ret = err; 2163 } 2164 pagevec_release(&pvec); 2165 } 2166 ext4_io_submit(&io_submit); 2167 return ret; 2168 } 2169 2170 static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd) 2171 { 2172 int nr_pages, i; 2173 pgoff_t index, end; 2174 struct pagevec pvec; 2175 struct inode *inode = mpd->inode; 2176 struct address_space *mapping = inode->i_mapping; 2177 2178 index = mpd->first_page; 2179 end = mpd->next_page - 1; 2180 while (index <= end) { 2181 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE); 2182 if (nr_pages == 0) 2183 break; 2184 for (i = 0; i < nr_pages; i++) { 2185 struct page *page = pvec.pages[i]; 2186 if (page->index > end) 2187 break; 2188 BUG_ON(!PageLocked(page)); 2189 BUG_ON(PageWriteback(page)); 2190 block_invalidatepage(page, 0); 2191 ClearPageUptodate(page); 2192 unlock_page(page); 2193 } 2194 index = pvec.pages[nr_pages - 1]->index + 1; 2195 pagevec_release(&pvec); 2196 } 2197 return; 2198 } 2199 2200 static void ext4_print_free_blocks(struct inode *inode) 2201 { 2202 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 2203 printk(KERN_CRIT "Total free blocks count %lld\n", 2204 ext4_count_free_blocks(inode->i_sb)); 2205 printk(KERN_CRIT "Free/Dirty block details\n"); 2206 printk(KERN_CRIT "free_blocks=%lld\n", 2207 (long long) percpu_counter_sum(&sbi->s_freeblocks_counter)); 2208 printk(KERN_CRIT "dirty_blocks=%lld\n", 2209 (long long) percpu_counter_sum(&sbi->s_dirtyblocks_counter)); 2210 printk(KERN_CRIT "Block reservation details\n"); 2211 printk(KERN_CRIT "i_reserved_data_blocks=%u\n", 2212 EXT4_I(inode)->i_reserved_data_blocks); 2213 printk(KERN_CRIT "i_reserved_meta_blocks=%u\n", 2214 EXT4_I(inode)->i_reserved_meta_blocks); 2215 return; 2216 } 2217 2218 /* 2219 * mpage_da_map_and_submit - go through given space, map them 2220 * if necessary, and then submit them for I/O 2221 * 2222 * @mpd - bh describing space 2223 * 2224 * The function skips space we know is already mapped to disk blocks. 2225 * 2226 */ 2227 static void mpage_da_map_and_submit(struct mpage_da_data *mpd) 2228 { 2229 int err, blks, get_blocks_flags; 2230 struct ext4_map_blocks map, *mapp = NULL; 2231 sector_t next = mpd->b_blocknr; 2232 unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits; 2233 loff_t disksize = EXT4_I(mpd->inode)->i_disksize; 2234 handle_t *handle = NULL; 2235 2236 /* 2237 * If the blocks are mapped already, or we couldn't accumulate 2238 * any blocks, then proceed immediately to the submission stage. 2239 */ 2240 if ((mpd->b_size == 0) || 2241 ((mpd->b_state & (1 << BH_Mapped)) && 2242 !(mpd->b_state & (1 << BH_Delay)) && 2243 !(mpd->b_state & (1 << BH_Unwritten)))) 2244 goto submit_io; 2245 2246 handle = ext4_journal_current_handle(); 2247 BUG_ON(!handle); 2248 2249 /* 2250 * Call ext4_map_blocks() to allocate any delayed allocation 2251 * blocks, or to convert an uninitialized extent to be 2252 * initialized (in the case where we have written into 2253 * one or more preallocated blocks). 2254 * 2255 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to 2256 * indicate that we are on the delayed allocation path. This 2257 * affects functions in many different parts of the allocation 2258 * call path. This flag exists primarily because we don't 2259 * want to change *many* call functions, so ext4_map_blocks() 2260 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the 2261 * inode's allocation semaphore is taken. 2262 * 2263 * If the blocks in questions were delalloc blocks, set 2264 * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting 2265 * variables are updated after the blocks have been allocated. 2266 */ 2267 map.m_lblk = next; 2268 map.m_len = max_blocks; 2269 get_blocks_flags = EXT4_GET_BLOCKS_CREATE; 2270 if (ext4_should_dioread_nolock(mpd->inode)) 2271 get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT; 2272 if (mpd->b_state & (1 << BH_Delay)) 2273 get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE; 2274 2275 blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags); 2276 if (blks < 0) { 2277 struct super_block *sb = mpd->inode->i_sb; 2278 2279 err = blks; 2280 /* 2281 * If get block returns EAGAIN or ENOSPC and there 2282 * appears to be free blocks we will just let 2283 * mpage_da_submit_io() unlock all of the pages. 2284 */ 2285 if (err == -EAGAIN) 2286 goto submit_io; 2287 2288 if (err == -ENOSPC && 2289 ext4_count_free_blocks(sb)) { 2290 mpd->retval = err; 2291 goto submit_io; 2292 } 2293 2294 /* 2295 * get block failure will cause us to loop in 2296 * writepages, because a_ops->writepage won't be able 2297 * to make progress. The page will be redirtied by 2298 * writepage and writepages will again try to write 2299 * the same. 2300 */ 2301 if (!(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)) { 2302 ext4_msg(sb, KERN_CRIT, 2303 "delayed block allocation failed for inode %lu " 2304 "at logical offset %llu with max blocks %zd " 2305 "with error %d", mpd->inode->i_ino, 2306 (unsigned long long) next, 2307 mpd->b_size >> mpd->inode->i_blkbits, err); 2308 ext4_msg(sb, KERN_CRIT, 2309 "This should not happen!! Data will be lost\n"); 2310 if (err == -ENOSPC) 2311 ext4_print_free_blocks(mpd->inode); 2312 } 2313 /* invalidate all the pages */ 2314 ext4_da_block_invalidatepages(mpd); 2315 2316 /* Mark this page range as having been completed */ 2317 mpd->io_done = 1; 2318 return; 2319 } 2320 BUG_ON(blks == 0); 2321 2322 mapp = ↦ 2323 if (map.m_flags & EXT4_MAP_NEW) { 2324 struct block_device *bdev = mpd->inode->i_sb->s_bdev; 2325 int i; 2326 2327 for (i = 0; i < map.m_len; i++) 2328 unmap_underlying_metadata(bdev, map.m_pblk + i); 2329 } 2330 2331 if (ext4_should_order_data(mpd->inode)) { 2332 err = ext4_jbd2_file_inode(handle, mpd->inode); 2333 if (err) 2334 /* This only happens if the journal is aborted */ 2335 return; 2336 } 2337 2338 /* 2339 * Update on-disk size along with block allocation. 2340 */ 2341 disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits; 2342 if (disksize > i_size_read(mpd->inode)) 2343 disksize = i_size_read(mpd->inode); 2344 if (disksize > EXT4_I(mpd->inode)->i_disksize) { 2345 ext4_update_i_disksize(mpd->inode, disksize); 2346 err = ext4_mark_inode_dirty(handle, mpd->inode); 2347 if (err) 2348 ext4_error(mpd->inode->i_sb, 2349 "Failed to mark inode %lu dirty", 2350 mpd->inode->i_ino); 2351 } 2352 2353 submit_io: 2354 mpage_da_submit_io(mpd, mapp); 2355 mpd->io_done = 1; 2356 } 2357 2358 #define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \ 2359 (1 << BH_Delay) | (1 << BH_Unwritten)) 2360 2361 /* 2362 * mpage_add_bh_to_extent - try to add one more block to extent of blocks 2363 * 2364 * @mpd->lbh - extent of blocks 2365 * @logical - logical number of the block in the file 2366 * @bh - bh of the block (used to access block's state) 2367 * 2368 * the function is used to collect contig. blocks in same state 2369 */ 2370 static void mpage_add_bh_to_extent(struct mpage_da_data *mpd, 2371 sector_t logical, size_t b_size, 2372 unsigned long b_state) 2373 { 2374 sector_t next; 2375 int nrblocks = mpd->b_size >> mpd->inode->i_blkbits; 2376 2377 /* 2378 * XXX Don't go larger than mballoc is willing to allocate 2379 * This is a stopgap solution. We eventually need to fold 2380 * mpage_da_submit_io() into this function and then call 2381 * ext4_map_blocks() multiple times in a loop 2382 */ 2383 if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize) 2384 goto flush_it; 2385 2386 /* check if thereserved journal credits might overflow */ 2387 if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) { 2388 if (nrblocks >= EXT4_MAX_TRANS_DATA) { 2389 /* 2390 * With non-extent format we are limited by the journal 2391 * credit available. Total credit needed to insert 2392 * nrblocks contiguous blocks is dependent on the 2393 * nrblocks. So limit nrblocks. 2394 */ 2395 goto flush_it; 2396 } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) > 2397 EXT4_MAX_TRANS_DATA) { 2398 /* 2399 * Adding the new buffer_head would make it cross the 2400 * allowed limit for which we have journal credit 2401 * reserved. So limit the new bh->b_size 2402 */ 2403 b_size = (EXT4_MAX_TRANS_DATA - nrblocks) << 2404 mpd->inode->i_blkbits; 2405 /* we will do mpage_da_submit_io in the next loop */ 2406 } 2407 } 2408 /* 2409 * First block in the extent 2410 */ 2411 if (mpd->b_size == 0) { 2412 mpd->b_blocknr = logical; 2413 mpd->b_size = b_size; 2414 mpd->b_state = b_state & BH_FLAGS; 2415 return; 2416 } 2417 2418 next = mpd->b_blocknr + nrblocks; 2419 /* 2420 * Can we merge the block to our big extent? 2421 */ 2422 if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) { 2423 mpd->b_size += b_size; 2424 return; 2425 } 2426 2427 flush_it: 2428 /* 2429 * We couldn't merge the block to our extent, so we 2430 * need to flush current extent and start new one 2431 */ 2432 mpage_da_map_and_submit(mpd); 2433 return; 2434 } 2435 2436 static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh) 2437 { 2438 return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh); 2439 } 2440 2441 /* 2442 * This is a special get_blocks_t callback which is used by 2443 * ext4_da_write_begin(). It will either return mapped block or 2444 * reserve space for a single block. 2445 * 2446 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set. 2447 * We also have b_blocknr = -1 and b_bdev initialized properly 2448 * 2449 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set. 2450 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev 2451 * initialized properly. 2452 */ 2453 static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock, 2454 struct buffer_head *bh, int create) 2455 { 2456 struct ext4_map_blocks map; 2457 int ret = 0; 2458 sector_t invalid_block = ~((sector_t) 0xffff); 2459 2460 if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es)) 2461 invalid_block = ~0; 2462 2463 BUG_ON(create == 0); 2464 BUG_ON(bh->b_size != inode->i_sb->s_blocksize); 2465 2466 map.m_lblk = iblock; 2467 map.m_len = 1; 2468 2469 /* 2470 * first, we need to know whether the block is allocated already 2471 * preallocated blocks are unmapped but should treated 2472 * the same as allocated blocks. 2473 */ 2474 ret = ext4_map_blocks(NULL, inode, &map, 0); 2475 if (ret < 0) 2476 return ret; 2477 if (ret == 0) { 2478 if (buffer_delay(bh)) 2479 return 0; /* Not sure this could or should happen */ 2480 /* 2481 * XXX: __block_write_begin() unmaps passed block, is it OK? 2482 */ 2483 ret = ext4_da_reserve_space(inode, iblock); 2484 if (ret) 2485 /* not enough space to reserve */ 2486 return ret; 2487 2488 map_bh(bh, inode->i_sb, invalid_block); 2489 set_buffer_new(bh); 2490 set_buffer_delay(bh); 2491 return 0; 2492 } 2493 2494 map_bh(bh, inode->i_sb, map.m_pblk); 2495 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags; 2496 2497 if (buffer_unwritten(bh)) { 2498 /* A delayed write to unwritten bh should be marked 2499 * new and mapped. Mapped ensures that we don't do 2500 * get_block multiple times when we write to the same 2501 * offset and new ensures that we do proper zero out 2502 * for partial write. 2503 */ 2504 set_buffer_new(bh); 2505 } 2506 return 0; 2507 } 2508 2509 /* 2510 * This function is used as a standard get_block_t calback function 2511 * when there is no desire to allocate any blocks. It is used as a 2512 * callback function for block_write_begin() and block_write_full_page(). 2513 * These functions should only try to map a single block at a time. 2514 * 2515 * Since this function doesn't do block allocations even if the caller 2516 * requests it by passing in create=1, it is critically important that 2517 * any caller checks to make sure that any buffer heads are returned 2518 * by this function are either all already mapped or marked for 2519 * delayed allocation before calling block_write_full_page(). Otherwise, 2520 * b_blocknr could be left unitialized, and the page write functions will 2521 * be taken by surprise. 2522 */ 2523 static int noalloc_get_block_write(struct inode *inode, sector_t iblock, 2524 struct buffer_head *bh_result, int create) 2525 { 2526 BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize); 2527 return _ext4_get_block(inode, iblock, bh_result, 0); 2528 } 2529 2530 static int bget_one(handle_t *handle, struct buffer_head *bh) 2531 { 2532 get_bh(bh); 2533 return 0; 2534 } 2535 2536 static int bput_one(handle_t *handle, struct buffer_head *bh) 2537 { 2538 put_bh(bh); 2539 return 0; 2540 } 2541 2542 static int __ext4_journalled_writepage(struct page *page, 2543 unsigned int len) 2544 { 2545 struct address_space *mapping = page->mapping; 2546 struct inode *inode = mapping->host; 2547 struct buffer_head *page_bufs; 2548 handle_t *handle = NULL; 2549 int ret = 0; 2550 int err; 2551 2552 ClearPageChecked(page); 2553 page_bufs = page_buffers(page); 2554 BUG_ON(!page_bufs); 2555 walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one); 2556 /* As soon as we unlock the page, it can go away, but we have 2557 * references to buffers so we are safe */ 2558 unlock_page(page); 2559 2560 handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode)); 2561 if (IS_ERR(handle)) { 2562 ret = PTR_ERR(handle); 2563 goto out; 2564 } 2565 2566 ret = walk_page_buffers(handle, page_bufs, 0, len, NULL, 2567 do_journal_get_write_access); 2568 2569 err = walk_page_buffers(handle, page_bufs, 0, len, NULL, 2570 write_end_fn); 2571 if (ret == 0) 2572 ret = err; 2573 err = ext4_journal_stop(handle); 2574 if (!ret) 2575 ret = err; 2576 2577 walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one); 2578 ext4_set_inode_state(inode, EXT4_STATE_JDATA); 2579 out: 2580 return ret; 2581 } 2582 2583 static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode); 2584 static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate); 2585 2586 /* 2587 * Note that we don't need to start a transaction unless we're journaling data 2588 * because we should have holes filled from ext4_page_mkwrite(). We even don't 2589 * need to file the inode to the transaction's list in ordered mode because if 2590 * we are writing back data added by write(), the inode is already there and if 2591 * we are writing back data modified via mmap(), noone guarantees in which 2592 * transaction the data will hit the disk. In case we are journaling data, we 2593 * cannot start transaction directly because transaction start ranks above page 2594 * lock so we have to do some magic. 2595 * 2596 * This function can get called via... 2597 * - ext4_da_writepages after taking page lock (have journal handle) 2598 * - journal_submit_inode_data_buffers (no journal handle) 2599 * - shrink_page_list via pdflush (no journal handle) 2600 * - grab_page_cache when doing write_begin (have journal handle) 2601 * 2602 * We don't do any block allocation in this function. If we have page with 2603 * multiple blocks we need to write those buffer_heads that are mapped. This 2604 * is important for mmaped based write. So if we do with blocksize 1K 2605 * truncate(f, 1024); 2606 * a = mmap(f, 0, 4096); 2607 * a[0] = 'a'; 2608 * truncate(f, 4096); 2609 * we have in the page first buffer_head mapped via page_mkwrite call back 2610 * but other bufer_heads would be unmapped but dirty(dirty done via the 2611 * do_wp_page). So writepage should write the first block. If we modify 2612 * the mmap area beyond 1024 we will again get a page_fault and the 2613 * page_mkwrite callback will do the block allocation and mark the 2614 * buffer_heads mapped. 2615 * 2616 * We redirty the page if we have any buffer_heads that is either delay or 2617 * unwritten in the page. 2618 * 2619 * We can get recursively called as show below. 2620 * 2621 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() -> 2622 * ext4_writepage() 2623 * 2624 * But since we don't do any block allocation we should not deadlock. 2625 * Page also have the dirty flag cleared so we don't get recurive page_lock. 2626 */ 2627 static int ext4_writepage(struct page *page, 2628 struct writeback_control *wbc) 2629 { 2630 int ret = 0, commit_write = 0; 2631 loff_t size; 2632 unsigned int len; 2633 struct buffer_head *page_bufs = NULL; 2634 struct inode *inode = page->mapping->host; 2635 2636 trace_ext4_writepage(inode, page); 2637 size = i_size_read(inode); 2638 if (page->index == size >> PAGE_CACHE_SHIFT) 2639 len = size & ~PAGE_CACHE_MASK; 2640 else 2641 len = PAGE_CACHE_SIZE; 2642 2643 /* 2644 * If the page does not have buffers (for whatever reason), 2645 * try to create them using __block_write_begin. If this 2646 * fails, redirty the page and move on. 2647 */ 2648 if (!page_has_buffers(page)) { 2649 if (__block_write_begin(page, 0, len, 2650 noalloc_get_block_write)) { 2651 redirty_page: 2652 redirty_page_for_writepage(wbc, page); 2653 unlock_page(page); 2654 return 0; 2655 } 2656 commit_write = 1; 2657 } 2658 page_bufs = page_buffers(page); 2659 if (walk_page_buffers(NULL, page_bufs, 0, len, NULL, 2660 ext4_bh_delay_or_unwritten)) { 2661 /* 2662 * We don't want to do block allocation, so redirty 2663 * the page and return. We may reach here when we do 2664 * a journal commit via journal_submit_inode_data_buffers. 2665 * We can also reach here via shrink_page_list 2666 */ 2667 goto redirty_page; 2668 } 2669 if (commit_write) 2670 /* now mark the buffer_heads as dirty and uptodate */ 2671 block_commit_write(page, 0, len); 2672 2673 if (PageChecked(page) && ext4_should_journal_data(inode)) 2674 /* 2675 * It's mmapped pagecache. Add buffers and journal it. There 2676 * doesn't seem much point in redirtying the page here. 2677 */ 2678 return __ext4_journalled_writepage(page, len); 2679 2680 if (buffer_uninit(page_bufs)) { 2681 ext4_set_bh_endio(page_bufs, inode); 2682 ret = block_write_full_page_endio(page, noalloc_get_block_write, 2683 wbc, ext4_end_io_buffer_write); 2684 } else 2685 ret = block_write_full_page(page, noalloc_get_block_write, 2686 wbc); 2687 2688 return ret; 2689 } 2690 2691 /* 2692 * This is called via ext4_da_writepages() to 2693 * calulate the total number of credits to reserve to fit 2694 * a single extent allocation into a single transaction, 2695 * ext4_da_writpeages() will loop calling this before 2696 * the block allocation. 2697 */ 2698 2699 static int ext4_da_writepages_trans_blocks(struct inode *inode) 2700 { 2701 int max_blocks = EXT4_I(inode)->i_reserved_data_blocks; 2702 2703 /* 2704 * With non-extent format the journal credit needed to 2705 * insert nrblocks contiguous block is dependent on 2706 * number of contiguous block. So we will limit 2707 * number of contiguous block to a sane value 2708 */ 2709 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) && 2710 (max_blocks > EXT4_MAX_TRANS_DATA)) 2711 max_blocks = EXT4_MAX_TRANS_DATA; 2712 2713 return ext4_chunk_trans_blocks(inode, max_blocks); 2714 } 2715 2716 /* 2717 * write_cache_pages_da - walk the list of dirty pages of the given 2718 * address space and accumulate pages that need writing, and call 2719 * mpage_da_map_and_submit to map a single contiguous memory region 2720 * and then write them. 2721 */ 2722 static int write_cache_pages_da(struct address_space *mapping, 2723 struct writeback_control *wbc, 2724 struct mpage_da_data *mpd, 2725 pgoff_t *done_index) 2726 { 2727 struct buffer_head *bh, *head; 2728 struct inode *inode = mapping->host; 2729 struct pagevec pvec; 2730 unsigned int nr_pages; 2731 sector_t logical; 2732 pgoff_t index, end; 2733 long nr_to_write = wbc->nr_to_write; 2734 int i, tag, ret = 0; 2735 2736 memset(mpd, 0, sizeof(struct mpage_da_data)); 2737 mpd->wbc = wbc; 2738 mpd->inode = inode; 2739 pagevec_init(&pvec, 0); 2740 index = wbc->range_start >> PAGE_CACHE_SHIFT; 2741 end = wbc->range_end >> PAGE_CACHE_SHIFT; 2742 2743 if (wbc->sync_mode == WB_SYNC_ALL) 2744 tag = PAGECACHE_TAG_TOWRITE; 2745 else 2746 tag = PAGECACHE_TAG_DIRTY; 2747 2748 *done_index = index; 2749 while (index <= end) { 2750 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag, 2751 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1); 2752 if (nr_pages == 0) 2753 return 0; 2754 2755 for (i = 0; i < nr_pages; i++) { 2756 struct page *page = pvec.pages[i]; 2757 2758 /* 2759 * At this point, the page may be truncated or 2760 * invalidated (changing page->mapping to NULL), or 2761 * even swizzled back from swapper_space to tmpfs file 2762 * mapping. However, page->index will not change 2763 * because we have a reference on the page. 2764 */ 2765 if (page->index > end) 2766 goto out; 2767 2768 *done_index = page->index + 1; 2769 2770 /* 2771 * If we can't merge this page, and we have 2772 * accumulated an contiguous region, write it 2773 */ 2774 if ((mpd->next_page != page->index) && 2775 (mpd->next_page != mpd->first_page)) { 2776 mpage_da_map_and_submit(mpd); 2777 goto ret_extent_tail; 2778 } 2779 2780 lock_page(page); 2781 2782 /* 2783 * If the page is no longer dirty, or its 2784 * mapping no longer corresponds to inode we 2785 * are writing (which means it has been 2786 * truncated or invalidated), or the page is 2787 * already under writeback and we are not 2788 * doing a data integrity writeback, skip the page 2789 */ 2790 if (!PageDirty(page) || 2791 (PageWriteback(page) && 2792 (wbc->sync_mode == WB_SYNC_NONE)) || 2793 unlikely(page->mapping != mapping)) { 2794 unlock_page(page); 2795 continue; 2796 } 2797 2798 if (PageWriteback(page)) 2799 wait_on_page_writeback(page); 2800 2801 BUG_ON(PageWriteback(page)); 2802 2803 if (mpd->next_page != page->index) 2804 mpd->first_page = page->index; 2805 mpd->next_page = page->index + 1; 2806 logical = (sector_t) page->index << 2807 (PAGE_CACHE_SHIFT - inode->i_blkbits); 2808 2809 if (!page_has_buffers(page)) { 2810 mpage_add_bh_to_extent(mpd, logical, 2811 PAGE_CACHE_SIZE, 2812 (1 << BH_Dirty) | (1 << BH_Uptodate)); 2813 if (mpd->io_done) 2814 goto ret_extent_tail; 2815 } else { 2816 /* 2817 * Page with regular buffer heads, 2818 * just add all dirty ones 2819 */ 2820 head = page_buffers(page); 2821 bh = head; 2822 do { 2823 BUG_ON(buffer_locked(bh)); 2824 /* 2825 * We need to try to allocate 2826 * unmapped blocks in the same page. 2827 * Otherwise we won't make progress 2828 * with the page in ext4_writepage 2829 */ 2830 if (ext4_bh_delay_or_unwritten(NULL, bh)) { 2831 mpage_add_bh_to_extent(mpd, logical, 2832 bh->b_size, 2833 bh->b_state); 2834 if (mpd->io_done) 2835 goto ret_extent_tail; 2836 } else if (buffer_dirty(bh) && (buffer_mapped(bh))) { 2837 /* 2838 * mapped dirty buffer. We need 2839 * to update the b_state 2840 * because we look at b_state 2841 * in mpage_da_map_blocks. We 2842 * don't update b_size because 2843 * if we find an unmapped 2844 * buffer_head later we need to 2845 * use the b_state flag of that 2846 * buffer_head. 2847 */ 2848 if (mpd->b_size == 0) 2849 mpd->b_state = bh->b_state & BH_FLAGS; 2850 } 2851 logical++; 2852 } while ((bh = bh->b_this_page) != head); 2853 } 2854 2855 if (nr_to_write > 0) { 2856 nr_to_write--; 2857 if (nr_to_write == 0 && 2858 wbc->sync_mode == WB_SYNC_NONE) 2859 /* 2860 * We stop writing back only if we are 2861 * not doing integrity sync. In case of 2862 * integrity sync we have to keep going 2863 * because someone may be concurrently 2864 * dirtying pages, and we might have 2865 * synced a lot of newly appeared dirty 2866 * pages, but have not synced all of the 2867 * old dirty pages. 2868 */ 2869 goto out; 2870 } 2871 } 2872 pagevec_release(&pvec); 2873 cond_resched(); 2874 } 2875 return 0; 2876 ret_extent_tail: 2877 ret = MPAGE_DA_EXTENT_TAIL; 2878 out: 2879 pagevec_release(&pvec); 2880 cond_resched(); 2881 return ret; 2882 } 2883 2884 2885 static int ext4_da_writepages(struct address_space *mapping, 2886 struct writeback_control *wbc) 2887 { 2888 pgoff_t index; 2889 int range_whole = 0; 2890 handle_t *handle = NULL; 2891 struct mpage_da_data mpd; 2892 struct inode *inode = mapping->host; 2893 int pages_written = 0; 2894 unsigned int max_pages; 2895 int range_cyclic, cycled = 1, io_done = 0; 2896 int needed_blocks, ret = 0; 2897 long desired_nr_to_write, nr_to_writebump = 0; 2898 loff_t range_start = wbc->range_start; 2899 struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb); 2900 pgoff_t done_index = 0; 2901 pgoff_t end; 2902 2903 trace_ext4_da_writepages(inode, wbc); 2904 2905 /* 2906 * No pages to write? This is mainly a kludge to avoid starting 2907 * a transaction for special inodes like journal inode on last iput() 2908 * because that could violate lock ordering on umount 2909 */ 2910 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) 2911 return 0; 2912 2913 /* 2914 * If the filesystem has aborted, it is read-only, so return 2915 * right away instead of dumping stack traces later on that 2916 * will obscure the real source of the problem. We test 2917 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because 2918 * the latter could be true if the filesystem is mounted 2919 * read-only, and in that case, ext4_da_writepages should 2920 * *never* be called, so if that ever happens, we would want 2921 * the stack trace. 2922 */ 2923 if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) 2924 return -EROFS; 2925 2926 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) 2927 range_whole = 1; 2928 2929 range_cyclic = wbc->range_cyclic; 2930 if (wbc->range_cyclic) { 2931 index = mapping->writeback_index; 2932 if (index) 2933 cycled = 0; 2934 wbc->range_start = index << PAGE_CACHE_SHIFT; 2935 wbc->range_end = LLONG_MAX; 2936 wbc->range_cyclic = 0; 2937 end = -1; 2938 } else { 2939 index = wbc->range_start >> PAGE_CACHE_SHIFT; 2940 end = wbc->range_end >> PAGE_CACHE_SHIFT; 2941 } 2942 2943 /* 2944 * This works around two forms of stupidity. The first is in 2945 * the writeback code, which caps the maximum number of pages 2946 * written to be 1024 pages. This is wrong on multiple 2947 * levels; different architectues have a different page size, 2948 * which changes the maximum amount of data which gets 2949 * written. Secondly, 4 megabytes is way too small. XFS 2950 * forces this value to be 16 megabytes by multiplying 2951 * nr_to_write parameter by four, and then relies on its 2952 * allocator to allocate larger extents to make them 2953 * contiguous. Unfortunately this brings us to the second 2954 * stupidity, which is that ext4's mballoc code only allocates 2955 * at most 2048 blocks. So we force contiguous writes up to 2956 * the number of dirty blocks in the inode, or 2957 * sbi->max_writeback_mb_bump whichever is smaller. 2958 */ 2959 max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT); 2960 if (!range_cyclic && range_whole) { 2961 if (wbc->nr_to_write == LONG_MAX) 2962 desired_nr_to_write = wbc->nr_to_write; 2963 else 2964 desired_nr_to_write = wbc->nr_to_write * 8; 2965 } else 2966 desired_nr_to_write = ext4_num_dirty_pages(inode, index, 2967 max_pages); 2968 if (desired_nr_to_write > max_pages) 2969 desired_nr_to_write = max_pages; 2970 2971 if (wbc->nr_to_write < desired_nr_to_write) { 2972 nr_to_writebump = desired_nr_to_write - wbc->nr_to_write; 2973 wbc->nr_to_write = desired_nr_to_write; 2974 } 2975 2976 retry: 2977 if (wbc->sync_mode == WB_SYNC_ALL) 2978 tag_pages_for_writeback(mapping, index, end); 2979 2980 while (!ret && wbc->nr_to_write > 0) { 2981 2982 /* 2983 * we insert one extent at a time. So we need 2984 * credit needed for single extent allocation. 2985 * journalled mode is currently not supported 2986 * by delalloc 2987 */ 2988 BUG_ON(ext4_should_journal_data(inode)); 2989 needed_blocks = ext4_da_writepages_trans_blocks(inode); 2990 2991 /* start a new transaction*/ 2992 handle = ext4_journal_start(inode, needed_blocks); 2993 if (IS_ERR(handle)) { 2994 ret = PTR_ERR(handle); 2995 ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: " 2996 "%ld pages, ino %lu; err %d", __func__, 2997 wbc->nr_to_write, inode->i_ino, ret); 2998 goto out_writepages; 2999 } 3000 3001 /* 3002 * Now call write_cache_pages_da() to find the next 3003 * contiguous region of logical blocks that need 3004 * blocks to be allocated by ext4 and submit them. 3005 */ 3006 ret = write_cache_pages_da(mapping, wbc, &mpd, &done_index); 3007 /* 3008 * If we have a contiguous extent of pages and we 3009 * haven't done the I/O yet, map the blocks and submit 3010 * them for I/O. 3011 */ 3012 if (!mpd.io_done && mpd.next_page != mpd.first_page) { 3013 mpage_da_map_and_submit(&mpd); 3014 ret = MPAGE_DA_EXTENT_TAIL; 3015 } 3016 trace_ext4_da_write_pages(inode, &mpd); 3017 wbc->nr_to_write -= mpd.pages_written; 3018 3019 ext4_journal_stop(handle); 3020 3021 if ((mpd.retval == -ENOSPC) && sbi->s_journal) { 3022 /* commit the transaction which would 3023 * free blocks released in the transaction 3024 * and try again 3025 */ 3026 jbd2_journal_force_commit_nested(sbi->s_journal); 3027 ret = 0; 3028 } else if (ret == MPAGE_DA_EXTENT_TAIL) { 3029 /* 3030 * got one extent now try with 3031 * rest of the pages 3032 */ 3033 pages_written += mpd.pages_written; 3034 ret = 0; 3035 io_done = 1; 3036 } else if (wbc->nr_to_write) 3037 /* 3038 * There is no more writeout needed 3039 * or we requested for a noblocking writeout 3040 * and we found the device congested 3041 */ 3042 break; 3043 } 3044 if (!io_done && !cycled) { 3045 cycled = 1; 3046 index = 0; 3047 wbc->range_start = index << PAGE_CACHE_SHIFT; 3048 wbc->range_end = mapping->writeback_index - 1; 3049 goto retry; 3050 } 3051 3052 /* Update index */ 3053 wbc->range_cyclic = range_cyclic; 3054 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) 3055 /* 3056 * set the writeback_index so that range_cyclic 3057 * mode will write it back later 3058 */ 3059 mapping->writeback_index = done_index; 3060 3061 out_writepages: 3062 wbc->nr_to_write -= nr_to_writebump; 3063 wbc->range_start = range_start; 3064 trace_ext4_da_writepages_result(inode, wbc, ret, pages_written); 3065 return ret; 3066 } 3067 3068 #define FALL_BACK_TO_NONDELALLOC 1 3069 static int ext4_nonda_switch(struct super_block *sb) 3070 { 3071 s64 free_blocks, dirty_blocks; 3072 struct ext4_sb_info *sbi = EXT4_SB(sb); 3073 3074 /* 3075 * switch to non delalloc mode if we are running low 3076 * on free block. The free block accounting via percpu 3077 * counters can get slightly wrong with percpu_counter_batch getting 3078 * accumulated on each CPU without updating global counters 3079 * Delalloc need an accurate free block accounting. So switch 3080 * to non delalloc when we are near to error range. 3081 */ 3082 free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter); 3083 dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyblocks_counter); 3084 if (2 * free_blocks < 3 * dirty_blocks || 3085 free_blocks < (dirty_blocks + EXT4_FREEBLOCKS_WATERMARK)) { 3086 /* 3087 * free block count is less than 150% of dirty blocks 3088 * or free blocks is less than watermark 3089 */ 3090 return 1; 3091 } 3092 /* 3093 * Even if we don't switch but are nearing capacity, 3094 * start pushing delalloc when 1/2 of free blocks are dirty. 3095 */ 3096 if (free_blocks < 2 * dirty_blocks) 3097 writeback_inodes_sb_if_idle(sb); 3098 3099 return 0; 3100 } 3101 3102 static int ext4_da_write_begin(struct file *file, struct address_space *mapping, 3103 loff_t pos, unsigned len, unsigned flags, 3104 struct page **pagep, void **fsdata) 3105 { 3106 int ret, retries = 0; 3107 struct page *page; 3108 pgoff_t index; 3109 struct inode *inode = mapping->host; 3110 handle_t *handle; 3111 3112 index = pos >> PAGE_CACHE_SHIFT; 3113 3114 if (ext4_nonda_switch(inode->i_sb)) { 3115 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC; 3116 return ext4_write_begin(file, mapping, pos, 3117 len, flags, pagep, fsdata); 3118 } 3119 *fsdata = (void *)0; 3120 trace_ext4_da_write_begin(inode, pos, len, flags); 3121 retry: 3122 /* 3123 * With delayed allocation, we don't log the i_disksize update 3124 * if there is delayed block allocation. But we still need 3125 * to journalling the i_disksize update if writes to the end 3126 * of file which has an already mapped buffer. 3127 */ 3128 handle = ext4_journal_start(inode, 1); 3129 if (IS_ERR(handle)) { 3130 ret = PTR_ERR(handle); 3131 goto out; 3132 } 3133 /* We cannot recurse into the filesystem as the transaction is already 3134 * started */ 3135 flags |= AOP_FLAG_NOFS; 3136 3137 page = grab_cache_page_write_begin(mapping, index, flags); 3138 if (!page) { 3139 ext4_journal_stop(handle); 3140 ret = -ENOMEM; 3141 goto out; 3142 } 3143 *pagep = page; 3144 3145 ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep); 3146 if (ret < 0) { 3147 unlock_page(page); 3148 ext4_journal_stop(handle); 3149 page_cache_release(page); 3150 /* 3151 * block_write_begin may have instantiated a few blocks 3152 * outside i_size. Trim these off again. Don't need 3153 * i_size_read because we hold i_mutex. 3154 */ 3155 if (pos + len > inode->i_size) 3156 ext4_truncate_failed_write(inode); 3157 } 3158 3159 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) 3160 goto retry; 3161 out: 3162 return ret; 3163 } 3164 3165 /* 3166 * Check if we should update i_disksize 3167 * when write to the end of file but not require block allocation 3168 */ 3169 static int ext4_da_should_update_i_disksize(struct page *page, 3170 unsigned long offset) 3171 { 3172 struct buffer_head *bh; 3173 struct inode *inode = page->mapping->host; 3174 unsigned int idx; 3175 int i; 3176 3177 bh = page_buffers(page); 3178 idx = offset >> inode->i_blkbits; 3179 3180 for (i = 0; i < idx; i++) 3181 bh = bh->b_this_page; 3182 3183 if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh)) 3184 return 0; 3185 return 1; 3186 } 3187 3188 static int ext4_da_write_end(struct file *file, 3189 struct address_space *mapping, 3190 loff_t pos, unsigned len, unsigned copied, 3191 struct page *page, void *fsdata) 3192 { 3193 struct inode *inode = mapping->host; 3194 int ret = 0, ret2; 3195 handle_t *handle = ext4_journal_current_handle(); 3196 loff_t new_i_size; 3197 unsigned long start, end; 3198 int write_mode = (int)(unsigned long)fsdata; 3199 3200 if (write_mode == FALL_BACK_TO_NONDELALLOC) { 3201 if (ext4_should_order_data(inode)) { 3202 return ext4_ordered_write_end(file, mapping, pos, 3203 len, copied, page, fsdata); 3204 } else if (ext4_should_writeback_data(inode)) { 3205 return ext4_writeback_write_end(file, mapping, pos, 3206 len, copied, page, fsdata); 3207 } else { 3208 BUG(); 3209 } 3210 } 3211 3212 trace_ext4_da_write_end(inode, pos, len, copied); 3213 start = pos & (PAGE_CACHE_SIZE - 1); 3214 end = start + copied - 1; 3215 3216 /* 3217 * generic_write_end() will run mark_inode_dirty() if i_size 3218 * changes. So let's piggyback the i_disksize mark_inode_dirty 3219 * into that. 3220 */ 3221 3222 new_i_size = pos + copied; 3223 if (new_i_size > EXT4_I(inode)->i_disksize) { 3224 if (ext4_da_should_update_i_disksize(page, end)) { 3225 down_write(&EXT4_I(inode)->i_data_sem); 3226 if (new_i_size > EXT4_I(inode)->i_disksize) { 3227 /* 3228 * Updating i_disksize when extending file 3229 * without needing block allocation 3230 */ 3231 if (ext4_should_order_data(inode)) 3232 ret = ext4_jbd2_file_inode(handle, 3233 inode); 3234 3235 EXT4_I(inode)->i_disksize = new_i_size; 3236 } 3237 up_write(&EXT4_I(inode)->i_data_sem); 3238 /* We need to mark inode dirty even if 3239 * new_i_size is less that inode->i_size 3240 * bu greater than i_disksize.(hint delalloc) 3241 */ 3242 ext4_mark_inode_dirty(handle, inode); 3243 } 3244 } 3245 ret2 = generic_write_end(file, mapping, pos, len, copied, 3246 page, fsdata); 3247 copied = ret2; 3248 if (ret2 < 0) 3249 ret = ret2; 3250 ret2 = ext4_journal_stop(handle); 3251 if (!ret) 3252 ret = ret2; 3253 3254 return ret ? ret : copied; 3255 } 3256 3257 static void ext4_da_invalidatepage(struct page *page, unsigned long offset) 3258 { 3259 /* 3260 * Drop reserved blocks 3261 */ 3262 BUG_ON(!PageLocked(page)); 3263 if (!page_has_buffers(page)) 3264 goto out; 3265 3266 ext4_da_page_release_reservation(page, offset); 3267 3268 out: 3269 ext4_invalidatepage(page, offset); 3270 3271 return; 3272 } 3273 3274 /* 3275 * Force all delayed allocation blocks to be allocated for a given inode. 3276 */ 3277 int ext4_alloc_da_blocks(struct inode *inode) 3278 { 3279 trace_ext4_alloc_da_blocks(inode); 3280 3281 if (!EXT4_I(inode)->i_reserved_data_blocks && 3282 !EXT4_I(inode)->i_reserved_meta_blocks) 3283 return 0; 3284 3285 /* 3286 * We do something simple for now. The filemap_flush() will 3287 * also start triggering a write of the data blocks, which is 3288 * not strictly speaking necessary (and for users of 3289 * laptop_mode, not even desirable). However, to do otherwise 3290 * would require replicating code paths in: 3291 * 3292 * ext4_da_writepages() -> 3293 * write_cache_pages() ---> (via passed in callback function) 3294 * __mpage_da_writepage() --> 3295 * mpage_add_bh_to_extent() 3296 * mpage_da_map_blocks() 3297 * 3298 * The problem is that write_cache_pages(), located in 3299 * mm/page-writeback.c, marks pages clean in preparation for 3300 * doing I/O, which is not desirable if we're not planning on 3301 * doing I/O at all. 3302 * 3303 * We could call write_cache_pages(), and then redirty all of 3304 * the pages by calling redirty_page_for_writepage() but that 3305 * would be ugly in the extreme. So instead we would need to 3306 * replicate parts of the code in the above functions, 3307 * simplifying them becuase we wouldn't actually intend to 3308 * write out the pages, but rather only collect contiguous 3309 * logical block extents, call the multi-block allocator, and 3310 * then update the buffer heads with the block allocations. 3311 * 3312 * For now, though, we'll cheat by calling filemap_flush(), 3313 * which will map the blocks, and start the I/O, but not 3314 * actually wait for the I/O to complete. 3315 */ 3316 return filemap_flush(inode->i_mapping); 3317 } 3318 3319 /* 3320 * bmap() is special. It gets used by applications such as lilo and by 3321 * the swapper to find the on-disk block of a specific piece of data. 3322 * 3323 * Naturally, this is dangerous if the block concerned is still in the 3324 * journal. If somebody makes a swapfile on an ext4 data-journaling 3325 * filesystem and enables swap, then they may get a nasty shock when the 3326 * data getting swapped to that swapfile suddenly gets overwritten by 3327 * the original zero's written out previously to the journal and 3328 * awaiting writeback in the kernel's buffer cache. 3329 * 3330 * So, if we see any bmap calls here on a modified, data-journaled file, 3331 * take extra steps to flush any blocks which might be in the cache. 3332 */ 3333 static sector_t ext4_bmap(struct address_space *mapping, sector_t block) 3334 { 3335 struct inode *inode = mapping->host; 3336 journal_t *journal; 3337 int err; 3338 3339 if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) && 3340 test_opt(inode->i_sb, DELALLOC)) { 3341 /* 3342 * With delalloc we want to sync the file 3343 * so that we can make sure we allocate 3344 * blocks for file 3345 */ 3346 filemap_write_and_wait(mapping); 3347 } 3348 3349 if (EXT4_JOURNAL(inode) && 3350 ext4_test_inode_state(inode, EXT4_STATE_JDATA)) { 3351 /* 3352 * This is a REALLY heavyweight approach, but the use of 3353 * bmap on dirty files is expected to be extremely rare: 3354 * only if we run lilo or swapon on a freshly made file 3355 * do we expect this to happen. 3356 * 3357 * (bmap requires CAP_SYS_RAWIO so this does not 3358 * represent an unprivileged user DOS attack --- we'd be 3359 * in trouble if mortal users could trigger this path at 3360 * will.) 3361 * 3362 * NB. EXT4_STATE_JDATA is not set on files other than 3363 * regular files. If somebody wants to bmap a directory 3364 * or symlink and gets confused because the buffer 3365 * hasn't yet been flushed to disk, they deserve 3366 * everything they get. 3367 */ 3368 3369 ext4_clear_inode_state(inode, EXT4_STATE_JDATA); 3370 journal = EXT4_JOURNAL(inode); 3371 jbd2_journal_lock_updates(journal); 3372 err = jbd2_journal_flush(journal); 3373 jbd2_journal_unlock_updates(journal); 3374 3375 if (err) 3376 return 0; 3377 } 3378 3379 return generic_block_bmap(mapping, block, ext4_get_block); 3380 } 3381 3382 static int ext4_readpage(struct file *file, struct page *page) 3383 { 3384 trace_ext4_readpage(page); 3385 return mpage_readpage(page, ext4_get_block); 3386 } 3387 3388 static int 3389 ext4_readpages(struct file *file, struct address_space *mapping, 3390 struct list_head *pages, unsigned nr_pages) 3391 { 3392 return mpage_readpages(mapping, pages, nr_pages, ext4_get_block); 3393 } 3394 3395 static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset) 3396 { 3397 struct buffer_head *head, *bh; 3398 unsigned int curr_off = 0; 3399 3400 if (!page_has_buffers(page)) 3401 return; 3402 head = bh = page_buffers(page); 3403 do { 3404 if (offset <= curr_off && test_clear_buffer_uninit(bh) 3405 && bh->b_private) { 3406 ext4_free_io_end(bh->b_private); 3407 bh->b_private = NULL; 3408 bh->b_end_io = NULL; 3409 } 3410 curr_off = curr_off + bh->b_size; 3411 bh = bh->b_this_page; 3412 } while (bh != head); 3413 } 3414 3415 static void ext4_invalidatepage(struct page *page, unsigned long offset) 3416 { 3417 journal_t *journal = EXT4_JOURNAL(page->mapping->host); 3418 3419 trace_ext4_invalidatepage(page, offset); 3420 3421 /* 3422 * free any io_end structure allocated for buffers to be discarded 3423 */ 3424 if (ext4_should_dioread_nolock(page->mapping->host)) 3425 ext4_invalidatepage_free_endio(page, offset); 3426 /* 3427 * If it's a full truncate we just forget about the pending dirtying 3428 */ 3429 if (offset == 0) 3430 ClearPageChecked(page); 3431 3432 if (journal) 3433 jbd2_journal_invalidatepage(journal, page, offset); 3434 else 3435 block_invalidatepage(page, offset); 3436 } 3437 3438 static int ext4_releasepage(struct page *page, gfp_t wait) 3439 { 3440 journal_t *journal = EXT4_JOURNAL(page->mapping->host); 3441 3442 trace_ext4_releasepage(page); 3443 3444 WARN_ON(PageChecked(page)); 3445 if (!page_has_buffers(page)) 3446 return 0; 3447 if (journal) 3448 return jbd2_journal_try_to_free_buffers(journal, page, wait); 3449 else 3450 return try_to_free_buffers(page); 3451 } 3452 3453 /* 3454 * O_DIRECT for ext3 (or indirect map) based files 3455 * 3456 * If the O_DIRECT write will extend the file then add this inode to the 3457 * orphan list. So recovery will truncate it back to the original size 3458 * if the machine crashes during the write. 3459 * 3460 * If the O_DIRECT write is intantiating holes inside i_size and the machine 3461 * crashes then stale disk data _may_ be exposed inside the file. But current 3462 * VFS code falls back into buffered path in that case so we are safe. 3463 */ 3464 static ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb, 3465 const struct iovec *iov, loff_t offset, 3466 unsigned long nr_segs) 3467 { 3468 struct file *file = iocb->ki_filp; 3469 struct inode *inode = file->f_mapping->host; 3470 struct ext4_inode_info *ei = EXT4_I(inode); 3471 handle_t *handle; 3472 ssize_t ret; 3473 int orphan = 0; 3474 size_t count = iov_length(iov, nr_segs); 3475 int retries = 0; 3476 3477 if (rw == WRITE) { 3478 loff_t final_size = offset + count; 3479 3480 if (final_size > inode->i_size) { 3481 /* Credits for sb + inode write */ 3482 handle = ext4_journal_start(inode, 2); 3483 if (IS_ERR(handle)) { 3484 ret = PTR_ERR(handle); 3485 goto out; 3486 } 3487 ret = ext4_orphan_add(handle, inode); 3488 if (ret) { 3489 ext4_journal_stop(handle); 3490 goto out; 3491 } 3492 orphan = 1; 3493 ei->i_disksize = inode->i_size; 3494 ext4_journal_stop(handle); 3495 } 3496 } 3497 3498 retry: 3499 if (rw == READ && ext4_should_dioread_nolock(inode)) 3500 ret = __blockdev_direct_IO(rw, iocb, inode, 3501 inode->i_sb->s_bdev, iov, 3502 offset, nr_segs, 3503 ext4_get_block, NULL, NULL, 0); 3504 else { 3505 ret = blockdev_direct_IO(rw, iocb, inode, 3506 inode->i_sb->s_bdev, iov, 3507 offset, nr_segs, 3508 ext4_get_block, NULL); 3509 3510 if (unlikely((rw & WRITE) && ret < 0)) { 3511 loff_t isize = i_size_read(inode); 3512 loff_t end = offset + iov_length(iov, nr_segs); 3513 3514 if (end > isize) 3515 vmtruncate(inode, isize); 3516 } 3517 } 3518 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) 3519 goto retry; 3520 3521 if (orphan) { 3522 int err; 3523 3524 /* Credits for sb + inode write */ 3525 handle = ext4_journal_start(inode, 2); 3526 if (IS_ERR(handle)) { 3527 /* This is really bad luck. We've written the data 3528 * but cannot extend i_size. Bail out and pretend 3529 * the write failed... */ 3530 ret = PTR_ERR(handle); 3531 if (inode->i_nlink) 3532 ext4_orphan_del(NULL, inode); 3533 3534 goto out; 3535 } 3536 if (inode->i_nlink) 3537 ext4_orphan_del(handle, inode); 3538 if (ret > 0) { 3539 loff_t end = offset + ret; 3540 if (end > inode->i_size) { 3541 ei->i_disksize = end; 3542 i_size_write(inode, end); 3543 /* 3544 * We're going to return a positive `ret' 3545 * here due to non-zero-length I/O, so there's 3546 * no way of reporting error returns from 3547 * ext4_mark_inode_dirty() to userspace. So 3548 * ignore it. 3549 */ 3550 ext4_mark_inode_dirty(handle, inode); 3551 } 3552 } 3553 err = ext4_journal_stop(handle); 3554 if (ret == 0) 3555 ret = err; 3556 } 3557 out: 3558 return ret; 3559 } 3560 3561 /* 3562 * ext4_get_block used when preparing for a DIO write or buffer write. 3563 * We allocate an uinitialized extent if blocks haven't been allocated. 3564 * The extent will be converted to initialized after the IO is complete. 3565 */ 3566 static int ext4_get_block_write(struct inode *inode, sector_t iblock, 3567 struct buffer_head *bh_result, int create) 3568 { 3569 ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n", 3570 inode->i_ino, create); 3571 return _ext4_get_block(inode, iblock, bh_result, 3572 EXT4_GET_BLOCKS_IO_CREATE_EXT); 3573 } 3574 3575 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset, 3576 ssize_t size, void *private, int ret, 3577 bool is_async) 3578 { 3579 ext4_io_end_t *io_end = iocb->private; 3580 struct workqueue_struct *wq; 3581 unsigned long flags; 3582 struct ext4_inode_info *ei; 3583 3584 /* if not async direct IO or dio with 0 bytes write, just return */ 3585 if (!io_end || !size) 3586 goto out; 3587 3588 ext_debug("ext4_end_io_dio(): io_end 0x%p" 3589 "for inode %lu, iocb 0x%p, offset %llu, size %llu\n", 3590 iocb->private, io_end->inode->i_ino, iocb, offset, 3591 size); 3592 3593 /* if not aio dio with unwritten extents, just free io and return */ 3594 if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) { 3595 ext4_free_io_end(io_end); 3596 iocb->private = NULL; 3597 out: 3598 if (is_async) 3599 aio_complete(iocb, ret, 0); 3600 return; 3601 } 3602 3603 io_end->offset = offset; 3604 io_end->size = size; 3605 if (is_async) { 3606 io_end->iocb = iocb; 3607 io_end->result = ret; 3608 } 3609 wq = EXT4_SB(io_end->inode->i_sb)->dio_unwritten_wq; 3610 3611 /* Add the io_end to per-inode completed aio dio list*/ 3612 ei = EXT4_I(io_end->inode); 3613 spin_lock_irqsave(&ei->i_completed_io_lock, flags); 3614 list_add_tail(&io_end->list, &ei->i_completed_io_list); 3615 spin_unlock_irqrestore(&ei->i_completed_io_lock, flags); 3616 3617 /* queue the work to convert unwritten extents to written */ 3618 queue_work(wq, &io_end->work); 3619 iocb->private = NULL; 3620 } 3621 3622 static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate) 3623 { 3624 ext4_io_end_t *io_end = bh->b_private; 3625 struct workqueue_struct *wq; 3626 struct inode *inode; 3627 unsigned long flags; 3628 3629 if (!test_clear_buffer_uninit(bh) || !io_end) 3630 goto out; 3631 3632 if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) { 3633 printk("sb umounted, discard end_io request for inode %lu\n", 3634 io_end->inode->i_ino); 3635 ext4_free_io_end(io_end); 3636 goto out; 3637 } 3638 3639 io_end->flag = EXT4_IO_END_UNWRITTEN; 3640 inode = io_end->inode; 3641 3642 /* Add the io_end to per-inode completed io list*/ 3643 spin_lock_irqsave(&EXT4_I(inode)->i_completed_io_lock, flags); 3644 list_add_tail(&io_end->list, &EXT4_I(inode)->i_completed_io_list); 3645 spin_unlock_irqrestore(&EXT4_I(inode)->i_completed_io_lock, flags); 3646 3647 wq = EXT4_SB(inode->i_sb)->dio_unwritten_wq; 3648 /* queue the work to convert unwritten extents to written */ 3649 queue_work(wq, &io_end->work); 3650 out: 3651 bh->b_private = NULL; 3652 bh->b_end_io = NULL; 3653 clear_buffer_uninit(bh); 3654 end_buffer_async_write(bh, uptodate); 3655 } 3656 3657 static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode) 3658 { 3659 ext4_io_end_t *io_end; 3660 struct page *page = bh->b_page; 3661 loff_t offset = (sector_t)page->index << PAGE_CACHE_SHIFT; 3662 size_t size = bh->b_size; 3663 3664 retry: 3665 io_end = ext4_init_io_end(inode, GFP_ATOMIC); 3666 if (!io_end) { 3667 pr_warn_ratelimited("%s: allocation fail\n", __func__); 3668 schedule(); 3669 goto retry; 3670 } 3671 io_end->offset = offset; 3672 io_end->size = size; 3673 /* 3674 * We need to hold a reference to the page to make sure it 3675 * doesn't get evicted before ext4_end_io_work() has a chance 3676 * to convert the extent from written to unwritten. 3677 */ 3678 io_end->page = page; 3679 get_page(io_end->page); 3680 3681 bh->b_private = io_end; 3682 bh->b_end_io = ext4_end_io_buffer_write; 3683 return 0; 3684 } 3685 3686 /* 3687 * For ext4 extent files, ext4 will do direct-io write to holes, 3688 * preallocated extents, and those write extend the file, no need to 3689 * fall back to buffered IO. 3690 * 3691 * For holes, we fallocate those blocks, mark them as uninitialized 3692 * If those blocks were preallocated, we mark sure they are splited, but 3693 * still keep the range to write as uninitialized. 3694 * 3695 * The unwrritten extents will be converted to written when DIO is completed. 3696 * For async direct IO, since the IO may still pending when return, we 3697 * set up an end_io call back function, which will do the convertion 3698 * when async direct IO completed. 3699 * 3700 * If the O_DIRECT write will extend the file then add this inode to the 3701 * orphan list. So recovery will truncate it back to the original size 3702 * if the machine crashes during the write. 3703 * 3704 */ 3705 static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb, 3706 const struct iovec *iov, loff_t offset, 3707 unsigned long nr_segs) 3708 { 3709 struct file *file = iocb->ki_filp; 3710 struct inode *inode = file->f_mapping->host; 3711 ssize_t ret; 3712 size_t count = iov_length(iov, nr_segs); 3713 3714 loff_t final_size = offset + count; 3715 if (rw == WRITE && final_size <= inode->i_size) { 3716 /* 3717 * We could direct write to holes and fallocate. 3718 * 3719 * Allocated blocks to fill the hole are marked as uninitialized 3720 * to prevent paralel buffered read to expose the stale data 3721 * before DIO complete the data IO. 3722 * 3723 * As to previously fallocated extents, ext4 get_block 3724 * will just simply mark the buffer mapped but still 3725 * keep the extents uninitialized. 3726 * 3727 * for non AIO case, we will convert those unwritten extents 3728 * to written after return back from blockdev_direct_IO. 3729 * 3730 * for async DIO, the conversion needs to be defered when 3731 * the IO is completed. The ext4 end_io callback function 3732 * will be called to take care of the conversion work. 3733 * Here for async case, we allocate an io_end structure to 3734 * hook to the iocb. 3735 */ 3736 iocb->private = NULL; 3737 EXT4_I(inode)->cur_aio_dio = NULL; 3738 if (!is_sync_kiocb(iocb)) { 3739 iocb->private = ext4_init_io_end(inode, GFP_NOFS); 3740 if (!iocb->private) 3741 return -ENOMEM; 3742 /* 3743 * we save the io structure for current async 3744 * direct IO, so that later ext4_map_blocks() 3745 * could flag the io structure whether there 3746 * is a unwritten extents needs to be converted 3747 * when IO is completed. 3748 */ 3749 EXT4_I(inode)->cur_aio_dio = iocb->private; 3750 } 3751 3752 ret = blockdev_direct_IO(rw, iocb, inode, 3753 inode->i_sb->s_bdev, iov, 3754 offset, nr_segs, 3755 ext4_get_block_write, 3756 ext4_end_io_dio); 3757 if (iocb->private) 3758 EXT4_I(inode)->cur_aio_dio = NULL; 3759 /* 3760 * The io_end structure takes a reference to the inode, 3761 * that structure needs to be destroyed and the 3762 * reference to the inode need to be dropped, when IO is 3763 * complete, even with 0 byte write, or failed. 3764 * 3765 * In the successful AIO DIO case, the io_end structure will be 3766 * desctroyed and the reference to the inode will be dropped 3767 * after the end_io call back function is called. 3768 * 3769 * In the case there is 0 byte write, or error case, since 3770 * VFS direct IO won't invoke the end_io call back function, 3771 * we need to free the end_io structure here. 3772 */ 3773 if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) { 3774 ext4_free_io_end(iocb->private); 3775 iocb->private = NULL; 3776 } else if (ret > 0 && ext4_test_inode_state(inode, 3777 EXT4_STATE_DIO_UNWRITTEN)) { 3778 int err; 3779 /* 3780 * for non AIO case, since the IO is already 3781 * completed, we could do the convertion right here 3782 */ 3783 err = ext4_convert_unwritten_extents(inode, 3784 offset, ret); 3785 if (err < 0) 3786 ret = err; 3787 ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN); 3788 } 3789 return ret; 3790 } 3791 3792 /* for write the the end of file case, we fall back to old way */ 3793 return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs); 3794 } 3795 3796 static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb, 3797 const struct iovec *iov, loff_t offset, 3798 unsigned long nr_segs) 3799 { 3800 struct file *file = iocb->ki_filp; 3801 struct inode *inode = file->f_mapping->host; 3802 ssize_t ret; 3803 3804 trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw); 3805 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 3806 ret = ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs); 3807 else 3808 ret = ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs); 3809 trace_ext4_direct_IO_exit(inode, offset, 3810 iov_length(iov, nr_segs), rw, ret); 3811 return ret; 3812 } 3813 3814 /* 3815 * Pages can be marked dirty completely asynchronously from ext4's journalling 3816 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do 3817 * much here because ->set_page_dirty is called under VFS locks. The page is 3818 * not necessarily locked. 3819 * 3820 * We cannot just dirty the page and leave attached buffers clean, because the 3821 * buffers' dirty state is "definitive". We cannot just set the buffers dirty 3822 * or jbddirty because all the journalling code will explode. 3823 * 3824 * So what we do is to mark the page "pending dirty" and next time writepage 3825 * is called, propagate that into the buffers appropriately. 3826 */ 3827 static int ext4_journalled_set_page_dirty(struct page *page) 3828 { 3829 SetPageChecked(page); 3830 return __set_page_dirty_nobuffers(page); 3831 } 3832 3833 static const struct address_space_operations ext4_ordered_aops = { 3834 .readpage = ext4_readpage, 3835 .readpages = ext4_readpages, 3836 .writepage = ext4_writepage, 3837 .write_begin = ext4_write_begin, 3838 .write_end = ext4_ordered_write_end, 3839 .bmap = ext4_bmap, 3840 .invalidatepage = ext4_invalidatepage, 3841 .releasepage = ext4_releasepage, 3842 .direct_IO = ext4_direct_IO, 3843 .migratepage = buffer_migrate_page, 3844 .is_partially_uptodate = block_is_partially_uptodate, 3845 .error_remove_page = generic_error_remove_page, 3846 }; 3847 3848 static const struct address_space_operations ext4_writeback_aops = { 3849 .readpage = ext4_readpage, 3850 .readpages = ext4_readpages, 3851 .writepage = ext4_writepage, 3852 .write_begin = ext4_write_begin, 3853 .write_end = ext4_writeback_write_end, 3854 .bmap = ext4_bmap, 3855 .invalidatepage = ext4_invalidatepage, 3856 .releasepage = ext4_releasepage, 3857 .direct_IO = ext4_direct_IO, 3858 .migratepage = buffer_migrate_page, 3859 .is_partially_uptodate = block_is_partially_uptodate, 3860 .error_remove_page = generic_error_remove_page, 3861 }; 3862 3863 static const struct address_space_operations ext4_journalled_aops = { 3864 .readpage = ext4_readpage, 3865 .readpages = ext4_readpages, 3866 .writepage = ext4_writepage, 3867 .write_begin = ext4_write_begin, 3868 .write_end = ext4_journalled_write_end, 3869 .set_page_dirty = ext4_journalled_set_page_dirty, 3870 .bmap = ext4_bmap, 3871 .invalidatepage = ext4_invalidatepage, 3872 .releasepage = ext4_releasepage, 3873 .is_partially_uptodate = block_is_partially_uptodate, 3874 .error_remove_page = generic_error_remove_page, 3875 }; 3876 3877 static const struct address_space_operations ext4_da_aops = { 3878 .readpage = ext4_readpage, 3879 .readpages = ext4_readpages, 3880 .writepage = ext4_writepage, 3881 .writepages = ext4_da_writepages, 3882 .write_begin = ext4_da_write_begin, 3883 .write_end = ext4_da_write_end, 3884 .bmap = ext4_bmap, 3885 .invalidatepage = ext4_da_invalidatepage, 3886 .releasepage = ext4_releasepage, 3887 .direct_IO = ext4_direct_IO, 3888 .migratepage = buffer_migrate_page, 3889 .is_partially_uptodate = block_is_partially_uptodate, 3890 .error_remove_page = generic_error_remove_page, 3891 }; 3892 3893 void ext4_set_aops(struct inode *inode) 3894 { 3895 if (ext4_should_order_data(inode) && 3896 test_opt(inode->i_sb, DELALLOC)) 3897 inode->i_mapping->a_ops = &ext4_da_aops; 3898 else if (ext4_should_order_data(inode)) 3899 inode->i_mapping->a_ops = &ext4_ordered_aops; 3900 else if (ext4_should_writeback_data(inode) && 3901 test_opt(inode->i_sb, DELALLOC)) 3902 inode->i_mapping->a_ops = &ext4_da_aops; 3903 else if (ext4_should_writeback_data(inode)) 3904 inode->i_mapping->a_ops = &ext4_writeback_aops; 3905 else 3906 inode->i_mapping->a_ops = &ext4_journalled_aops; 3907 } 3908 3909 /* 3910 * ext4_block_truncate_page() zeroes out a mapping from file offset `from' 3911 * up to the end of the block which corresponds to `from'. 3912 * This required during truncate. We need to physically zero the tail end 3913 * of that block so it doesn't yield old data if the file is later grown. 3914 */ 3915 int ext4_block_truncate_page(handle_t *handle, 3916 struct address_space *mapping, loff_t from) 3917 { 3918 ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT; 3919 unsigned offset = from & (PAGE_CACHE_SIZE-1); 3920 unsigned blocksize, length, pos; 3921 ext4_lblk_t iblock; 3922 struct inode *inode = mapping->host; 3923 struct buffer_head *bh; 3924 struct page *page; 3925 int err = 0; 3926 3927 page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT, 3928 mapping_gfp_mask(mapping) & ~__GFP_FS); 3929 if (!page) 3930 return -EINVAL; 3931 3932 blocksize = inode->i_sb->s_blocksize; 3933 length = blocksize - (offset & (blocksize - 1)); 3934 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); 3935 3936 if (!page_has_buffers(page)) 3937 create_empty_buffers(page, blocksize, 0); 3938 3939 /* Find the buffer that contains "offset" */ 3940 bh = page_buffers(page); 3941 pos = blocksize; 3942 while (offset >= pos) { 3943 bh = bh->b_this_page; 3944 iblock++; 3945 pos += blocksize; 3946 } 3947 3948 err = 0; 3949 if (buffer_freed(bh)) { 3950 BUFFER_TRACE(bh, "freed: skip"); 3951 goto unlock; 3952 } 3953 3954 if (!buffer_mapped(bh)) { 3955 BUFFER_TRACE(bh, "unmapped"); 3956 ext4_get_block(inode, iblock, bh, 0); 3957 /* unmapped? It's a hole - nothing to do */ 3958 if (!buffer_mapped(bh)) { 3959 BUFFER_TRACE(bh, "still unmapped"); 3960 goto unlock; 3961 } 3962 } 3963 3964 /* Ok, it's mapped. Make sure it's up-to-date */ 3965 if (PageUptodate(page)) 3966 set_buffer_uptodate(bh); 3967 3968 if (!buffer_uptodate(bh)) { 3969 err = -EIO; 3970 ll_rw_block(READ, 1, &bh); 3971 wait_on_buffer(bh); 3972 /* Uhhuh. Read error. Complain and punt. */ 3973 if (!buffer_uptodate(bh)) 3974 goto unlock; 3975 } 3976 3977 if (ext4_should_journal_data(inode)) { 3978 BUFFER_TRACE(bh, "get write access"); 3979 err = ext4_journal_get_write_access(handle, bh); 3980 if (err) 3981 goto unlock; 3982 } 3983 3984 zero_user(page, offset, length); 3985 3986 BUFFER_TRACE(bh, "zeroed end of block"); 3987 3988 err = 0; 3989 if (ext4_should_journal_data(inode)) { 3990 err = ext4_handle_dirty_metadata(handle, inode, bh); 3991 } else { 3992 if (ext4_should_order_data(inode) && EXT4_I(inode)->jinode) 3993 err = ext4_jbd2_file_inode(handle, inode); 3994 mark_buffer_dirty(bh); 3995 } 3996 3997 unlock: 3998 unlock_page(page); 3999 page_cache_release(page); 4000 return err; 4001 } 4002 4003 /* 4004 * Probably it should be a library function... search for first non-zero word 4005 * or memcmp with zero_page, whatever is better for particular architecture. 4006 * Linus? 4007 */ 4008 static inline int all_zeroes(__le32 *p, __le32 *q) 4009 { 4010 while (p < q) 4011 if (*p++) 4012 return 0; 4013 return 1; 4014 } 4015 4016 /** 4017 * ext4_find_shared - find the indirect blocks for partial truncation. 4018 * @inode: inode in question 4019 * @depth: depth of the affected branch 4020 * @offsets: offsets of pointers in that branch (see ext4_block_to_path) 4021 * @chain: place to store the pointers to partial indirect blocks 4022 * @top: place to the (detached) top of branch 4023 * 4024 * This is a helper function used by ext4_truncate(). 4025 * 4026 * When we do truncate() we may have to clean the ends of several 4027 * indirect blocks but leave the blocks themselves alive. Block is 4028 * partially truncated if some data below the new i_size is refered 4029 * from it (and it is on the path to the first completely truncated 4030 * data block, indeed). We have to free the top of that path along 4031 * with everything to the right of the path. Since no allocation 4032 * past the truncation point is possible until ext4_truncate() 4033 * finishes, we may safely do the latter, but top of branch may 4034 * require special attention - pageout below the truncation point 4035 * might try to populate it. 4036 * 4037 * We atomically detach the top of branch from the tree, store the 4038 * block number of its root in *@top, pointers to buffer_heads of 4039 * partially truncated blocks - in @chain[].bh and pointers to 4040 * their last elements that should not be removed - in 4041 * @chain[].p. Return value is the pointer to last filled element 4042 * of @chain. 4043 * 4044 * The work left to caller to do the actual freeing of subtrees: 4045 * a) free the subtree starting from *@top 4046 * b) free the subtrees whose roots are stored in 4047 * (@chain[i].p+1 .. end of @chain[i].bh->b_data) 4048 * c) free the subtrees growing from the inode past the @chain[0]. 4049 * (no partially truncated stuff there). */ 4050 4051 static Indirect *ext4_find_shared(struct inode *inode, int depth, 4052 ext4_lblk_t offsets[4], Indirect chain[4], 4053 __le32 *top) 4054 { 4055 Indirect *partial, *p; 4056 int k, err; 4057 4058 *top = 0; 4059 /* Make k index the deepest non-null offset + 1 */ 4060 for (k = depth; k > 1 && !offsets[k-1]; k--) 4061 ; 4062 partial = ext4_get_branch(inode, k, offsets, chain, &err); 4063 /* Writer: pointers */ 4064 if (!partial) 4065 partial = chain + k-1; 4066 /* 4067 * If the branch acquired continuation since we've looked at it - 4068 * fine, it should all survive and (new) top doesn't belong to us. 4069 */ 4070 if (!partial->key && *partial->p) 4071 /* Writer: end */ 4072 goto no_top; 4073 for (p = partial; (p > chain) && all_zeroes((__le32 *) p->bh->b_data, p->p); p--) 4074 ; 4075 /* 4076 * OK, we've found the last block that must survive. The rest of our 4077 * branch should be detached before unlocking. However, if that rest 4078 * of branch is all ours and does not grow immediately from the inode 4079 * it's easier to cheat and just decrement partial->p. 4080 */ 4081 if (p == chain + k - 1 && p > chain) { 4082 p->p--; 4083 } else { 4084 *top = *p->p; 4085 /* Nope, don't do this in ext4. Must leave the tree intact */ 4086 #if 0 4087 *p->p = 0; 4088 #endif 4089 } 4090 /* Writer: end */ 4091 4092 while (partial > p) { 4093 brelse(partial->bh); 4094 partial--; 4095 } 4096 no_top: 4097 return partial; 4098 } 4099 4100 /* 4101 * Zero a number of block pointers in either an inode or an indirect block. 4102 * If we restart the transaction we must again get write access to the 4103 * indirect block for further modification. 4104 * 4105 * We release `count' blocks on disk, but (last - first) may be greater 4106 * than `count' because there can be holes in there. 4107 * 4108 * Return 0 on success, 1 on invalid block range 4109 * and < 0 on fatal error. 4110 */ 4111 static int ext4_clear_blocks(handle_t *handle, struct inode *inode, 4112 struct buffer_head *bh, 4113 ext4_fsblk_t block_to_free, 4114 unsigned long count, __le32 *first, 4115 __le32 *last) 4116 { 4117 __le32 *p; 4118 int flags = EXT4_FREE_BLOCKS_FORGET | EXT4_FREE_BLOCKS_VALIDATED; 4119 int err; 4120 4121 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) 4122 flags |= EXT4_FREE_BLOCKS_METADATA; 4123 4124 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), block_to_free, 4125 count)) { 4126 EXT4_ERROR_INODE(inode, "attempt to clear invalid " 4127 "blocks %llu len %lu", 4128 (unsigned long long) block_to_free, count); 4129 return 1; 4130 } 4131 4132 if (try_to_extend_transaction(handle, inode)) { 4133 if (bh) { 4134 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); 4135 err = ext4_handle_dirty_metadata(handle, inode, bh); 4136 if (unlikely(err)) 4137 goto out_err; 4138 } 4139 err = ext4_mark_inode_dirty(handle, inode); 4140 if (unlikely(err)) 4141 goto out_err; 4142 err = ext4_truncate_restart_trans(handle, inode, 4143 blocks_for_truncate(inode)); 4144 if (unlikely(err)) 4145 goto out_err; 4146 if (bh) { 4147 BUFFER_TRACE(bh, "retaking write access"); 4148 err = ext4_journal_get_write_access(handle, bh); 4149 if (unlikely(err)) 4150 goto out_err; 4151 } 4152 } 4153 4154 for (p = first; p < last; p++) 4155 *p = 0; 4156 4157 ext4_free_blocks(handle, inode, NULL, block_to_free, count, flags); 4158 return 0; 4159 out_err: 4160 ext4_std_error(inode->i_sb, err); 4161 return err; 4162 } 4163 4164 /** 4165 * ext4_free_data - free a list of data blocks 4166 * @handle: handle for this transaction 4167 * @inode: inode we are dealing with 4168 * @this_bh: indirect buffer_head which contains *@first and *@last 4169 * @first: array of block numbers 4170 * @last: points immediately past the end of array 4171 * 4172 * We are freeing all blocks refered from that array (numbers are stored as 4173 * little-endian 32-bit) and updating @inode->i_blocks appropriately. 4174 * 4175 * We accumulate contiguous runs of blocks to free. Conveniently, if these 4176 * blocks are contiguous then releasing them at one time will only affect one 4177 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't 4178 * actually use a lot of journal space. 4179 * 4180 * @this_bh will be %NULL if @first and @last point into the inode's direct 4181 * block pointers. 4182 */ 4183 static void ext4_free_data(handle_t *handle, struct inode *inode, 4184 struct buffer_head *this_bh, 4185 __le32 *first, __le32 *last) 4186 { 4187 ext4_fsblk_t block_to_free = 0; /* Starting block # of a run */ 4188 unsigned long count = 0; /* Number of blocks in the run */ 4189 __le32 *block_to_free_p = NULL; /* Pointer into inode/ind 4190 corresponding to 4191 block_to_free */ 4192 ext4_fsblk_t nr; /* Current block # */ 4193 __le32 *p; /* Pointer into inode/ind 4194 for current block */ 4195 int err = 0; 4196 4197 if (this_bh) { /* For indirect block */ 4198 BUFFER_TRACE(this_bh, "get_write_access"); 4199 err = ext4_journal_get_write_access(handle, this_bh); 4200 /* Important: if we can't update the indirect pointers 4201 * to the blocks, we can't free them. */ 4202 if (err) 4203 return; 4204 } 4205 4206 for (p = first; p < last; p++) { 4207 nr = le32_to_cpu(*p); 4208 if (nr) { 4209 /* accumulate blocks to free if they're contiguous */ 4210 if (count == 0) { 4211 block_to_free = nr; 4212 block_to_free_p = p; 4213 count = 1; 4214 } else if (nr == block_to_free + count) { 4215 count++; 4216 } else { 4217 err = ext4_clear_blocks(handle, inode, this_bh, 4218 block_to_free, count, 4219 block_to_free_p, p); 4220 if (err) 4221 break; 4222 block_to_free = nr; 4223 block_to_free_p = p; 4224 count = 1; 4225 } 4226 } 4227 } 4228 4229 if (!err && count > 0) 4230 err = ext4_clear_blocks(handle, inode, this_bh, block_to_free, 4231 count, block_to_free_p, p); 4232 if (err < 0) 4233 /* fatal error */ 4234 return; 4235 4236 if (this_bh) { 4237 BUFFER_TRACE(this_bh, "call ext4_handle_dirty_metadata"); 4238 4239 /* 4240 * The buffer head should have an attached journal head at this 4241 * point. However, if the data is corrupted and an indirect 4242 * block pointed to itself, it would have been detached when 4243 * the block was cleared. Check for this instead of OOPSing. 4244 */ 4245 if ((EXT4_JOURNAL(inode) == NULL) || bh2jh(this_bh)) 4246 ext4_handle_dirty_metadata(handle, inode, this_bh); 4247 else 4248 EXT4_ERROR_INODE(inode, 4249 "circular indirect block detected at " 4250 "block %llu", 4251 (unsigned long long) this_bh->b_blocknr); 4252 } 4253 } 4254 4255 /** 4256 * ext4_free_branches - free an array of branches 4257 * @handle: JBD handle for this transaction 4258 * @inode: inode we are dealing with 4259 * @parent_bh: the buffer_head which contains *@first and *@last 4260 * @first: array of block numbers 4261 * @last: pointer immediately past the end of array 4262 * @depth: depth of the branches to free 4263 * 4264 * We are freeing all blocks refered from these branches (numbers are 4265 * stored as little-endian 32-bit) and updating @inode->i_blocks 4266 * appropriately. 4267 */ 4268 static void ext4_free_branches(handle_t *handle, struct inode *inode, 4269 struct buffer_head *parent_bh, 4270 __le32 *first, __le32 *last, int depth) 4271 { 4272 ext4_fsblk_t nr; 4273 __le32 *p; 4274 4275 if (ext4_handle_is_aborted(handle)) 4276 return; 4277 4278 if (depth--) { 4279 struct buffer_head *bh; 4280 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); 4281 p = last; 4282 while (--p >= first) { 4283 nr = le32_to_cpu(*p); 4284 if (!nr) 4285 continue; /* A hole */ 4286 4287 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), 4288 nr, 1)) { 4289 EXT4_ERROR_INODE(inode, 4290 "invalid indirect mapped " 4291 "block %lu (level %d)", 4292 (unsigned long) nr, depth); 4293 break; 4294 } 4295 4296 /* Go read the buffer for the next level down */ 4297 bh = sb_bread(inode->i_sb, nr); 4298 4299 /* 4300 * A read failure? Report error and clear slot 4301 * (should be rare). 4302 */ 4303 if (!bh) { 4304 EXT4_ERROR_INODE_BLOCK(inode, nr, 4305 "Read failure"); 4306 continue; 4307 } 4308 4309 /* This zaps the entire block. Bottom up. */ 4310 BUFFER_TRACE(bh, "free child branches"); 4311 ext4_free_branches(handle, inode, bh, 4312 (__le32 *) bh->b_data, 4313 (__le32 *) bh->b_data + addr_per_block, 4314 depth); 4315 brelse(bh); 4316 4317 /* 4318 * Everything below this this pointer has been 4319 * released. Now let this top-of-subtree go. 4320 * 4321 * We want the freeing of this indirect block to be 4322 * atomic in the journal with the updating of the 4323 * bitmap block which owns it. So make some room in 4324 * the journal. 4325 * 4326 * We zero the parent pointer *after* freeing its 4327 * pointee in the bitmaps, so if extend_transaction() 4328 * for some reason fails to put the bitmap changes and 4329 * the release into the same transaction, recovery 4330 * will merely complain about releasing a free block, 4331 * rather than leaking blocks. 4332 */ 4333 if (ext4_handle_is_aborted(handle)) 4334 return; 4335 if (try_to_extend_transaction(handle, inode)) { 4336 ext4_mark_inode_dirty(handle, inode); 4337 ext4_truncate_restart_trans(handle, inode, 4338 blocks_for_truncate(inode)); 4339 } 4340 4341 /* 4342 * The forget flag here is critical because if 4343 * we are journaling (and not doing data 4344 * journaling), we have to make sure a revoke 4345 * record is written to prevent the journal 4346 * replay from overwriting the (former) 4347 * indirect block if it gets reallocated as a 4348 * data block. This must happen in the same 4349 * transaction where the data blocks are 4350 * actually freed. 4351 */ 4352 ext4_free_blocks(handle, inode, NULL, nr, 1, 4353 EXT4_FREE_BLOCKS_METADATA| 4354 EXT4_FREE_BLOCKS_FORGET); 4355 4356 if (parent_bh) { 4357 /* 4358 * The block which we have just freed is 4359 * pointed to by an indirect block: journal it 4360 */ 4361 BUFFER_TRACE(parent_bh, "get_write_access"); 4362 if (!ext4_journal_get_write_access(handle, 4363 parent_bh)){ 4364 *p = 0; 4365 BUFFER_TRACE(parent_bh, 4366 "call ext4_handle_dirty_metadata"); 4367 ext4_handle_dirty_metadata(handle, 4368 inode, 4369 parent_bh); 4370 } 4371 } 4372 } 4373 } else { 4374 /* We have reached the bottom of the tree. */ 4375 BUFFER_TRACE(parent_bh, "free data blocks"); 4376 ext4_free_data(handle, inode, parent_bh, first, last); 4377 } 4378 } 4379 4380 int ext4_can_truncate(struct inode *inode) 4381 { 4382 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 4383 return 0; 4384 if (S_ISREG(inode->i_mode)) 4385 return 1; 4386 if (S_ISDIR(inode->i_mode)) 4387 return 1; 4388 if (S_ISLNK(inode->i_mode)) 4389 return !ext4_inode_is_fast_symlink(inode); 4390 return 0; 4391 } 4392 4393 /* 4394 * ext4_truncate() 4395 * 4396 * We block out ext4_get_block() block instantiations across the entire 4397 * transaction, and VFS/VM ensures that ext4_truncate() cannot run 4398 * simultaneously on behalf of the same inode. 4399 * 4400 * As we work through the truncate and commmit bits of it to the journal there 4401 * is one core, guiding principle: the file's tree must always be consistent on 4402 * disk. We must be able to restart the truncate after a crash. 4403 * 4404 * The file's tree may be transiently inconsistent in memory (although it 4405 * probably isn't), but whenever we close off and commit a journal transaction, 4406 * the contents of (the filesystem + the journal) must be consistent and 4407 * restartable. It's pretty simple, really: bottom up, right to left (although 4408 * left-to-right works OK too). 4409 * 4410 * Note that at recovery time, journal replay occurs *before* the restart of 4411 * truncate against the orphan inode list. 4412 * 4413 * The committed inode has the new, desired i_size (which is the same as 4414 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see 4415 * that this inode's truncate did not complete and it will again call 4416 * ext4_truncate() to have another go. So there will be instantiated blocks 4417 * to the right of the truncation point in a crashed ext4 filesystem. But 4418 * that's fine - as long as they are linked from the inode, the post-crash 4419 * ext4_truncate() run will find them and release them. 4420 */ 4421 void ext4_truncate(struct inode *inode) 4422 { 4423 handle_t *handle; 4424 struct ext4_inode_info *ei = EXT4_I(inode); 4425 __le32 *i_data = ei->i_data; 4426 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); 4427 struct address_space *mapping = inode->i_mapping; 4428 ext4_lblk_t offsets[4]; 4429 Indirect chain[4]; 4430 Indirect *partial; 4431 __le32 nr = 0; 4432 int n; 4433 ext4_lblk_t last_block; 4434 unsigned blocksize = inode->i_sb->s_blocksize; 4435 4436 trace_ext4_truncate_enter(inode); 4437 4438 if (!ext4_can_truncate(inode)) 4439 return; 4440 4441 ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS); 4442 4443 if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC)) 4444 ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE); 4445 4446 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 4447 ext4_ext_truncate(inode); 4448 trace_ext4_truncate_exit(inode); 4449 return; 4450 } 4451 4452 handle = start_transaction(inode); 4453 if (IS_ERR(handle)) 4454 return; /* AKPM: return what? */ 4455 4456 last_block = (inode->i_size + blocksize-1) 4457 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); 4458 4459 if (inode->i_size & (blocksize - 1)) 4460 if (ext4_block_truncate_page(handle, mapping, inode->i_size)) 4461 goto out_stop; 4462 4463 n = ext4_block_to_path(inode, last_block, offsets, NULL); 4464 if (n == 0) 4465 goto out_stop; /* error */ 4466 4467 /* 4468 * OK. This truncate is going to happen. We add the inode to the 4469 * orphan list, so that if this truncate spans multiple transactions, 4470 * and we crash, we will resume the truncate when the filesystem 4471 * recovers. It also marks the inode dirty, to catch the new size. 4472 * 4473 * Implication: the file must always be in a sane, consistent 4474 * truncatable state while each transaction commits. 4475 */ 4476 if (ext4_orphan_add(handle, inode)) 4477 goto out_stop; 4478 4479 /* 4480 * From here we block out all ext4_get_block() callers who want to 4481 * modify the block allocation tree. 4482 */ 4483 down_write(&ei->i_data_sem); 4484 4485 ext4_discard_preallocations(inode); 4486 4487 /* 4488 * The orphan list entry will now protect us from any crash which 4489 * occurs before the truncate completes, so it is now safe to propagate 4490 * the new, shorter inode size (held for now in i_size) into the 4491 * on-disk inode. We do this via i_disksize, which is the value which 4492 * ext4 *really* writes onto the disk inode. 4493 */ 4494 ei->i_disksize = inode->i_size; 4495 4496 if (n == 1) { /* direct blocks */ 4497 ext4_free_data(handle, inode, NULL, i_data+offsets[0], 4498 i_data + EXT4_NDIR_BLOCKS); 4499 goto do_indirects; 4500 } 4501 4502 partial = ext4_find_shared(inode, n, offsets, chain, &nr); 4503 /* Kill the top of shared branch (not detached) */ 4504 if (nr) { 4505 if (partial == chain) { 4506 /* Shared branch grows from the inode */ 4507 ext4_free_branches(handle, inode, NULL, 4508 &nr, &nr+1, (chain+n-1) - partial); 4509 *partial->p = 0; 4510 /* 4511 * We mark the inode dirty prior to restart, 4512 * and prior to stop. No need for it here. 4513 */ 4514 } else { 4515 /* Shared branch grows from an indirect block */ 4516 BUFFER_TRACE(partial->bh, "get_write_access"); 4517 ext4_free_branches(handle, inode, partial->bh, 4518 partial->p, 4519 partial->p+1, (chain+n-1) - partial); 4520 } 4521 } 4522 /* Clear the ends of indirect blocks on the shared branch */ 4523 while (partial > chain) { 4524 ext4_free_branches(handle, inode, partial->bh, partial->p + 1, 4525 (__le32*)partial->bh->b_data+addr_per_block, 4526 (chain+n-1) - partial); 4527 BUFFER_TRACE(partial->bh, "call brelse"); 4528 brelse(partial->bh); 4529 partial--; 4530 } 4531 do_indirects: 4532 /* Kill the remaining (whole) subtrees */ 4533 switch (offsets[0]) { 4534 default: 4535 nr = i_data[EXT4_IND_BLOCK]; 4536 if (nr) { 4537 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 1); 4538 i_data[EXT4_IND_BLOCK] = 0; 4539 } 4540 case EXT4_IND_BLOCK: 4541 nr = i_data[EXT4_DIND_BLOCK]; 4542 if (nr) { 4543 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 2); 4544 i_data[EXT4_DIND_BLOCK] = 0; 4545 } 4546 case EXT4_DIND_BLOCK: 4547 nr = i_data[EXT4_TIND_BLOCK]; 4548 if (nr) { 4549 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 3); 4550 i_data[EXT4_TIND_BLOCK] = 0; 4551 } 4552 case EXT4_TIND_BLOCK: 4553 ; 4554 } 4555 4556 up_write(&ei->i_data_sem); 4557 inode->i_mtime = inode->i_ctime = ext4_current_time(inode); 4558 ext4_mark_inode_dirty(handle, inode); 4559 4560 /* 4561 * In a multi-transaction truncate, we only make the final transaction 4562 * synchronous 4563 */ 4564 if (IS_SYNC(inode)) 4565 ext4_handle_sync(handle); 4566 out_stop: 4567 /* 4568 * If this was a simple ftruncate(), and the file will remain alive 4569 * then we need to clear up the orphan record which we created above. 4570 * However, if this was a real unlink then we were called by 4571 * ext4_delete_inode(), and we allow that function to clean up the 4572 * orphan info for us. 4573 */ 4574 if (inode->i_nlink) 4575 ext4_orphan_del(handle, inode); 4576 4577 ext4_journal_stop(handle); 4578 trace_ext4_truncate_exit(inode); 4579 } 4580 4581 /* 4582 * ext4_get_inode_loc returns with an extra refcount against the inode's 4583 * underlying buffer_head on success. If 'in_mem' is true, we have all 4584 * data in memory that is needed to recreate the on-disk version of this 4585 * inode. 4586 */ 4587 static int __ext4_get_inode_loc(struct inode *inode, 4588 struct ext4_iloc *iloc, int in_mem) 4589 { 4590 struct ext4_group_desc *gdp; 4591 struct buffer_head *bh; 4592 struct super_block *sb = inode->i_sb; 4593 ext4_fsblk_t block; 4594 int inodes_per_block, inode_offset; 4595 4596 iloc->bh = NULL; 4597 if (!ext4_valid_inum(sb, inode->i_ino)) 4598 return -EIO; 4599 4600 iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb); 4601 gdp = ext4_get_group_desc(sb, iloc->block_group, NULL); 4602 if (!gdp) 4603 return -EIO; 4604 4605 /* 4606 * Figure out the offset within the block group inode table 4607 */ 4608 inodes_per_block = (EXT4_BLOCK_SIZE(sb) / EXT4_INODE_SIZE(sb)); 4609 inode_offset = ((inode->i_ino - 1) % 4610 EXT4_INODES_PER_GROUP(sb)); 4611 block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block); 4612 iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb); 4613 4614 bh = sb_getblk(sb, block); 4615 if (!bh) { 4616 EXT4_ERROR_INODE_BLOCK(inode, block, 4617 "unable to read itable block"); 4618 return -EIO; 4619 } 4620 if (!buffer_uptodate(bh)) { 4621 lock_buffer(bh); 4622 4623 /* 4624 * If the buffer has the write error flag, we have failed 4625 * to write out another inode in the same block. In this 4626 * case, we don't have to read the block because we may 4627 * read the old inode data successfully. 4628 */ 4629 if (buffer_write_io_error(bh) && !buffer_uptodate(bh)) 4630 set_buffer_uptodate(bh); 4631 4632 if (buffer_uptodate(bh)) { 4633 /* someone brought it uptodate while we waited */ 4634 unlock_buffer(bh); 4635 goto has_buffer; 4636 } 4637 4638 /* 4639 * If we have all information of the inode in memory and this 4640 * is the only valid inode in the block, we need not read the 4641 * block. 4642 */ 4643 if (in_mem) { 4644 struct buffer_head *bitmap_bh; 4645 int i, start; 4646 4647 start = inode_offset & ~(inodes_per_block - 1); 4648 4649 /* Is the inode bitmap in cache? */ 4650 bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp)); 4651 if (!bitmap_bh) 4652 goto make_io; 4653 4654 /* 4655 * If the inode bitmap isn't in cache then the 4656 * optimisation may end up performing two reads instead 4657 * of one, so skip it. 4658 */ 4659 if (!buffer_uptodate(bitmap_bh)) { 4660 brelse(bitmap_bh); 4661 goto make_io; 4662 } 4663 for (i = start; i < start + inodes_per_block; i++) { 4664 if (i == inode_offset) 4665 continue; 4666 if (ext4_test_bit(i, bitmap_bh->b_data)) 4667 break; 4668 } 4669 brelse(bitmap_bh); 4670 if (i == start + inodes_per_block) { 4671 /* all other inodes are free, so skip I/O */ 4672 memset(bh->b_data, 0, bh->b_size); 4673 set_buffer_uptodate(bh); 4674 unlock_buffer(bh); 4675 goto has_buffer; 4676 } 4677 } 4678 4679 make_io: 4680 /* 4681 * If we need to do any I/O, try to pre-readahead extra 4682 * blocks from the inode table. 4683 */ 4684 if (EXT4_SB(sb)->s_inode_readahead_blks) { 4685 ext4_fsblk_t b, end, table; 4686 unsigned num; 4687 4688 table = ext4_inode_table(sb, gdp); 4689 /* s_inode_readahead_blks is always a power of 2 */ 4690 b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1); 4691 if (table > b) 4692 b = table; 4693 end = b + EXT4_SB(sb)->s_inode_readahead_blks; 4694 num = EXT4_INODES_PER_GROUP(sb); 4695 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 4696 EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) 4697 num -= ext4_itable_unused_count(sb, gdp); 4698 table += num / inodes_per_block; 4699 if (end > table) 4700 end = table; 4701 while (b <= end) 4702 sb_breadahead(sb, b++); 4703 } 4704 4705 /* 4706 * There are other valid inodes in the buffer, this inode 4707 * has in-inode xattrs, or we don't have this inode in memory. 4708 * Read the block from disk. 4709 */ 4710 trace_ext4_load_inode(inode); 4711 get_bh(bh); 4712 bh->b_end_io = end_buffer_read_sync; 4713 submit_bh(READ_META, bh); 4714 wait_on_buffer(bh); 4715 if (!buffer_uptodate(bh)) { 4716 EXT4_ERROR_INODE_BLOCK(inode, block, 4717 "unable to read itable block"); 4718 brelse(bh); 4719 return -EIO; 4720 } 4721 } 4722 has_buffer: 4723 iloc->bh = bh; 4724 return 0; 4725 } 4726 4727 int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc) 4728 { 4729 /* We have all inode data except xattrs in memory here. */ 4730 return __ext4_get_inode_loc(inode, iloc, 4731 !ext4_test_inode_state(inode, EXT4_STATE_XATTR)); 4732 } 4733 4734 void ext4_set_inode_flags(struct inode *inode) 4735 { 4736 unsigned int flags = EXT4_I(inode)->i_flags; 4737 4738 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC); 4739 if (flags & EXT4_SYNC_FL) 4740 inode->i_flags |= S_SYNC; 4741 if (flags & EXT4_APPEND_FL) 4742 inode->i_flags |= S_APPEND; 4743 if (flags & EXT4_IMMUTABLE_FL) 4744 inode->i_flags |= S_IMMUTABLE; 4745 if (flags & EXT4_NOATIME_FL) 4746 inode->i_flags |= S_NOATIME; 4747 if (flags & EXT4_DIRSYNC_FL) 4748 inode->i_flags |= S_DIRSYNC; 4749 } 4750 4751 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */ 4752 void ext4_get_inode_flags(struct ext4_inode_info *ei) 4753 { 4754 unsigned int vfs_fl; 4755 unsigned long old_fl, new_fl; 4756 4757 do { 4758 vfs_fl = ei->vfs_inode.i_flags; 4759 old_fl = ei->i_flags; 4760 new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL| 4761 EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL| 4762 EXT4_DIRSYNC_FL); 4763 if (vfs_fl & S_SYNC) 4764 new_fl |= EXT4_SYNC_FL; 4765 if (vfs_fl & S_APPEND) 4766 new_fl |= EXT4_APPEND_FL; 4767 if (vfs_fl & S_IMMUTABLE) 4768 new_fl |= EXT4_IMMUTABLE_FL; 4769 if (vfs_fl & S_NOATIME) 4770 new_fl |= EXT4_NOATIME_FL; 4771 if (vfs_fl & S_DIRSYNC) 4772 new_fl |= EXT4_DIRSYNC_FL; 4773 } while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl); 4774 } 4775 4776 static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode, 4777 struct ext4_inode_info *ei) 4778 { 4779 blkcnt_t i_blocks ; 4780 struct inode *inode = &(ei->vfs_inode); 4781 struct super_block *sb = inode->i_sb; 4782 4783 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 4784 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) { 4785 /* we are using combined 48 bit field */ 4786 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 | 4787 le32_to_cpu(raw_inode->i_blocks_lo); 4788 if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) { 4789 /* i_blocks represent file system block size */ 4790 return i_blocks << (inode->i_blkbits - 9); 4791 } else { 4792 return i_blocks; 4793 } 4794 } else { 4795 return le32_to_cpu(raw_inode->i_blocks_lo); 4796 } 4797 } 4798 4799 struct inode *ext4_iget(struct super_block *sb, unsigned long ino) 4800 { 4801 struct ext4_iloc iloc; 4802 struct ext4_inode *raw_inode; 4803 struct ext4_inode_info *ei; 4804 struct inode *inode; 4805 journal_t *journal = EXT4_SB(sb)->s_journal; 4806 long ret; 4807 int block; 4808 4809 inode = iget_locked(sb, ino); 4810 if (!inode) 4811 return ERR_PTR(-ENOMEM); 4812 if (!(inode->i_state & I_NEW)) 4813 return inode; 4814 4815 ei = EXT4_I(inode); 4816 iloc.bh = NULL; 4817 4818 ret = __ext4_get_inode_loc(inode, &iloc, 0); 4819 if (ret < 0) 4820 goto bad_inode; 4821 raw_inode = ext4_raw_inode(&iloc); 4822 inode->i_mode = le16_to_cpu(raw_inode->i_mode); 4823 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low); 4824 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low); 4825 if (!(test_opt(inode->i_sb, NO_UID32))) { 4826 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16; 4827 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16; 4828 } 4829 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count); 4830 4831 ext4_clear_state_flags(ei); /* Only relevant on 32-bit archs */ 4832 ei->i_dir_start_lookup = 0; 4833 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime); 4834 /* We now have enough fields to check if the inode was active or not. 4835 * This is needed because nfsd might try to access dead inodes 4836 * the test is that same one that e2fsck uses 4837 * NeilBrown 1999oct15 4838 */ 4839 if (inode->i_nlink == 0) { 4840 if (inode->i_mode == 0 || 4841 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) { 4842 /* this inode is deleted */ 4843 ret = -ESTALE; 4844 goto bad_inode; 4845 } 4846 /* The only unlinked inodes we let through here have 4847 * valid i_mode and are being read by the orphan 4848 * recovery code: that's fine, we're about to complete 4849 * the process of deleting those. */ 4850 } 4851 ei->i_flags = le32_to_cpu(raw_inode->i_flags); 4852 inode->i_blocks = ext4_inode_blocks(raw_inode, ei); 4853 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo); 4854 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) 4855 ei->i_file_acl |= 4856 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32; 4857 inode->i_size = ext4_isize(raw_inode); 4858 ei->i_disksize = inode->i_size; 4859 #ifdef CONFIG_QUOTA 4860 ei->i_reserved_quota = 0; 4861 #endif 4862 inode->i_generation = le32_to_cpu(raw_inode->i_generation); 4863 ei->i_block_group = iloc.block_group; 4864 ei->i_last_alloc_group = ~0; 4865 /* 4866 * NOTE! The in-memory inode i_data array is in little-endian order 4867 * even on big-endian machines: we do NOT byteswap the block numbers! 4868 */ 4869 for (block = 0; block < EXT4_N_BLOCKS; block++) 4870 ei->i_data[block] = raw_inode->i_block[block]; 4871 INIT_LIST_HEAD(&ei->i_orphan); 4872 4873 /* 4874 * Set transaction id's of transactions that have to be committed 4875 * to finish f[data]sync. We set them to currently running transaction 4876 * as we cannot be sure that the inode or some of its metadata isn't 4877 * part of the transaction - the inode could have been reclaimed and 4878 * now it is reread from disk. 4879 */ 4880 if (journal) { 4881 transaction_t *transaction; 4882 tid_t tid; 4883 4884 read_lock(&journal->j_state_lock); 4885 if (journal->j_running_transaction) 4886 transaction = journal->j_running_transaction; 4887 else 4888 transaction = journal->j_committing_transaction; 4889 if (transaction) 4890 tid = transaction->t_tid; 4891 else 4892 tid = journal->j_commit_sequence; 4893 read_unlock(&journal->j_state_lock); 4894 ei->i_sync_tid = tid; 4895 ei->i_datasync_tid = tid; 4896 } 4897 4898 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { 4899 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize); 4900 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize > 4901 EXT4_INODE_SIZE(inode->i_sb)) { 4902 ret = -EIO; 4903 goto bad_inode; 4904 } 4905 if (ei->i_extra_isize == 0) { 4906 /* The extra space is currently unused. Use it. */ 4907 ei->i_extra_isize = sizeof(struct ext4_inode) - 4908 EXT4_GOOD_OLD_INODE_SIZE; 4909 } else { 4910 __le32 *magic = (void *)raw_inode + 4911 EXT4_GOOD_OLD_INODE_SIZE + 4912 ei->i_extra_isize; 4913 if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) 4914 ext4_set_inode_state(inode, EXT4_STATE_XATTR); 4915 } 4916 } else 4917 ei->i_extra_isize = 0; 4918 4919 EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode); 4920 EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode); 4921 EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode); 4922 EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode); 4923 4924 inode->i_version = le32_to_cpu(raw_inode->i_disk_version); 4925 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { 4926 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi)) 4927 inode->i_version |= 4928 (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32; 4929 } 4930 4931 ret = 0; 4932 if (ei->i_file_acl && 4933 !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) { 4934 EXT4_ERROR_INODE(inode, "bad extended attribute block %llu", 4935 ei->i_file_acl); 4936 ret = -EIO; 4937 goto bad_inode; 4938 } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 4939 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 4940 (S_ISLNK(inode->i_mode) && 4941 !ext4_inode_is_fast_symlink(inode))) 4942 /* Validate extent which is part of inode */ 4943 ret = ext4_ext_check_inode(inode); 4944 } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 4945 (S_ISLNK(inode->i_mode) && 4946 !ext4_inode_is_fast_symlink(inode))) { 4947 /* Validate block references which are part of inode */ 4948 ret = ext4_check_inode_blockref(inode); 4949 } 4950 if (ret) 4951 goto bad_inode; 4952 4953 if (S_ISREG(inode->i_mode)) { 4954 inode->i_op = &ext4_file_inode_operations; 4955 inode->i_fop = &ext4_file_operations; 4956 ext4_set_aops(inode); 4957 } else if (S_ISDIR(inode->i_mode)) { 4958 inode->i_op = &ext4_dir_inode_operations; 4959 inode->i_fop = &ext4_dir_operations; 4960 } else if (S_ISLNK(inode->i_mode)) { 4961 if (ext4_inode_is_fast_symlink(inode)) { 4962 inode->i_op = &ext4_fast_symlink_inode_operations; 4963 nd_terminate_link(ei->i_data, inode->i_size, 4964 sizeof(ei->i_data) - 1); 4965 } else { 4966 inode->i_op = &ext4_symlink_inode_operations; 4967 ext4_set_aops(inode); 4968 } 4969 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 4970 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 4971 inode->i_op = &ext4_special_inode_operations; 4972 if (raw_inode->i_block[0]) 4973 init_special_inode(inode, inode->i_mode, 4974 old_decode_dev(le32_to_cpu(raw_inode->i_block[0]))); 4975 else 4976 init_special_inode(inode, inode->i_mode, 4977 new_decode_dev(le32_to_cpu(raw_inode->i_block[1]))); 4978 } else { 4979 ret = -EIO; 4980 EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode); 4981 goto bad_inode; 4982 } 4983 brelse(iloc.bh); 4984 ext4_set_inode_flags(inode); 4985 unlock_new_inode(inode); 4986 return inode; 4987 4988 bad_inode: 4989 brelse(iloc.bh); 4990 iget_failed(inode); 4991 return ERR_PTR(ret); 4992 } 4993 4994 static int ext4_inode_blocks_set(handle_t *handle, 4995 struct ext4_inode *raw_inode, 4996 struct ext4_inode_info *ei) 4997 { 4998 struct inode *inode = &(ei->vfs_inode); 4999 u64 i_blocks = inode->i_blocks; 5000 struct super_block *sb = inode->i_sb; 5001 5002 if (i_blocks <= ~0U) { 5003 /* 5004 * i_blocks can be represnted in a 32 bit variable 5005 * as multiple of 512 bytes 5006 */ 5007 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks); 5008 raw_inode->i_blocks_high = 0; 5009 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE); 5010 return 0; 5011 } 5012 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) 5013 return -EFBIG; 5014 5015 if (i_blocks <= 0xffffffffffffULL) { 5016 /* 5017 * i_blocks can be represented in a 48 bit variable 5018 * as multiple of 512 bytes 5019 */ 5020 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks); 5021 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32); 5022 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE); 5023 } else { 5024 ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE); 5025 /* i_block is stored in file system block size */ 5026 i_blocks = i_blocks >> (inode->i_blkbits - 9); 5027 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks); 5028 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32); 5029 } 5030 return 0; 5031 } 5032 5033 /* 5034 * Post the struct inode info into an on-disk inode location in the 5035 * buffer-cache. This gobbles the caller's reference to the 5036 * buffer_head in the inode location struct. 5037 * 5038 * The caller must have write access to iloc->bh. 5039 */ 5040 static int ext4_do_update_inode(handle_t *handle, 5041 struct inode *inode, 5042 struct ext4_iloc *iloc) 5043 { 5044 struct ext4_inode *raw_inode = ext4_raw_inode(iloc); 5045 struct ext4_inode_info *ei = EXT4_I(inode); 5046 struct buffer_head *bh = iloc->bh; 5047 int err = 0, rc, block; 5048 5049 /* For fields not not tracking in the in-memory inode, 5050 * initialise them to zero for new inodes. */ 5051 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) 5052 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); 5053 5054 ext4_get_inode_flags(ei); 5055 raw_inode->i_mode = cpu_to_le16(inode->i_mode); 5056 if (!(test_opt(inode->i_sb, NO_UID32))) { 5057 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid)); 5058 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid)); 5059 /* 5060 * Fix up interoperability with old kernels. Otherwise, old inodes get 5061 * re-used with the upper 16 bits of the uid/gid intact 5062 */ 5063 if (!ei->i_dtime) { 5064 raw_inode->i_uid_high = 5065 cpu_to_le16(high_16_bits(inode->i_uid)); 5066 raw_inode->i_gid_high = 5067 cpu_to_le16(high_16_bits(inode->i_gid)); 5068 } else { 5069 raw_inode->i_uid_high = 0; 5070 raw_inode->i_gid_high = 0; 5071 } 5072 } else { 5073 raw_inode->i_uid_low = 5074 cpu_to_le16(fs_high2lowuid(inode->i_uid)); 5075 raw_inode->i_gid_low = 5076 cpu_to_le16(fs_high2lowgid(inode->i_gid)); 5077 raw_inode->i_uid_high = 0; 5078 raw_inode->i_gid_high = 0; 5079 } 5080 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); 5081 5082 EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode); 5083 EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode); 5084 EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode); 5085 EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode); 5086 5087 if (ext4_inode_blocks_set(handle, raw_inode, ei)) 5088 goto out_brelse; 5089 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime); 5090 raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF); 5091 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != 5092 cpu_to_le32(EXT4_OS_HURD)) 5093 raw_inode->i_file_acl_high = 5094 cpu_to_le16(ei->i_file_acl >> 32); 5095 raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl); 5096 ext4_isize_set(raw_inode, ei->i_disksize); 5097 if (ei->i_disksize > 0x7fffffffULL) { 5098 struct super_block *sb = inode->i_sb; 5099 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 5100 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) || 5101 EXT4_SB(sb)->s_es->s_rev_level == 5102 cpu_to_le32(EXT4_GOOD_OLD_REV)) { 5103 /* If this is the first large file 5104 * created, add a flag to the superblock. 5105 */ 5106 err = ext4_journal_get_write_access(handle, 5107 EXT4_SB(sb)->s_sbh); 5108 if (err) 5109 goto out_brelse; 5110 ext4_update_dynamic_rev(sb); 5111 EXT4_SET_RO_COMPAT_FEATURE(sb, 5112 EXT4_FEATURE_RO_COMPAT_LARGE_FILE); 5113 sb->s_dirt = 1; 5114 ext4_handle_sync(handle); 5115 err = ext4_handle_dirty_metadata(handle, NULL, 5116 EXT4_SB(sb)->s_sbh); 5117 } 5118 } 5119 raw_inode->i_generation = cpu_to_le32(inode->i_generation); 5120 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 5121 if (old_valid_dev(inode->i_rdev)) { 5122 raw_inode->i_block[0] = 5123 cpu_to_le32(old_encode_dev(inode->i_rdev)); 5124 raw_inode->i_block[1] = 0; 5125 } else { 5126 raw_inode->i_block[0] = 0; 5127 raw_inode->i_block[1] = 5128 cpu_to_le32(new_encode_dev(inode->i_rdev)); 5129 raw_inode->i_block[2] = 0; 5130 } 5131 } else 5132 for (block = 0; block < EXT4_N_BLOCKS; block++) 5133 raw_inode->i_block[block] = ei->i_data[block]; 5134 5135 raw_inode->i_disk_version = cpu_to_le32(inode->i_version); 5136 if (ei->i_extra_isize) { 5137 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi)) 5138 raw_inode->i_version_hi = 5139 cpu_to_le32(inode->i_version >> 32); 5140 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize); 5141 } 5142 5143 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); 5144 rc = ext4_handle_dirty_metadata(handle, NULL, bh); 5145 if (!err) 5146 err = rc; 5147 ext4_clear_inode_state(inode, EXT4_STATE_NEW); 5148 5149 ext4_update_inode_fsync_trans(handle, inode, 0); 5150 out_brelse: 5151 brelse(bh); 5152 ext4_std_error(inode->i_sb, err); 5153 return err; 5154 } 5155 5156 /* 5157 * ext4_write_inode() 5158 * 5159 * We are called from a few places: 5160 * 5161 * - Within generic_file_write() for O_SYNC files. 5162 * Here, there will be no transaction running. We wait for any running 5163 * trasnaction to commit. 5164 * 5165 * - Within sys_sync(), kupdate and such. 5166 * We wait on commit, if tol to. 5167 * 5168 * - Within prune_icache() (PF_MEMALLOC == true) 5169 * Here we simply return. We can't afford to block kswapd on the 5170 * journal commit. 5171 * 5172 * In all cases it is actually safe for us to return without doing anything, 5173 * because the inode has been copied into a raw inode buffer in 5174 * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for 5175 * knfsd. 5176 * 5177 * Note that we are absolutely dependent upon all inode dirtiers doing the 5178 * right thing: they *must* call mark_inode_dirty() after dirtying info in 5179 * which we are interested. 5180 * 5181 * It would be a bug for them to not do this. The code: 5182 * 5183 * mark_inode_dirty(inode) 5184 * stuff(); 5185 * inode->i_size = expr; 5186 * 5187 * is in error because a kswapd-driven write_inode() could occur while 5188 * `stuff()' is running, and the new i_size will be lost. Plus the inode 5189 * will no longer be on the superblock's dirty inode list. 5190 */ 5191 int ext4_write_inode(struct inode *inode, struct writeback_control *wbc) 5192 { 5193 int err; 5194 5195 if (current->flags & PF_MEMALLOC) 5196 return 0; 5197 5198 if (EXT4_SB(inode->i_sb)->s_journal) { 5199 if (ext4_journal_current_handle()) { 5200 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n"); 5201 dump_stack(); 5202 return -EIO; 5203 } 5204 5205 if (wbc->sync_mode != WB_SYNC_ALL) 5206 return 0; 5207 5208 err = ext4_force_commit(inode->i_sb); 5209 } else { 5210 struct ext4_iloc iloc; 5211 5212 err = __ext4_get_inode_loc(inode, &iloc, 0); 5213 if (err) 5214 return err; 5215 if (wbc->sync_mode == WB_SYNC_ALL) 5216 sync_dirty_buffer(iloc.bh); 5217 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) { 5218 EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr, 5219 "IO error syncing inode"); 5220 err = -EIO; 5221 } 5222 brelse(iloc.bh); 5223 } 5224 return err; 5225 } 5226 5227 /* 5228 * ext4_setattr() 5229 * 5230 * Called from notify_change. 5231 * 5232 * We want to trap VFS attempts to truncate the file as soon as 5233 * possible. In particular, we want to make sure that when the VFS 5234 * shrinks i_size, we put the inode on the orphan list and modify 5235 * i_disksize immediately, so that during the subsequent flushing of 5236 * dirty pages and freeing of disk blocks, we can guarantee that any 5237 * commit will leave the blocks being flushed in an unused state on 5238 * disk. (On recovery, the inode will get truncated and the blocks will 5239 * be freed, so we have a strong guarantee that no future commit will 5240 * leave these blocks visible to the user.) 5241 * 5242 * Another thing we have to assure is that if we are in ordered mode 5243 * and inode is still attached to the committing transaction, we must 5244 * we start writeout of all the dirty pages which are being truncated. 5245 * This way we are sure that all the data written in the previous 5246 * transaction are already on disk (truncate waits for pages under 5247 * writeback). 5248 * 5249 * Called with inode->i_mutex down. 5250 */ 5251 int ext4_setattr(struct dentry *dentry, struct iattr *attr) 5252 { 5253 struct inode *inode = dentry->d_inode; 5254 int error, rc = 0; 5255 int orphan = 0; 5256 const unsigned int ia_valid = attr->ia_valid; 5257 5258 error = inode_change_ok(inode, attr); 5259 if (error) 5260 return error; 5261 5262 if (is_quota_modification(inode, attr)) 5263 dquot_initialize(inode); 5264 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) || 5265 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) { 5266 handle_t *handle; 5267 5268 /* (user+group)*(old+new) structure, inode write (sb, 5269 * inode block, ? - but truncate inode update has it) */ 5270 handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+ 5271 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3); 5272 if (IS_ERR(handle)) { 5273 error = PTR_ERR(handle); 5274 goto err_out; 5275 } 5276 error = dquot_transfer(inode, attr); 5277 if (error) { 5278 ext4_journal_stop(handle); 5279 return error; 5280 } 5281 /* Update corresponding info in inode so that everything is in 5282 * one transaction */ 5283 if (attr->ia_valid & ATTR_UID) 5284 inode->i_uid = attr->ia_uid; 5285 if (attr->ia_valid & ATTR_GID) 5286 inode->i_gid = attr->ia_gid; 5287 error = ext4_mark_inode_dirty(handle, inode); 5288 ext4_journal_stop(handle); 5289 } 5290 5291 if (attr->ia_valid & ATTR_SIZE) { 5292 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { 5293 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 5294 5295 if (attr->ia_size > sbi->s_bitmap_maxbytes) 5296 return -EFBIG; 5297 } 5298 } 5299 5300 if (S_ISREG(inode->i_mode) && 5301 attr->ia_valid & ATTR_SIZE && 5302 (attr->ia_size < inode->i_size || 5303 (ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS)))) { 5304 handle_t *handle; 5305 5306 handle = ext4_journal_start(inode, 3); 5307 if (IS_ERR(handle)) { 5308 error = PTR_ERR(handle); 5309 goto err_out; 5310 } 5311 if (ext4_handle_valid(handle)) { 5312 error = ext4_orphan_add(handle, inode); 5313 orphan = 1; 5314 } 5315 EXT4_I(inode)->i_disksize = attr->ia_size; 5316 rc = ext4_mark_inode_dirty(handle, inode); 5317 if (!error) 5318 error = rc; 5319 ext4_journal_stop(handle); 5320 5321 if (ext4_should_order_data(inode)) { 5322 error = ext4_begin_ordered_truncate(inode, 5323 attr->ia_size); 5324 if (error) { 5325 /* Do as much error cleanup as possible */ 5326 handle = ext4_journal_start(inode, 3); 5327 if (IS_ERR(handle)) { 5328 ext4_orphan_del(NULL, inode); 5329 goto err_out; 5330 } 5331 ext4_orphan_del(handle, inode); 5332 orphan = 0; 5333 ext4_journal_stop(handle); 5334 goto err_out; 5335 } 5336 } 5337 /* ext4_truncate will clear the flag */ 5338 if ((ext4_test_inode_flag(inode, EXT4_INODE_EOFBLOCKS))) 5339 ext4_truncate(inode); 5340 } 5341 5342 if ((attr->ia_valid & ATTR_SIZE) && 5343 attr->ia_size != i_size_read(inode)) 5344 rc = vmtruncate(inode, attr->ia_size); 5345 5346 if (!rc) { 5347 setattr_copy(inode, attr); 5348 mark_inode_dirty(inode); 5349 } 5350 5351 /* 5352 * If the call to ext4_truncate failed to get a transaction handle at 5353 * all, we need to clean up the in-core orphan list manually. 5354 */ 5355 if (orphan && inode->i_nlink) 5356 ext4_orphan_del(NULL, inode); 5357 5358 if (!rc && (ia_valid & ATTR_MODE)) 5359 rc = ext4_acl_chmod(inode); 5360 5361 err_out: 5362 ext4_std_error(inode->i_sb, error); 5363 if (!error) 5364 error = rc; 5365 return error; 5366 } 5367 5368 int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry, 5369 struct kstat *stat) 5370 { 5371 struct inode *inode; 5372 unsigned long delalloc_blocks; 5373 5374 inode = dentry->d_inode; 5375 generic_fillattr(inode, stat); 5376 5377 /* 5378 * We can't update i_blocks if the block allocation is delayed 5379 * otherwise in the case of system crash before the real block 5380 * allocation is done, we will have i_blocks inconsistent with 5381 * on-disk file blocks. 5382 * We always keep i_blocks updated together with real 5383 * allocation. But to not confuse with user, stat 5384 * will return the blocks that include the delayed allocation 5385 * blocks for this file. 5386 */ 5387 delalloc_blocks = EXT4_I(inode)->i_reserved_data_blocks; 5388 5389 stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9; 5390 return 0; 5391 } 5392 5393 static int ext4_indirect_trans_blocks(struct inode *inode, int nrblocks, 5394 int chunk) 5395 { 5396 int indirects; 5397 5398 /* if nrblocks are contiguous */ 5399 if (chunk) { 5400 /* 5401 * With N contiguous data blocks, it need at most 5402 * N/EXT4_ADDR_PER_BLOCK(inode->i_sb) indirect blocks 5403 * 2 dindirect blocks 5404 * 1 tindirect block 5405 */ 5406 indirects = nrblocks / EXT4_ADDR_PER_BLOCK(inode->i_sb); 5407 return indirects + 3; 5408 } 5409 /* 5410 * if nrblocks are not contiguous, worse case, each block touch 5411 * a indirect block, and each indirect block touch a double indirect 5412 * block, plus a triple indirect block 5413 */ 5414 indirects = nrblocks * 2 + 1; 5415 return indirects; 5416 } 5417 5418 static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk) 5419 { 5420 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 5421 return ext4_indirect_trans_blocks(inode, nrblocks, chunk); 5422 return ext4_ext_index_trans_blocks(inode, nrblocks, chunk); 5423 } 5424 5425 /* 5426 * Account for index blocks, block groups bitmaps and block group 5427 * descriptor blocks if modify datablocks and index blocks 5428 * worse case, the indexs blocks spread over different block groups 5429 * 5430 * If datablocks are discontiguous, they are possible to spread over 5431 * different block groups too. If they are contiuguous, with flexbg, 5432 * they could still across block group boundary. 5433 * 5434 * Also account for superblock, inode, quota and xattr blocks 5435 */ 5436 static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk) 5437 { 5438 ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb); 5439 int gdpblocks; 5440 int idxblocks; 5441 int ret = 0; 5442 5443 /* 5444 * How many index blocks need to touch to modify nrblocks? 5445 * The "Chunk" flag indicating whether the nrblocks is 5446 * physically contiguous on disk 5447 * 5448 * For Direct IO and fallocate, they calls get_block to allocate 5449 * one single extent at a time, so they could set the "Chunk" flag 5450 */ 5451 idxblocks = ext4_index_trans_blocks(inode, nrblocks, chunk); 5452 5453 ret = idxblocks; 5454 5455 /* 5456 * Now let's see how many group bitmaps and group descriptors need 5457 * to account 5458 */ 5459 groups = idxblocks; 5460 if (chunk) 5461 groups += 1; 5462 else 5463 groups += nrblocks; 5464 5465 gdpblocks = groups; 5466 if (groups > ngroups) 5467 groups = ngroups; 5468 if (groups > EXT4_SB(inode->i_sb)->s_gdb_count) 5469 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count; 5470 5471 /* bitmaps and block group descriptor blocks */ 5472 ret += groups + gdpblocks; 5473 5474 /* Blocks for super block, inode, quota and xattr blocks */ 5475 ret += EXT4_META_TRANS_BLOCKS(inode->i_sb); 5476 5477 return ret; 5478 } 5479 5480 /* 5481 * Calulate the total number of credits to reserve to fit 5482 * the modification of a single pages into a single transaction, 5483 * which may include multiple chunks of block allocations. 5484 * 5485 * This could be called via ext4_write_begin() 5486 * 5487 * We need to consider the worse case, when 5488 * one new block per extent. 5489 */ 5490 int ext4_writepage_trans_blocks(struct inode *inode) 5491 { 5492 int bpp = ext4_journal_blocks_per_page(inode); 5493 int ret; 5494 5495 ret = ext4_meta_trans_blocks(inode, bpp, 0); 5496 5497 /* Account for data blocks for journalled mode */ 5498 if (ext4_should_journal_data(inode)) 5499 ret += bpp; 5500 return ret; 5501 } 5502 5503 /* 5504 * Calculate the journal credits for a chunk of data modification. 5505 * 5506 * This is called from DIO, fallocate or whoever calling 5507 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks. 5508 * 5509 * journal buffers for data blocks are not included here, as DIO 5510 * and fallocate do no need to journal data buffers. 5511 */ 5512 int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks) 5513 { 5514 return ext4_meta_trans_blocks(inode, nrblocks, 1); 5515 } 5516 5517 /* 5518 * The caller must have previously called ext4_reserve_inode_write(). 5519 * Give this, we know that the caller already has write access to iloc->bh. 5520 */ 5521 int ext4_mark_iloc_dirty(handle_t *handle, 5522 struct inode *inode, struct ext4_iloc *iloc) 5523 { 5524 int err = 0; 5525 5526 if (test_opt(inode->i_sb, I_VERSION)) 5527 inode_inc_iversion(inode); 5528 5529 /* the do_update_inode consumes one bh->b_count */ 5530 get_bh(iloc->bh); 5531 5532 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */ 5533 err = ext4_do_update_inode(handle, inode, iloc); 5534 put_bh(iloc->bh); 5535 return err; 5536 } 5537 5538 /* 5539 * On success, We end up with an outstanding reference count against 5540 * iloc->bh. This _must_ be cleaned up later. 5541 */ 5542 5543 int 5544 ext4_reserve_inode_write(handle_t *handle, struct inode *inode, 5545 struct ext4_iloc *iloc) 5546 { 5547 int err; 5548 5549 err = ext4_get_inode_loc(inode, iloc); 5550 if (!err) { 5551 BUFFER_TRACE(iloc->bh, "get_write_access"); 5552 err = ext4_journal_get_write_access(handle, iloc->bh); 5553 if (err) { 5554 brelse(iloc->bh); 5555 iloc->bh = NULL; 5556 } 5557 } 5558 ext4_std_error(inode->i_sb, err); 5559 return err; 5560 } 5561 5562 /* 5563 * Expand an inode by new_extra_isize bytes. 5564 * Returns 0 on success or negative error number on failure. 5565 */ 5566 static int ext4_expand_extra_isize(struct inode *inode, 5567 unsigned int new_extra_isize, 5568 struct ext4_iloc iloc, 5569 handle_t *handle) 5570 { 5571 struct ext4_inode *raw_inode; 5572 struct ext4_xattr_ibody_header *header; 5573 5574 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) 5575 return 0; 5576 5577 raw_inode = ext4_raw_inode(&iloc); 5578 5579 header = IHDR(inode, raw_inode); 5580 5581 /* No extended attributes present */ 5582 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) || 5583 header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) { 5584 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0, 5585 new_extra_isize); 5586 EXT4_I(inode)->i_extra_isize = new_extra_isize; 5587 return 0; 5588 } 5589 5590 /* try to expand with EAs present */ 5591 return ext4_expand_extra_isize_ea(inode, new_extra_isize, 5592 raw_inode, handle); 5593 } 5594 5595 /* 5596 * What we do here is to mark the in-core inode as clean with respect to inode 5597 * dirtiness (it may still be data-dirty). 5598 * This means that the in-core inode may be reaped by prune_icache 5599 * without having to perform any I/O. This is a very good thing, 5600 * because *any* task may call prune_icache - even ones which 5601 * have a transaction open against a different journal. 5602 * 5603 * Is this cheating? Not really. Sure, we haven't written the 5604 * inode out, but prune_icache isn't a user-visible syncing function. 5605 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync) 5606 * we start and wait on commits. 5607 * 5608 * Is this efficient/effective? Well, we're being nice to the system 5609 * by cleaning up our inodes proactively so they can be reaped 5610 * without I/O. But we are potentially leaving up to five seconds' 5611 * worth of inodes floating about which prune_icache wants us to 5612 * write out. One way to fix that would be to get prune_icache() 5613 * to do a write_super() to free up some memory. It has the desired 5614 * effect. 5615 */ 5616 int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode) 5617 { 5618 struct ext4_iloc iloc; 5619 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 5620 static unsigned int mnt_count; 5621 int err, ret; 5622 5623 might_sleep(); 5624 trace_ext4_mark_inode_dirty(inode, _RET_IP_); 5625 err = ext4_reserve_inode_write(handle, inode, &iloc); 5626 if (ext4_handle_valid(handle) && 5627 EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize && 5628 !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) { 5629 /* 5630 * We need extra buffer credits since we may write into EA block 5631 * with this same handle. If journal_extend fails, then it will 5632 * only result in a minor loss of functionality for that inode. 5633 * If this is felt to be critical, then e2fsck should be run to 5634 * force a large enough s_min_extra_isize. 5635 */ 5636 if ((jbd2_journal_extend(handle, 5637 EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) { 5638 ret = ext4_expand_extra_isize(inode, 5639 sbi->s_want_extra_isize, 5640 iloc, handle); 5641 if (ret) { 5642 ext4_set_inode_state(inode, 5643 EXT4_STATE_NO_EXPAND); 5644 if (mnt_count != 5645 le16_to_cpu(sbi->s_es->s_mnt_count)) { 5646 ext4_warning(inode->i_sb, 5647 "Unable to expand inode %lu. Delete" 5648 " some EAs or run e2fsck.", 5649 inode->i_ino); 5650 mnt_count = 5651 le16_to_cpu(sbi->s_es->s_mnt_count); 5652 } 5653 } 5654 } 5655 } 5656 if (!err) 5657 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 5658 return err; 5659 } 5660 5661 /* 5662 * ext4_dirty_inode() is called from __mark_inode_dirty() 5663 * 5664 * We're really interested in the case where a file is being extended. 5665 * i_size has been changed by generic_commit_write() and we thus need 5666 * to include the updated inode in the current transaction. 5667 * 5668 * Also, dquot_alloc_block() will always dirty the inode when blocks 5669 * are allocated to the file. 5670 * 5671 * If the inode is marked synchronous, we don't honour that here - doing 5672 * so would cause a commit on atime updates, which we don't bother doing. 5673 * We handle synchronous inodes at the highest possible level. 5674 */ 5675 void ext4_dirty_inode(struct inode *inode) 5676 { 5677 handle_t *handle; 5678 5679 handle = ext4_journal_start(inode, 2); 5680 if (IS_ERR(handle)) 5681 goto out; 5682 5683 ext4_mark_inode_dirty(handle, inode); 5684 5685 ext4_journal_stop(handle); 5686 out: 5687 return; 5688 } 5689 5690 #if 0 5691 /* 5692 * Bind an inode's backing buffer_head into this transaction, to prevent 5693 * it from being flushed to disk early. Unlike 5694 * ext4_reserve_inode_write, this leaves behind no bh reference and 5695 * returns no iloc structure, so the caller needs to repeat the iloc 5696 * lookup to mark the inode dirty later. 5697 */ 5698 static int ext4_pin_inode(handle_t *handle, struct inode *inode) 5699 { 5700 struct ext4_iloc iloc; 5701 5702 int err = 0; 5703 if (handle) { 5704 err = ext4_get_inode_loc(inode, &iloc); 5705 if (!err) { 5706 BUFFER_TRACE(iloc.bh, "get_write_access"); 5707 err = jbd2_journal_get_write_access(handle, iloc.bh); 5708 if (!err) 5709 err = ext4_handle_dirty_metadata(handle, 5710 NULL, 5711 iloc.bh); 5712 brelse(iloc.bh); 5713 } 5714 } 5715 ext4_std_error(inode->i_sb, err); 5716 return err; 5717 } 5718 #endif 5719 5720 int ext4_change_inode_journal_flag(struct inode *inode, int val) 5721 { 5722 journal_t *journal; 5723 handle_t *handle; 5724 int err; 5725 5726 /* 5727 * We have to be very careful here: changing a data block's 5728 * journaling status dynamically is dangerous. If we write a 5729 * data block to the journal, change the status and then delete 5730 * that block, we risk forgetting to revoke the old log record 5731 * from the journal and so a subsequent replay can corrupt data. 5732 * So, first we make sure that the journal is empty and that 5733 * nobody is changing anything. 5734 */ 5735 5736 journal = EXT4_JOURNAL(inode); 5737 if (!journal) 5738 return 0; 5739 if (is_journal_aborted(journal)) 5740 return -EROFS; 5741 5742 jbd2_journal_lock_updates(journal); 5743 jbd2_journal_flush(journal); 5744 5745 /* 5746 * OK, there are no updates running now, and all cached data is 5747 * synced to disk. We are now in a completely consistent state 5748 * which doesn't have anything in the journal, and we know that 5749 * no filesystem updates are running, so it is safe to modify 5750 * the inode's in-core data-journaling state flag now. 5751 */ 5752 5753 if (val) 5754 ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA); 5755 else 5756 ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA); 5757 ext4_set_aops(inode); 5758 5759 jbd2_journal_unlock_updates(journal); 5760 5761 /* Finally we can mark the inode as dirty. */ 5762 5763 handle = ext4_journal_start(inode, 1); 5764 if (IS_ERR(handle)) 5765 return PTR_ERR(handle); 5766 5767 err = ext4_mark_inode_dirty(handle, inode); 5768 ext4_handle_sync(handle); 5769 ext4_journal_stop(handle); 5770 ext4_std_error(inode->i_sb, err); 5771 5772 return err; 5773 } 5774 5775 static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh) 5776 { 5777 return !buffer_mapped(bh); 5778 } 5779 5780 int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 5781 { 5782 struct page *page = vmf->page; 5783 loff_t size; 5784 unsigned long len; 5785 int ret = -EINVAL; 5786 void *fsdata; 5787 struct file *file = vma->vm_file; 5788 struct inode *inode = file->f_path.dentry->d_inode; 5789 struct address_space *mapping = inode->i_mapping; 5790 5791 /* 5792 * Get i_alloc_sem to stop truncates messing with the inode. We cannot 5793 * get i_mutex because we are already holding mmap_sem. 5794 */ 5795 down_read(&inode->i_alloc_sem); 5796 size = i_size_read(inode); 5797 if (page->mapping != mapping || size <= page_offset(page) 5798 || !PageUptodate(page)) { 5799 /* page got truncated from under us? */ 5800 goto out_unlock; 5801 } 5802 ret = 0; 5803 if (PageMappedToDisk(page)) 5804 goto out_unlock; 5805 5806 if (page->index == size >> PAGE_CACHE_SHIFT) 5807 len = size & ~PAGE_CACHE_MASK; 5808 else 5809 len = PAGE_CACHE_SIZE; 5810 5811 lock_page(page); 5812 /* 5813 * return if we have all the buffers mapped. This avoid 5814 * the need to call write_begin/write_end which does a 5815 * journal_start/journal_stop which can block and take 5816 * long time 5817 */ 5818 if (page_has_buffers(page)) { 5819 if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL, 5820 ext4_bh_unmapped)) { 5821 unlock_page(page); 5822 goto out_unlock; 5823 } 5824 } 5825 unlock_page(page); 5826 /* 5827 * OK, we need to fill the hole... Do write_begin write_end 5828 * to do block allocation/reservation.We are not holding 5829 * inode.i__mutex here. That allow * parallel write_begin, 5830 * write_end call. lock_page prevent this from happening 5831 * on the same page though 5832 */ 5833 ret = mapping->a_ops->write_begin(file, mapping, page_offset(page), 5834 len, AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata); 5835 if (ret < 0) 5836 goto out_unlock; 5837 ret = mapping->a_ops->write_end(file, mapping, page_offset(page), 5838 len, len, page, fsdata); 5839 if (ret < 0) 5840 goto out_unlock; 5841 ret = 0; 5842 out_unlock: 5843 if (ret) 5844 ret = VM_FAULT_SIGBUS; 5845 up_read(&inode->i_alloc_sem); 5846 return ret; 5847 } 5848