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/ext4_jbd2.h> 29#include <linux/jbd2.h> 30#include <linux/highuid.h> 31#include <linux/pagemap.h> 32#include <linux/quotaops.h> 33#include <linux/string.h> 34#include <linux/buffer_head.h> 35#include <linux/writeback.h> 36#include <linux/mpage.h> 37#include <linux/uio.h> 38#include <linux/bio.h> 39#include "xattr.h" 40#include "acl.h" 41 42/* 43 * Test whether an inode is a fast symlink. 44 */ 45static int ext4_inode_is_fast_symlink(struct inode *inode) 46{ 47 int ea_blocks = EXT4_I(inode)->i_file_acl ? 48 (inode->i_sb->s_blocksize >> 9) : 0; 49 50 return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0); 51} 52 53/* 54 * The ext4 forget function must perform a revoke if we are freeing data 55 * which has been journaled. Metadata (eg. indirect blocks) must be 56 * revoked in all cases. 57 * 58 * "bh" may be NULL: a metadata block may have been freed from memory 59 * but there may still be a record of it in the journal, and that record 60 * still needs to be revoked. 61 */ 62int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode, 63 struct buffer_head *bh, ext4_fsblk_t blocknr) 64{ 65 int err; 66 67 might_sleep(); 68 69 BUFFER_TRACE(bh, "enter"); 70 71 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " 72 "data mode %lx\n", 73 bh, is_metadata, inode->i_mode, 74 test_opt(inode->i_sb, DATA_FLAGS)); 75 76 /* Never use the revoke function if we are doing full data 77 * journaling: there is no need to, and a V1 superblock won't 78 * support it. Otherwise, only skip the revoke on un-journaled 79 * data blocks. */ 80 81 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || 82 (!is_metadata && !ext4_should_journal_data(inode))) { 83 if (bh) { 84 BUFFER_TRACE(bh, "call jbd2_journal_forget"); 85 return ext4_journal_forget(handle, bh); 86 } 87 return 0; 88 } 89 90 /* 91 * data!=journal && (is_metadata || should_journal_data(inode)) 92 */ 93 BUFFER_TRACE(bh, "call ext4_journal_revoke"); 94 err = ext4_journal_revoke(handle, blocknr, bh); 95 if (err) 96 ext4_abort(inode->i_sb, __FUNCTION__, 97 "error %d when attempting revoke", err); 98 BUFFER_TRACE(bh, "exit"); 99 return err; 100} 101 102/* 103 * Work out how many blocks we need to proceed with the next chunk of a 104 * truncate transaction. 105 */ 106static unsigned long blocks_for_truncate(struct inode *inode) 107{ 108 unsigned long needed; 109 110 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); 111 112 /* Give ourselves just enough room to cope with inodes in which 113 * i_blocks is corrupt: we've seen disk corruptions in the past 114 * which resulted in random data in an inode which looked enough 115 * like a regular file for ext4 to try to delete it. Things 116 * will go a bit crazy if that happens, but at least we should 117 * try not to panic the whole kernel. */ 118 if (needed < 2) 119 needed = 2; 120 121 /* But we need to bound the transaction so we don't overflow the 122 * journal. */ 123 if (needed > EXT4_MAX_TRANS_DATA) 124 needed = EXT4_MAX_TRANS_DATA; 125 126 return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed; 127} 128 129/* 130 * Truncate transactions can be complex and absolutely huge. So we need to 131 * be able to restart the transaction at a conventient checkpoint to make 132 * sure we don't overflow the journal. 133 * 134 * start_transaction gets us a new handle for a truncate transaction, 135 * and extend_transaction tries to extend the existing one a bit. If 136 * extend fails, we need to propagate the failure up and restart the 137 * transaction in the top-level truncate loop. --sct 138 */ 139static handle_t *start_transaction(struct inode *inode) 140{ 141 handle_t *result; 142 143 result = ext4_journal_start(inode, blocks_for_truncate(inode)); 144 if (!IS_ERR(result)) 145 return result; 146 147 ext4_std_error(inode->i_sb, PTR_ERR(result)); 148 return result; 149} 150 151/* 152 * Try to extend this transaction for the purposes of truncation. 153 * 154 * Returns 0 if we managed to create more room. If we can't create more 155 * room, and the transaction must be restarted we return 1. 156 */ 157static int try_to_extend_transaction(handle_t *handle, struct inode *inode) 158{ 159 if (handle->h_buffer_credits > EXT4_RESERVE_TRANS_BLOCKS) 160 return 0; 161 if (!ext4_journal_extend(handle, blocks_for_truncate(inode))) 162 return 0; 163 return 1; 164} 165 166/* 167 * Restart the transaction associated with *handle. This does a commit, 168 * so before we call here everything must be consistently dirtied against 169 * this transaction. 170 */ 171static int ext4_journal_test_restart(handle_t *handle, struct inode *inode) 172{ 173 jbd_debug(2, "restarting handle %p\n", handle); 174 return ext4_journal_restart(handle, blocks_for_truncate(inode)); 175} 176 177/* 178 * Called at the last iput() if i_nlink is zero. 179 */ 180void ext4_delete_inode (struct inode * inode) 181{ 182 handle_t *handle; 183 184 truncate_inode_pages(&inode->i_data, 0); 185 186 if (is_bad_inode(inode)) 187 goto no_delete; 188 189 handle = start_transaction(inode); 190 if (IS_ERR(handle)) { 191 /* 192 * If we're going to skip the normal cleanup, we still need to 193 * make sure that the in-core orphan linked list is properly 194 * cleaned up. 195 */ 196 ext4_orphan_del(NULL, inode); 197 goto no_delete; 198 } 199 200 if (IS_SYNC(inode)) 201 handle->h_sync = 1; 202 inode->i_size = 0; 203 if (inode->i_blocks) 204 ext4_truncate(inode); 205 /* 206 * Kill off the orphan record which ext4_truncate created. 207 * AKPM: I think this can be inside the above `if'. 208 * Note that ext4_orphan_del() has to be able to cope with the 209 * deletion of a non-existent orphan - this is because we don't 210 * know if ext4_truncate() actually created an orphan record. 211 * (Well, we could do this if we need to, but heck - it works) 212 */ 213 ext4_orphan_del(handle, inode); 214 EXT4_I(inode)->i_dtime = get_seconds(); 215 216 /* 217 * One subtle ordering requirement: if anything has gone wrong 218 * (transaction abort, IO errors, whatever), then we can still 219 * do these next steps (the fs will already have been marked as 220 * having errors), but we can't free the inode if the mark_dirty 221 * fails. 222 */ 223 if (ext4_mark_inode_dirty(handle, inode)) 224 /* If that failed, just do the required in-core inode clear. */ 225 clear_inode(inode); 226 else 227 ext4_free_inode(handle, inode); 228 ext4_journal_stop(handle); 229 return; 230no_delete: 231 clear_inode(inode); /* We must guarantee clearing of inode... */ 232} 233 234typedef struct { 235 __le32 *p; 236 __le32 key; 237 struct buffer_head *bh; 238} Indirect; 239 240static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v) 241{ 242 p->key = *(p->p = v); 243 p->bh = bh; 244} 245 246static int verify_chain(Indirect *from, Indirect *to) 247{ 248 while (from <= to && from->key == *from->p) 249 from++; 250 return (from > to); 251} 252 253/** 254 * ext4_block_to_path - parse the block number into array of offsets 255 * @inode: inode in question (we are only interested in its superblock) 256 * @i_block: block number to be parsed 257 * @offsets: array to store the offsets in 258 * @boundary: set this non-zero if the referred-to block is likely to be 259 * followed (on disk) by an indirect block. 260 * 261 * To store the locations of file's data ext4 uses a data structure common 262 * for UNIX filesystems - tree of pointers anchored in the inode, with 263 * data blocks at leaves and indirect blocks in intermediate nodes. 264 * This function translates the block number into path in that tree - 265 * return value is the path length and @offsets[n] is the offset of 266 * pointer to (n+1)th node in the nth one. If @block is out of range 267 * (negative or too large) warning is printed and zero returned. 268 * 269 * Note: function doesn't find node addresses, so no IO is needed. All 270 * we need to know is the capacity of indirect blocks (taken from the 271 * inode->i_sb). 272 */ 273 274/* 275 * Portability note: the last comparison (check that we fit into triple 276 * indirect block) is spelled differently, because otherwise on an 277 * architecture with 32-bit longs and 8Kb pages we might get into trouble 278 * if our filesystem had 8Kb blocks. We might use long long, but that would 279 * kill us on x86. Oh, well, at least the sign propagation does not matter - 280 * i_block would have to be negative in the very beginning, so we would not 281 * get there at all. 282 */ 283 284static int ext4_block_to_path(struct inode *inode, 285 long i_block, int offsets[4], int *boundary) 286{ 287 int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb); 288 int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb); 289 const long direct_blocks = EXT4_NDIR_BLOCKS, 290 indirect_blocks = ptrs, 291 double_blocks = (1 << (ptrs_bits * 2)); 292 int n = 0; 293 int final = 0; 294 295 if (i_block < 0) { 296 ext4_warning (inode->i_sb, "ext4_block_to_path", "block < 0"); 297 } else if (i_block < direct_blocks) { 298 offsets[n++] = i_block; 299 final = direct_blocks; 300 } else if ( (i_block -= direct_blocks) < indirect_blocks) { 301 offsets[n++] = EXT4_IND_BLOCK; 302 offsets[n++] = i_block; 303 final = ptrs; 304 } else if ((i_block -= indirect_blocks) < double_blocks) { 305 offsets[n++] = EXT4_DIND_BLOCK; 306 offsets[n++] = i_block >> ptrs_bits; 307 offsets[n++] = i_block & (ptrs - 1); 308 final = ptrs; 309 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) { 310 offsets[n++] = EXT4_TIND_BLOCK; 311 offsets[n++] = i_block >> (ptrs_bits * 2); 312 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1); 313 offsets[n++] = i_block & (ptrs - 1); 314 final = ptrs; 315 } else { 316 ext4_warning(inode->i_sb, "ext4_block_to_path", "block > big"); 317 } 318 if (boundary) 319 *boundary = final - 1 - (i_block & (ptrs - 1)); 320 return n; 321} 322 323/** 324 * ext4_get_branch - read the chain of indirect blocks leading to data 325 * @inode: inode in question 326 * @depth: depth of the chain (1 - direct pointer, etc.) 327 * @offsets: offsets of pointers in inode/indirect blocks 328 * @chain: place to store the result 329 * @err: here we store the error value 330 * 331 * Function fills the array of triples <key, p, bh> and returns %NULL 332 * if everything went OK or the pointer to the last filled triple 333 * (incomplete one) otherwise. Upon the return chain[i].key contains 334 * the number of (i+1)-th block in the chain (as it is stored in memory, 335 * i.e. little-endian 32-bit), chain[i].p contains the address of that 336 * number (it points into struct inode for i==0 and into the bh->b_data 337 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect 338 * block for i>0 and NULL for i==0. In other words, it holds the block 339 * numbers of the chain, addresses they were taken from (and where we can 340 * verify that chain did not change) and buffer_heads hosting these 341 * numbers. 342 * 343 * Function stops when it stumbles upon zero pointer (absent block) 344 * (pointer to last triple returned, *@err == 0) 345 * or when it gets an IO error reading an indirect block 346 * (ditto, *@err == -EIO) 347 * or when it notices that chain had been changed while it was reading 348 * (ditto, *@err == -EAGAIN) 349 * or when it reads all @depth-1 indirect blocks successfully and finds 350 * the whole chain, all way to the data (returns %NULL, *err == 0). 351 */ 352static Indirect *ext4_get_branch(struct inode *inode, int depth, int *offsets, 353 Indirect chain[4], int *err) 354{ 355 struct super_block *sb = inode->i_sb; 356 Indirect *p = chain; 357 struct buffer_head *bh; 358 359 *err = 0; 360 /* i_data is not going away, no lock needed */ 361 add_chain (chain, NULL, EXT4_I(inode)->i_data + *offsets); 362 if (!p->key) 363 goto no_block; 364 while (--depth) { 365 bh = sb_bread(sb, le32_to_cpu(p->key)); 366 if (!bh) 367 goto failure; 368 /* Reader: pointers */ 369 if (!verify_chain(chain, p)) 370 goto changed; 371 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets); 372 /* Reader: end */ 373 if (!p->key) 374 goto no_block; 375 } 376 return NULL; 377 378changed: 379 brelse(bh); 380 *err = -EAGAIN; 381 goto no_block; 382failure: 383 *err = -EIO; 384no_block: 385 return p; 386} 387 388/** 389 * ext4_find_near - find a place for allocation with sufficient locality 390 * @inode: owner 391 * @ind: descriptor of indirect block. 392 * 393 * This function returns the prefered place for block allocation. 394 * It is used when heuristic for sequential allocation fails. 395 * Rules are: 396 * + if there is a block to the left of our position - allocate near it. 397 * + if pointer will live in indirect block - allocate near that block. 398 * + if pointer will live in inode - allocate in the same 399 * cylinder group. 400 * 401 * In the latter case we colour the starting block by the callers PID to 402 * prevent it from clashing with concurrent allocations for a different inode 403 * in the same block group. The PID is used here so that functionally related 404 * files will be close-by on-disk. 405 * 406 * Caller must make sure that @ind is valid and will stay that way. 407 */ 408static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind) 409{ 410 struct ext4_inode_info *ei = EXT4_I(inode); 411 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data; 412 __le32 *p; 413 ext4_fsblk_t bg_start; 414 ext4_grpblk_t colour; 415 416 /* Try to find previous block */ 417 for (p = ind->p - 1; p >= start; p--) { 418 if (*p) 419 return le32_to_cpu(*p); 420 } 421 422 /* No such thing, so let's try location of indirect block */ 423 if (ind->bh) 424 return ind->bh->b_blocknr; 425 426 /* 427 * It is going to be referred to from the inode itself? OK, just put it 428 * into the same cylinder group then. 429 */ 430 bg_start = ext4_group_first_block_no(inode->i_sb, ei->i_block_group); 431 colour = (current->pid % 16) * 432 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16); 433 return bg_start + colour; 434} 435 436/** 437 * ext4_find_goal - find a prefered place for allocation. 438 * @inode: owner 439 * @block: block we want 440 * @chain: chain of indirect blocks 441 * @partial: pointer to the last triple within a chain 442 * @goal: place to store the result. 443 * 444 * Normally this function find the prefered place for block allocation, 445 * stores it in *@goal and returns zero. 446 */ 447 448static ext4_fsblk_t ext4_find_goal(struct inode *inode, long block, 449 Indirect chain[4], Indirect *partial) 450{ 451 struct ext4_block_alloc_info *block_i; 452 453 block_i = EXT4_I(inode)->i_block_alloc_info; 454 455 /* 456 * try the heuristic for sequential allocation, 457 * failing that at least try to get decent locality. 458 */ 459 if (block_i && (block == block_i->last_alloc_logical_block + 1) 460 && (block_i->last_alloc_physical_block != 0)) { 461 return block_i->last_alloc_physical_block + 1; 462 } 463 464 return ext4_find_near(inode, partial); 465} 466 467/** 468 * ext4_blks_to_allocate: Look up the block map and count the number 469 * of direct blocks need to be allocated for the given branch. 470 * 471 * @branch: chain of indirect blocks 472 * @k: number of blocks need for indirect blocks 473 * @blks: number of data blocks to be mapped. 474 * @blocks_to_boundary: the offset in the indirect block 475 * 476 * return the total number of blocks to be allocate, including the 477 * direct and indirect blocks. 478 */ 479static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned long blks, 480 int blocks_to_boundary) 481{ 482 unsigned long count = 0; 483 484 /* 485 * Simple case, [t,d]Indirect block(s) has not allocated yet 486 * then it's clear blocks on that path have not allocated 487 */ 488 if (k > 0) { 489 /* right now we don't handle cross boundary allocation */ 490 if (blks < blocks_to_boundary + 1) 491 count += blks; 492 else 493 count += blocks_to_boundary + 1; 494 return count; 495 } 496 497 count++; 498 while (count < blks && count <= blocks_to_boundary && 499 le32_to_cpu(*(branch[0].p + count)) == 0) { 500 count++; 501 } 502 return count; 503} 504 505/** 506 * ext4_alloc_blocks: multiple allocate blocks needed for a branch 507 * @indirect_blks: the number of blocks need to allocate for indirect 508 * blocks 509 * 510 * @new_blocks: on return it will store the new block numbers for 511 * the indirect blocks(if needed) and the first direct block, 512 * @blks: on return it will store the total number of allocated 513 * direct blocks 514 */ 515static int ext4_alloc_blocks(handle_t *handle, struct inode *inode, 516 ext4_fsblk_t goal, int indirect_blks, int blks, 517 ext4_fsblk_t new_blocks[4], int *err) 518{ 519 int target, i; 520 unsigned long count = 0; 521 int index = 0; 522 ext4_fsblk_t current_block = 0; 523 int ret = 0; 524 525 /* 526 * Here we try to allocate the requested multiple blocks at once, 527 * on a best-effort basis. 528 * To build a branch, we should allocate blocks for 529 * the indirect blocks(if not allocated yet), and at least 530 * the first direct block of this branch. That's the 531 * minimum number of blocks need to allocate(required) 532 */ 533 target = blks + indirect_blks; 534 535 while (1) { 536 count = target; 537 /* allocating blocks for indirect blocks and direct blocks */ 538 current_block = ext4_new_blocks(handle,inode,goal,&count,err); 539 if (*err) 540 goto failed_out; 541 542 target -= count; 543 /* allocate blocks for indirect blocks */ 544 while (index < indirect_blks && count) { 545 new_blocks[index++] = current_block++; 546 count--; 547 } 548 549 if (count > 0) 550 break; 551 } 552 553 /* save the new block number for the first direct block */ 554 new_blocks[index] = current_block; 555 556 /* total number of blocks allocated for direct blocks */ 557 ret = count; 558 *err = 0; 559 return ret; 560failed_out: 561 for (i = 0; i <index; i++) 562 ext4_free_blocks(handle, inode, new_blocks[i], 1); 563 return ret; 564} 565 566/** 567 * ext4_alloc_branch - allocate and set up a chain of blocks. 568 * @inode: owner 569 * @indirect_blks: number of allocated indirect blocks 570 * @blks: number of allocated direct blocks 571 * @offsets: offsets (in the blocks) to store the pointers to next. 572 * @branch: place to store the chain in. 573 * 574 * This function allocates blocks, zeroes out all but the last one, 575 * links them into chain and (if we are synchronous) writes them to disk. 576 * In other words, it prepares a branch that can be spliced onto the 577 * inode. It stores the information about that chain in the branch[], in 578 * the same format as ext4_get_branch() would do. We are calling it after 579 * we had read the existing part of chain and partial points to the last 580 * triple of that (one with zero ->key). Upon the exit we have the same 581 * picture as after the successful ext4_get_block(), except that in one 582 * place chain is disconnected - *branch->p is still zero (we did not 583 * set the last link), but branch->key contains the number that should 584 * be placed into *branch->p to fill that gap. 585 * 586 * If allocation fails we free all blocks we've allocated (and forget 587 * their buffer_heads) and return the error value the from failed 588 * ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain 589 * as described above and return 0. 590 */ 591static int ext4_alloc_branch(handle_t *handle, struct inode *inode, 592 int indirect_blks, int *blks, ext4_fsblk_t goal, 593 int *offsets, Indirect *branch) 594{ 595 int blocksize = inode->i_sb->s_blocksize; 596 int i, n = 0; 597 int err = 0; 598 struct buffer_head *bh; 599 int num; 600 ext4_fsblk_t new_blocks[4]; 601 ext4_fsblk_t current_block; 602 603 num = ext4_alloc_blocks(handle, inode, goal, indirect_blks, 604 *blks, new_blocks, &err); 605 if (err) 606 return err; 607 608 branch[0].key = cpu_to_le32(new_blocks[0]); 609 /* 610 * metadata blocks and data blocks are allocated. 611 */ 612 for (n = 1; n <= indirect_blks; n++) { 613 /* 614 * Get buffer_head for parent block, zero it out 615 * and set the pointer to new one, then send 616 * parent to disk. 617 */ 618 bh = sb_getblk(inode->i_sb, new_blocks[n-1]); 619 branch[n].bh = bh; 620 lock_buffer(bh); 621 BUFFER_TRACE(bh, "call get_create_access"); 622 err = ext4_journal_get_create_access(handle, bh); 623 if (err) { 624 unlock_buffer(bh); 625 brelse(bh); 626 goto failed; 627 } 628 629 memset(bh->b_data, 0, blocksize); 630 branch[n].p = (__le32 *) bh->b_data + offsets[n]; 631 branch[n].key = cpu_to_le32(new_blocks[n]); 632 *branch[n].p = branch[n].key; 633 if ( n == indirect_blks) { 634 current_block = new_blocks[n]; 635 /* 636 * End of chain, update the last new metablock of 637 * the chain to point to the new allocated 638 * data blocks numbers 639 */ 640 for (i=1; i < num; i++) 641 *(branch[n].p + i) = cpu_to_le32(++current_block); 642 } 643 BUFFER_TRACE(bh, "marking uptodate"); 644 set_buffer_uptodate(bh); 645 unlock_buffer(bh); 646 647 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata"); 648 err = ext4_journal_dirty_metadata(handle, bh); 649 if (err) 650 goto failed; 651 } 652 *blks = num; 653 return err; 654failed: 655 /* Allocation failed, free what we already allocated */ 656 for (i = 1; i <= n ; i++) { 657 BUFFER_TRACE(branch[i].bh, "call jbd2_journal_forget"); 658 ext4_journal_forget(handle, branch[i].bh); 659 } 660 for (i = 0; i <indirect_blks; i++) 661 ext4_free_blocks(handle, inode, new_blocks[i], 1); 662 663 ext4_free_blocks(handle, inode, new_blocks[i], num); 664 665 return err; 666} 667 668/** 669 * ext4_splice_branch - splice the allocated branch onto inode. 670 * @inode: owner 671 * @block: (logical) number of block we are adding 672 * @chain: chain of indirect blocks (with a missing link - see 673 * ext4_alloc_branch) 674 * @where: location of missing link 675 * @num: number of indirect blocks we are adding 676 * @blks: number of direct blocks we are adding 677 * 678 * This function fills the missing link and does all housekeeping needed in 679 * inode (->i_blocks, etc.). In case of success we end up with the full 680 * chain to new block and return 0. 681 */ 682static int ext4_splice_branch(handle_t *handle, struct inode *inode, 683 long block, Indirect *where, int num, int blks) 684{ 685 int i; 686 int err = 0; 687 struct ext4_block_alloc_info *block_i; 688 ext4_fsblk_t current_block; 689 690 block_i = EXT4_I(inode)->i_block_alloc_info; 691 /* 692 * If we're splicing into a [td]indirect block (as opposed to the 693 * inode) then we need to get write access to the [td]indirect block 694 * before the splice. 695 */ 696 if (where->bh) { 697 BUFFER_TRACE(where->bh, "get_write_access"); 698 err = ext4_journal_get_write_access(handle, where->bh); 699 if (err) 700 goto err_out; 701 } 702 /* That's it */ 703 704 *where->p = where->key; 705 706 /* 707 * Update the host buffer_head or inode to point to more just allocated 708 * direct blocks blocks 709 */ 710 if (num == 0 && blks > 1) { 711 current_block = le32_to_cpu(where->key) + 1; 712 for (i = 1; i < blks; i++) 713 *(where->p + i ) = cpu_to_le32(current_block++); 714 } 715 716 /* 717 * update the most recently allocated logical & physical block 718 * in i_block_alloc_info, to assist find the proper goal block for next 719 * allocation 720 */ 721 if (block_i) { 722 block_i->last_alloc_logical_block = block + blks - 1; 723 block_i->last_alloc_physical_block = 724 le32_to_cpu(where[num].key) + blks - 1; 725 } 726 727 /* We are done with atomic stuff, now do the rest of housekeeping */ 728 729 inode->i_ctime = CURRENT_TIME_SEC; 730 ext4_mark_inode_dirty(handle, inode); 731 732 /* had we spliced it onto indirect block? */ 733 if (where->bh) { 734 /* 735 * If we spliced it onto an indirect block, we haven't 736 * altered the inode. Note however that if it is being spliced 737 * onto an indirect block at the very end of the file (the 738 * file is growing) then we *will* alter the inode to reflect 739 * the new i_size. But that is not done here - it is done in 740 * generic_commit_write->__mark_inode_dirty->ext4_dirty_inode. 741 */ 742 jbd_debug(5, "splicing indirect only\n"); 743 BUFFER_TRACE(where->bh, "call ext4_journal_dirty_metadata"); 744 err = ext4_journal_dirty_metadata(handle, where->bh); 745 if (err) 746 goto err_out; 747 } else { 748 /* 749 * OK, we spliced it into the inode itself on a direct block. 750 * Inode was dirtied above. 751 */ 752 jbd_debug(5, "splicing direct\n"); 753 } 754 return err; 755 756err_out: 757 for (i = 1; i <= num; i++) { 758 BUFFER_TRACE(where[i].bh, "call jbd2_journal_forget"); 759 ext4_journal_forget(handle, where[i].bh); 760 ext4_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1); 761 } 762 ext4_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks); 763 764 return err; 765} 766 767/* 768 * Allocation strategy is simple: if we have to allocate something, we will 769 * have to go the whole way to leaf. So let's do it before attaching anything 770 * to tree, set linkage between the newborn blocks, write them if sync is 771 * required, recheck the path, free and repeat if check fails, otherwise 772 * set the last missing link (that will protect us from any truncate-generated 773 * removals - all blocks on the path are immune now) and possibly force the 774 * write on the parent block. 775 * That has a nice additional property: no special recovery from the failed 776 * allocations is needed - we simply release blocks and do not touch anything 777 * reachable from inode. 778 * 779 * `handle' can be NULL if create == 0. 780 * 781 * The BKL may not be held on entry here. Be sure to take it early. 782 * return > 0, # of blocks mapped or allocated. 783 * return = 0, if plain lookup failed. 784 * return < 0, error case. 785 */ 786int ext4_get_blocks_handle(handle_t *handle, struct inode *inode, 787 sector_t iblock, unsigned long maxblocks, 788 struct buffer_head *bh_result, 789 int create, int extend_disksize) 790{ 791 int err = -EIO; 792 int offsets[4]; 793 Indirect chain[4]; 794 Indirect *partial; 795 ext4_fsblk_t goal; 796 int indirect_blks; 797 int blocks_to_boundary = 0; 798 int depth; 799 struct ext4_inode_info *ei = EXT4_I(inode); 800 int count = 0; 801 ext4_fsblk_t first_block = 0; 802 803 804 J_ASSERT(!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)); 805 J_ASSERT(handle != NULL || create == 0); 806 depth = ext4_block_to_path(inode,iblock,offsets,&blocks_to_boundary); 807 808 if (depth == 0) 809 goto out; 810 811 partial = ext4_get_branch(inode, depth, offsets, chain, &err); 812 813 /* Simplest case - block found, no allocation needed */ 814 if (!partial) { 815 first_block = le32_to_cpu(chain[depth - 1].key); 816 clear_buffer_new(bh_result); 817 count++; 818 /*map more blocks*/ 819 while (count < maxblocks && count <= blocks_to_boundary) { 820 ext4_fsblk_t blk; 821 822 if (!verify_chain(chain, partial)) { 823 /* 824 * Indirect block might be removed by 825 * truncate while we were reading it. 826 * Handling of that case: forget what we've 827 * got now. Flag the err as EAGAIN, so it 828 * will reread. 829 */ 830 err = -EAGAIN; 831 count = 0; 832 break; 833 } 834 blk = le32_to_cpu(*(chain[depth-1].p + count)); 835 836 if (blk == first_block + count) 837 count++; 838 else 839 break; 840 } 841 if (err != -EAGAIN) 842 goto got_it; 843 } 844 845 /* Next simple case - plain lookup or failed read of indirect block */ 846 if (!create || err == -EIO) 847 goto cleanup; 848 849 mutex_lock(&ei->truncate_mutex); 850 851 /* 852 * If the indirect block is missing while we are reading 853 * the chain(ext4_get_branch() returns -EAGAIN err), or 854 * if the chain has been changed after we grab the semaphore, 855 * (either because another process truncated this branch, or 856 * another get_block allocated this branch) re-grab the chain to see if 857 * the request block has been allocated or not. 858 * 859 * Since we already block the truncate/other get_block 860 * at this point, we will have the current copy of the chain when we 861 * splice the branch into the tree. 862 */ 863 if (err == -EAGAIN || !verify_chain(chain, partial)) { 864 while (partial > chain) { 865 brelse(partial->bh); 866 partial--; 867 } 868 partial = ext4_get_branch(inode, depth, offsets, chain, &err); 869 if (!partial) { 870 count++; 871 mutex_unlock(&ei->truncate_mutex); 872 if (err) 873 goto cleanup; 874 clear_buffer_new(bh_result); 875 goto got_it; 876 } 877 } 878 879 /* 880 * Okay, we need to do block allocation. Lazily initialize the block 881 * allocation info here if necessary 882 */ 883 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info)) 884 ext4_init_block_alloc_info(inode); 885 886 goal = ext4_find_goal(inode, iblock, chain, partial); 887 888 /* the number of blocks need to allocate for [d,t]indirect blocks */ 889 indirect_blks = (chain + depth) - partial - 1; 890 891 /* 892 * Next look up the indirect map to count the totoal number of 893 * direct blocks to allocate for this branch. 894 */ 895 count = ext4_blks_to_allocate(partial, indirect_blks, 896 maxblocks, blocks_to_boundary); 897 /* 898 * Block out ext4_truncate while we alter the tree 899 */ 900 err = ext4_alloc_branch(handle, inode, indirect_blks, &count, goal, 901 offsets + (partial - chain), partial); 902 903 /* 904 * The ext4_splice_branch call will free and forget any buffers 905 * on the new chain if there is a failure, but that risks using 906 * up transaction credits, especially for bitmaps where the 907 * credits cannot be returned. Can we handle this somehow? We 908 * may need to return -EAGAIN upwards in the worst case. --sct 909 */ 910 if (!err) 911 err = ext4_splice_branch(handle, inode, iblock, 912 partial, indirect_blks, count); 913 /* 914 * i_disksize growing is protected by truncate_mutex. Don't forget to 915 * protect it if you're about to implement concurrent 916 * ext4_get_block() -bzzz 917 */ 918 if (!err && extend_disksize && inode->i_size > ei->i_disksize) 919 ei->i_disksize = inode->i_size; 920 mutex_unlock(&ei->truncate_mutex); 921 if (err) 922 goto cleanup; 923 924 set_buffer_new(bh_result); 925got_it: 926 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key)); 927 if (count > blocks_to_boundary) 928 set_buffer_boundary(bh_result); 929 err = count; 930 /* Clean up and exit */ 931 partial = chain + depth - 1; /* the whole chain */ 932cleanup: 933 while (partial > chain) { 934 BUFFER_TRACE(partial->bh, "call brelse"); 935 brelse(partial->bh); 936 partial--; 937 } 938 BUFFER_TRACE(bh_result, "returned"); 939out: 940 return err; 941} 942 943#define DIO_CREDITS (EXT4_RESERVE_TRANS_BLOCKS + 32) 944 945static int ext4_get_block(struct inode *inode, sector_t iblock, 946 struct buffer_head *bh_result, int create) 947{ 948 handle_t *handle = ext4_journal_current_handle(); 949 int ret = 0; 950 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits; 951 952 if (!create) 953 goto get_block; /* A read */ 954 955 if (max_blocks == 1) 956 goto get_block; /* A single block get */ 957 958 if (handle->h_transaction->t_state == T_LOCKED) { 959 /* 960 * Huge direct-io writes can hold off commits for long 961 * periods of time. Let this commit run. 962 */ 963 ext4_journal_stop(handle); 964 handle = ext4_journal_start(inode, DIO_CREDITS); 965 if (IS_ERR(handle)) 966 ret = PTR_ERR(handle); 967 goto get_block; 968 } 969 970 if (handle->h_buffer_credits <= EXT4_RESERVE_TRANS_BLOCKS) { 971 /* 972 * Getting low on buffer credits... 973 */ 974 ret = ext4_journal_extend(handle, DIO_CREDITS); 975 if (ret > 0) { 976 /* 977 * Couldn't extend the transaction. Start a new one. 978 */ 979 ret = ext4_journal_restart(handle, DIO_CREDITS); 980 } 981 } 982 983get_block: 984 if (ret == 0) { 985 ret = ext4_get_blocks_wrap(handle, inode, iblock, 986 max_blocks, bh_result, create, 0); 987 if (ret > 0) { 988 bh_result->b_size = (ret << inode->i_blkbits); 989 ret = 0; 990 } 991 } 992 return ret; 993} 994 995/* 996 * `handle' can be NULL if create is zero 997 */ 998struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, 999 long block, int create, int *errp) 1000{ 1001 struct buffer_head dummy; 1002 int fatal = 0, err; 1003 1004 J_ASSERT(handle != NULL || create == 0); 1005 1006 dummy.b_state = 0; 1007 dummy.b_blocknr = -1000; 1008 buffer_trace_init(&dummy.b_history); 1009 err = ext4_get_blocks_wrap(handle, inode, block, 1, 1010 &dummy, create, 1); 1011 /* 1012 * ext4_get_blocks_handle() returns number of blocks 1013 * mapped. 0 in case of a HOLE. 1014 */ 1015 if (err > 0) { 1016 if (err > 1) 1017 WARN_ON(1); 1018 err = 0; 1019 } 1020 *errp = err; 1021 if (!err && buffer_mapped(&dummy)) { 1022 struct buffer_head *bh; 1023 bh = sb_getblk(inode->i_sb, dummy.b_blocknr); 1024 if (!bh) { 1025 *errp = -EIO; 1026 goto err; 1027 } 1028 if (buffer_new(&dummy)) { 1029 J_ASSERT(create != 0); 1030 J_ASSERT(handle != 0); 1031 1032 /* 1033 * Now that we do not always journal data, we should 1034 * keep in mind whether this should always journal the 1035 * new buffer as metadata. For now, regular file 1036 * writes use ext4_get_block instead, so it's not a 1037 * problem. 1038 */ 1039 lock_buffer(bh); 1040 BUFFER_TRACE(bh, "call get_create_access"); 1041 fatal = ext4_journal_get_create_access(handle, bh); 1042 if (!fatal && !buffer_uptodate(bh)) { 1043 memset(bh->b_data,0,inode->i_sb->s_blocksize); 1044 set_buffer_uptodate(bh); 1045 } 1046 unlock_buffer(bh); 1047 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata"); 1048 err = ext4_journal_dirty_metadata(handle, bh); 1049 if (!fatal) 1050 fatal = err; 1051 } else { 1052 BUFFER_TRACE(bh, "not a new buffer"); 1053 } 1054 if (fatal) { 1055 *errp = fatal; 1056 brelse(bh); 1057 bh = NULL; 1058 } 1059 return bh; 1060 } 1061err: 1062 return NULL; 1063} 1064 1065struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode, 1066 int block, int create, int *err) 1067{ 1068 struct buffer_head * bh; 1069 1070 bh = ext4_getblk(handle, inode, block, create, err); 1071 if (!bh) 1072 return bh; 1073 if (buffer_uptodate(bh)) 1074 return bh; 1075 ll_rw_block(READ_META, 1, &bh); 1076 wait_on_buffer(bh); 1077 if (buffer_uptodate(bh)) 1078 return bh; 1079 put_bh(bh); 1080 *err = -EIO; 1081 return NULL; 1082} 1083 1084static int walk_page_buffers( handle_t *handle, 1085 struct buffer_head *head, 1086 unsigned from, 1087 unsigned to, 1088 int *partial, 1089 int (*fn)( handle_t *handle, 1090 struct buffer_head *bh)) 1091{ 1092 struct buffer_head *bh; 1093 unsigned block_start, block_end; 1094 unsigned blocksize = head->b_size; 1095 int err, ret = 0; 1096 struct buffer_head *next; 1097 1098 for ( bh = head, block_start = 0; 1099 ret == 0 && (bh != head || !block_start); 1100 block_start = block_end, bh = next) 1101 { 1102 next = bh->b_this_page; 1103 block_end = block_start + blocksize; 1104 if (block_end <= from || block_start >= to) { 1105 if (partial && !buffer_uptodate(bh)) 1106 *partial = 1; 1107 continue; 1108 } 1109 err = (*fn)(handle, bh); 1110 if (!ret) 1111 ret = err; 1112 } 1113 return ret; 1114} 1115 1116/* 1117 * To preserve ordering, it is essential that the hole instantiation and 1118 * the data write be encapsulated in a single transaction. We cannot 1119 * close off a transaction and start a new one between the ext4_get_block() 1120 * and the commit_write(). So doing the jbd2_journal_start at the start of 1121 * prepare_write() is the right place. 1122 * 1123 * Also, this function can nest inside ext4_writepage() -> 1124 * block_write_full_page(). In that case, we *know* that ext4_writepage() 1125 * has generated enough buffer credits to do the whole page. So we won't 1126 * block on the journal in that case, which is good, because the caller may 1127 * be PF_MEMALLOC. 1128 * 1129 * By accident, ext4 can be reentered when a transaction is open via 1130 * quota file writes. If we were to commit the transaction while thus 1131 * reentered, there can be a deadlock - we would be holding a quota 1132 * lock, and the commit would never complete if another thread had a 1133 * transaction open and was blocking on the quota lock - a ranking 1134 * violation. 1135 * 1136 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start 1137 * will _not_ run commit under these circumstances because handle->h_ref 1138 * is elevated. We'll still have enough credits for the tiny quotafile 1139 * write. 1140 */ 1141static int do_journal_get_write_access(handle_t *handle, 1142 struct buffer_head *bh) 1143{ 1144 if (!buffer_mapped(bh) || buffer_freed(bh)) 1145 return 0; 1146 return ext4_journal_get_write_access(handle, bh); 1147} 1148 1149static int ext4_prepare_write(struct file *file, struct page *page, 1150 unsigned from, unsigned to) 1151{ 1152 struct inode *inode = page->mapping->host; 1153 int ret, needed_blocks = ext4_writepage_trans_blocks(inode); 1154 handle_t *handle; 1155 int retries = 0; 1156 1157retry: 1158 handle = ext4_journal_start(inode, needed_blocks); 1159 if (IS_ERR(handle)) { 1160 ret = PTR_ERR(handle); 1161 goto out; 1162 } 1163 if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode)) 1164 ret = nobh_prepare_write(page, from, to, ext4_get_block); 1165 else 1166 ret = block_prepare_write(page, from, to, ext4_get_block); 1167 if (ret) 1168 goto prepare_write_failed; 1169 1170 if (ext4_should_journal_data(inode)) { 1171 ret = walk_page_buffers(handle, page_buffers(page), 1172 from, to, NULL, do_journal_get_write_access); 1173 } 1174prepare_write_failed: 1175 if (ret) 1176 ext4_journal_stop(handle); 1177 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) 1178 goto retry; 1179out: 1180 return ret; 1181} 1182 1183int ext4_journal_dirty_data(handle_t *handle, struct buffer_head *bh) 1184{ 1185 int err = jbd2_journal_dirty_data(handle, bh); 1186 if (err) 1187 ext4_journal_abort_handle(__FUNCTION__, __FUNCTION__, 1188 bh, handle,err); 1189 return err; 1190} 1191 1192/* For commit_write() in data=journal mode */ 1193static int commit_write_fn(handle_t *handle, struct buffer_head *bh) 1194{ 1195 if (!buffer_mapped(bh) || buffer_freed(bh)) 1196 return 0; 1197 set_buffer_uptodate(bh); 1198 return ext4_journal_dirty_metadata(handle, bh); 1199} 1200 1201/* 1202 * We need to pick up the new inode size which generic_commit_write gave us 1203 * `file' can be NULL - eg, when called from page_symlink(). 1204 * 1205 * ext4 never places buffers on inode->i_mapping->private_list. metadata 1206 * buffers are managed internally. 1207 */ 1208static int ext4_ordered_commit_write(struct file *file, struct page *page, 1209 unsigned from, unsigned to) 1210{ 1211 handle_t *handle = ext4_journal_current_handle(); 1212 struct inode *inode = page->mapping->host; 1213 int ret = 0, ret2; 1214 1215 ret = walk_page_buffers(handle, page_buffers(page), 1216 from, to, NULL, ext4_journal_dirty_data); 1217 1218 if (ret == 0) { 1219 /* 1220 * generic_commit_write() will run mark_inode_dirty() if i_size 1221 * changes. So let's piggyback the i_disksize mark_inode_dirty 1222 * into that. 1223 */ 1224 loff_t new_i_size; 1225 1226 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 1227 if (new_i_size > EXT4_I(inode)->i_disksize) 1228 EXT4_I(inode)->i_disksize = new_i_size; 1229 ret = generic_commit_write(file, page, from, to); 1230 } 1231 ret2 = ext4_journal_stop(handle); 1232 if (!ret) 1233 ret = ret2; 1234 return ret; 1235} 1236 1237static int ext4_writeback_commit_write(struct file *file, struct page *page, 1238 unsigned from, unsigned to) 1239{ 1240 handle_t *handle = ext4_journal_current_handle(); 1241 struct inode *inode = page->mapping->host; 1242 int ret = 0, ret2; 1243 loff_t new_i_size; 1244 1245 new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 1246 if (new_i_size > EXT4_I(inode)->i_disksize) 1247 EXT4_I(inode)->i_disksize = new_i_size; 1248 1249 if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode)) 1250 ret = nobh_commit_write(file, page, from, to); 1251 else 1252 ret = generic_commit_write(file, page, from, to); 1253 1254 ret2 = ext4_journal_stop(handle); 1255 if (!ret) 1256 ret = ret2; 1257 return ret; 1258} 1259 1260static int ext4_journalled_commit_write(struct file *file, 1261 struct page *page, unsigned from, unsigned to) 1262{ 1263 handle_t *handle = ext4_journal_current_handle(); 1264 struct inode *inode = page->mapping->host; 1265 int ret = 0, ret2; 1266 int partial = 0; 1267 loff_t pos; 1268 1269 /* 1270 * Here we duplicate the generic_commit_write() functionality 1271 */ 1272 pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 1273 1274 ret = walk_page_buffers(handle, page_buffers(page), from, 1275 to, &partial, commit_write_fn); 1276 if (!partial) 1277 SetPageUptodate(page); 1278 if (pos > inode->i_size) 1279 i_size_write(inode, pos); 1280 EXT4_I(inode)->i_state |= EXT4_STATE_JDATA; 1281 if (inode->i_size > EXT4_I(inode)->i_disksize) { 1282 EXT4_I(inode)->i_disksize = inode->i_size; 1283 ret2 = ext4_mark_inode_dirty(handle, inode); 1284 if (!ret) 1285 ret = ret2; 1286 } 1287 ret2 = ext4_journal_stop(handle); 1288 if (!ret) 1289 ret = ret2; 1290 return ret; 1291} 1292 1293/* 1294 * bmap() is special. It gets used by applications such as lilo and by 1295 * the swapper to find the on-disk block of a specific piece of data. 1296 * 1297 * Naturally, this is dangerous if the block concerned is still in the 1298 * journal. If somebody makes a swapfile on an ext4 data-journaling 1299 * filesystem and enables swap, then they may get a nasty shock when the 1300 * data getting swapped to that swapfile suddenly gets overwritten by 1301 * the original zero's written out previously to the journal and 1302 * awaiting writeback in the kernel's buffer cache. 1303 * 1304 * So, if we see any bmap calls here on a modified, data-journaled file, 1305 * take extra steps to flush any blocks which might be in the cache. 1306 */ 1307static sector_t ext4_bmap(struct address_space *mapping, sector_t block) 1308{ 1309 struct inode *inode = mapping->host; 1310 journal_t *journal; 1311 int err; 1312 1313 if (EXT4_I(inode)->i_state & EXT4_STATE_JDATA) { 1314 /* 1315 * This is a REALLY heavyweight approach, but the use of 1316 * bmap on dirty files is expected to be extremely rare: 1317 * only if we run lilo or swapon on a freshly made file 1318 * do we expect this to happen. 1319 * 1320 * (bmap requires CAP_SYS_RAWIO so this does not 1321 * represent an unprivileged user DOS attack --- we'd be 1322 * in trouble if mortal users could trigger this path at 1323 * will.) 1324 * 1325 * NB. EXT4_STATE_JDATA is not set on files other than 1326 * regular files. If somebody wants to bmap a directory 1327 * or symlink and gets confused because the buffer 1328 * hasn't yet been flushed to disk, they deserve 1329 * everything they get. 1330 */ 1331 1332 EXT4_I(inode)->i_state &= ~EXT4_STATE_JDATA; 1333 journal = EXT4_JOURNAL(inode); 1334 jbd2_journal_lock_updates(journal); 1335 err = jbd2_journal_flush(journal); 1336 jbd2_journal_unlock_updates(journal); 1337 1338 if (err) 1339 return 0; 1340 } 1341 1342 return generic_block_bmap(mapping,block,ext4_get_block); 1343} 1344 1345static int bget_one(handle_t *handle, struct buffer_head *bh) 1346{ 1347 get_bh(bh); 1348 return 0; 1349} 1350 1351static int bput_one(handle_t *handle, struct buffer_head *bh) 1352{ 1353 put_bh(bh); 1354 return 0; 1355} 1356 1357static int jbd2_journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh) 1358{ 1359 if (buffer_mapped(bh)) 1360 return ext4_journal_dirty_data(handle, bh); 1361 return 0; 1362} 1363 1364static int ext4_ordered_writepage(struct page *page, 1365 struct writeback_control *wbc) 1366{ 1367 struct inode *inode = page->mapping->host; 1368 struct buffer_head *page_bufs; 1369 handle_t *handle = NULL; 1370 int ret = 0; 1371 int err; 1372 1373 J_ASSERT(PageLocked(page)); 1374 1375 /* 1376 * We give up here if we're reentered, because it might be for a 1377 * different filesystem. 1378 */ 1379 if (ext4_journal_current_handle()) 1380 goto out_fail; 1381 1382 handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode)); 1383 1384 if (IS_ERR(handle)) { 1385 ret = PTR_ERR(handle); 1386 goto out_fail; 1387 } 1388 1389 if (!page_has_buffers(page)) { 1390 create_empty_buffers(page, inode->i_sb->s_blocksize, 1391 (1 << BH_Dirty)|(1 << BH_Uptodate)); 1392 } 1393 page_bufs = page_buffers(page); 1394 walk_page_buffers(handle, page_bufs, 0, 1395 PAGE_CACHE_SIZE, NULL, bget_one); 1396 1397 ret = block_write_full_page(page, ext4_get_block, wbc); 1398 1399 /* 1400 * The page can become unlocked at any point now, and 1401 * truncate can then come in and change things. So we 1402 * can't touch *page from now on. But *page_bufs is 1403 * safe due to elevated refcount. 1404 */ 1405 1406 /* 1407 * And attach them to the current transaction. But only if 1408 * block_write_full_page() succeeded. Otherwise they are unmapped, 1409 * and generally junk. 1410 */ 1411 if (ret == 0) { 1412 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE, 1413 NULL, jbd2_journal_dirty_data_fn); 1414 if (!ret) 1415 ret = err; 1416 } 1417 walk_page_buffers(handle, page_bufs, 0, 1418 PAGE_CACHE_SIZE, NULL, bput_one); 1419 err = ext4_journal_stop(handle); 1420 if (!ret) 1421 ret = err; 1422 return ret; 1423 1424out_fail: 1425 redirty_page_for_writepage(wbc, page); 1426 unlock_page(page); 1427 return ret; 1428} 1429 1430static int ext4_writeback_writepage(struct page *page, 1431 struct writeback_control *wbc) 1432{ 1433 struct inode *inode = page->mapping->host; 1434 handle_t *handle = NULL; 1435 int ret = 0; 1436 int err; 1437 1438 if (ext4_journal_current_handle()) 1439 goto out_fail; 1440 1441 handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode)); 1442 if (IS_ERR(handle)) { 1443 ret = PTR_ERR(handle); 1444 goto out_fail; 1445 } 1446 1447 if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode)) 1448 ret = nobh_writepage(page, ext4_get_block, wbc); 1449 else 1450 ret = block_write_full_page(page, ext4_get_block, wbc); 1451 1452 err = ext4_journal_stop(handle); 1453 if (!ret) 1454 ret = err; 1455 return ret; 1456 1457out_fail: 1458 redirty_page_for_writepage(wbc, page); 1459 unlock_page(page); 1460 return ret; 1461} 1462 1463static int ext4_journalled_writepage(struct page *page, 1464 struct writeback_control *wbc) 1465{ 1466 struct inode *inode = page->mapping->host; 1467 handle_t *handle = NULL; 1468 int ret = 0; 1469 int err; 1470 1471 if (ext4_journal_current_handle()) 1472 goto no_write; 1473 1474 handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode)); 1475 if (IS_ERR(handle)) { 1476 ret = PTR_ERR(handle); 1477 goto no_write; 1478 } 1479 1480 if (!page_has_buffers(page) || PageChecked(page)) { 1481 /* 1482 * It's mmapped pagecache. Add buffers and journal it. There 1483 * doesn't seem much point in redirtying the page here. 1484 */ 1485 ClearPageChecked(page); 1486 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE, 1487 ext4_get_block); 1488 if (ret != 0) { 1489 ext4_journal_stop(handle); 1490 goto out_unlock; 1491 } 1492 ret = walk_page_buffers(handle, page_buffers(page), 0, 1493 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access); 1494 1495 err = walk_page_buffers(handle, page_buffers(page), 0, 1496 PAGE_CACHE_SIZE, NULL, commit_write_fn); 1497 if (ret == 0) 1498 ret = err; 1499 EXT4_I(inode)->i_state |= EXT4_STATE_JDATA; 1500 unlock_page(page); 1501 } else { 1502 /* 1503 * It may be a page full of checkpoint-mode buffers. We don't 1504 * really know unless we go poke around in the buffer_heads. 1505 * But block_write_full_page will do the right thing. 1506 */ 1507 ret = block_write_full_page(page, ext4_get_block, wbc); 1508 } 1509 err = ext4_journal_stop(handle); 1510 if (!ret) 1511 ret = err; 1512out: 1513 return ret; 1514 1515no_write: 1516 redirty_page_for_writepage(wbc, page); 1517out_unlock: 1518 unlock_page(page); 1519 goto out; 1520} 1521 1522static int ext4_readpage(struct file *file, struct page *page) 1523{ 1524 return mpage_readpage(page, ext4_get_block); 1525} 1526 1527static int 1528ext4_readpages(struct file *file, struct address_space *mapping, 1529 struct list_head *pages, unsigned nr_pages) 1530{ 1531 return mpage_readpages(mapping, pages, nr_pages, ext4_get_block); 1532} 1533 1534static void ext4_invalidatepage(struct page *page, unsigned long offset) 1535{ 1536 journal_t *journal = EXT4_JOURNAL(page->mapping->host); 1537 1538 /* 1539 * If it's a full truncate we just forget about the pending dirtying 1540 */ 1541 if (offset == 0) 1542 ClearPageChecked(page); 1543 1544 jbd2_journal_invalidatepage(journal, page, offset); 1545} 1546 1547static int ext4_releasepage(struct page *page, gfp_t wait) 1548{ 1549 journal_t *journal = EXT4_JOURNAL(page->mapping->host); 1550 1551 WARN_ON(PageChecked(page)); 1552 if (!page_has_buffers(page)) 1553 return 0; 1554 return jbd2_journal_try_to_free_buffers(journal, page, wait); 1555} 1556 1557/* 1558 * If the O_DIRECT write will extend the file then add this inode to the 1559 * orphan list. So recovery will truncate it back to the original size 1560 * if the machine crashes during the write. 1561 * 1562 * If the O_DIRECT write is intantiating holes inside i_size and the machine 1563 * crashes then stale disk data _may_ be exposed inside the file. 1564 */ 1565static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb, 1566 const struct iovec *iov, loff_t offset, 1567 unsigned long nr_segs) 1568{ 1569 struct file *file = iocb->ki_filp; 1570 struct inode *inode = file->f_mapping->host; 1571 struct ext4_inode_info *ei = EXT4_I(inode); 1572 handle_t *handle = NULL; 1573 ssize_t ret; 1574 int orphan = 0; 1575 size_t count = iov_length(iov, nr_segs); 1576 1577 if (rw == WRITE) { 1578 loff_t final_size = offset + count; 1579 1580 handle = ext4_journal_start(inode, DIO_CREDITS); 1581 if (IS_ERR(handle)) { 1582 ret = PTR_ERR(handle); 1583 goto out; 1584 } 1585 if (final_size > inode->i_size) { 1586 ret = ext4_orphan_add(handle, inode); 1587 if (ret) 1588 goto out_stop; 1589 orphan = 1; 1590 ei->i_disksize = inode->i_size; 1591 } 1592 } 1593 1594 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 1595 offset, nr_segs, 1596 ext4_get_block, NULL); 1597 1598 /* 1599 * Reacquire the handle: ext4_get_block() can restart the transaction 1600 */ 1601 handle = ext4_journal_current_handle(); 1602 1603out_stop: 1604 if (handle) { 1605 int err; 1606 1607 if (orphan && inode->i_nlink) 1608 ext4_orphan_del(handle, inode); 1609 if (orphan && ret > 0) { 1610 loff_t end = offset + ret; 1611 if (end > inode->i_size) { 1612 ei->i_disksize = end; 1613 i_size_write(inode, end); 1614 /* 1615 * We're going to return a positive `ret' 1616 * here due to non-zero-length I/O, so there's 1617 * no way of reporting error returns from 1618 * ext4_mark_inode_dirty() to userspace. So 1619 * ignore it. 1620 */ 1621 ext4_mark_inode_dirty(handle, inode); 1622 } 1623 } 1624 err = ext4_journal_stop(handle); 1625 if (ret == 0) 1626 ret = err; 1627 } 1628out: 1629 return ret; 1630} 1631 1632/* 1633 * Pages can be marked dirty completely asynchronously from ext4's journalling 1634 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do 1635 * much here because ->set_page_dirty is called under VFS locks. The page is 1636 * not necessarily locked. 1637 * 1638 * We cannot just dirty the page and leave attached buffers clean, because the 1639 * buffers' dirty state is "definitive". We cannot just set the buffers dirty 1640 * or jbddirty because all the journalling code will explode. 1641 * 1642 * So what we do is to mark the page "pending dirty" and next time writepage 1643 * is called, propagate that into the buffers appropriately. 1644 */ 1645static int ext4_journalled_set_page_dirty(struct page *page) 1646{ 1647 SetPageChecked(page); 1648 return __set_page_dirty_nobuffers(page); 1649} 1650 1651static const struct address_space_operations ext4_ordered_aops = { 1652 .readpage = ext4_readpage, 1653 .readpages = ext4_readpages, 1654 .writepage = ext4_ordered_writepage, 1655 .sync_page = block_sync_page, 1656 .prepare_write = ext4_prepare_write, 1657 .commit_write = ext4_ordered_commit_write, 1658 .bmap = ext4_bmap, 1659 .invalidatepage = ext4_invalidatepage, 1660 .releasepage = ext4_releasepage, 1661 .direct_IO = ext4_direct_IO, 1662 .migratepage = buffer_migrate_page, 1663}; 1664 1665static const struct address_space_operations ext4_writeback_aops = { 1666 .readpage = ext4_readpage, 1667 .readpages = ext4_readpages, 1668 .writepage = ext4_writeback_writepage, 1669 .sync_page = block_sync_page, 1670 .prepare_write = ext4_prepare_write, 1671 .commit_write = ext4_writeback_commit_write, 1672 .bmap = ext4_bmap, 1673 .invalidatepage = ext4_invalidatepage, 1674 .releasepage = ext4_releasepage, 1675 .direct_IO = ext4_direct_IO, 1676 .migratepage = buffer_migrate_page, 1677}; 1678 1679static const struct address_space_operations ext4_journalled_aops = { 1680 .readpage = ext4_readpage, 1681 .readpages = ext4_readpages, 1682 .writepage = ext4_journalled_writepage, 1683 .sync_page = block_sync_page, 1684 .prepare_write = ext4_prepare_write, 1685 .commit_write = ext4_journalled_commit_write, 1686 .set_page_dirty = ext4_journalled_set_page_dirty, 1687 .bmap = ext4_bmap, 1688 .invalidatepage = ext4_invalidatepage, 1689 .releasepage = ext4_releasepage, 1690}; 1691 1692void ext4_set_aops(struct inode *inode) 1693{ 1694 if (ext4_should_order_data(inode)) 1695 inode->i_mapping->a_ops = &ext4_ordered_aops; 1696 else if (ext4_should_writeback_data(inode)) 1697 inode->i_mapping->a_ops = &ext4_writeback_aops; 1698 else 1699 inode->i_mapping->a_ops = &ext4_journalled_aops; 1700} 1701 1702/* 1703 * ext4_block_truncate_page() zeroes out a mapping from file offset `from' 1704 * up to the end of the block which corresponds to `from'. 1705 * This required during truncate. We need to physically zero the tail end 1706 * of that block so it doesn't yield old data if the file is later grown. 1707 */ 1708int ext4_block_truncate_page(handle_t *handle, struct page *page, 1709 struct address_space *mapping, loff_t from) 1710{ 1711 ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT; 1712 unsigned offset = from & (PAGE_CACHE_SIZE-1); 1713 unsigned blocksize, iblock, length, pos; 1714 struct inode *inode = mapping->host; 1715 struct buffer_head *bh; 1716 int err = 0; 1717 void *kaddr; 1718 1719 blocksize = inode->i_sb->s_blocksize; 1720 length = blocksize - (offset & (blocksize - 1)); 1721 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); 1722 1723 /* 1724 * For "nobh" option, we can only work if we don't need to 1725 * read-in the page - otherwise we create buffers to do the IO. 1726 */ 1727 if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) && 1728 ext4_should_writeback_data(inode) && PageUptodate(page)) { 1729 kaddr = kmap_atomic(page, KM_USER0); 1730 memset(kaddr + offset, 0, length); 1731 flush_dcache_page(page); 1732 kunmap_atomic(kaddr, KM_USER0); 1733 set_page_dirty(page); 1734 goto unlock; 1735 } 1736 1737 if (!page_has_buffers(page)) 1738 create_empty_buffers(page, blocksize, 0); 1739 1740 /* Find the buffer that contains "offset" */ 1741 bh = page_buffers(page); 1742 pos = blocksize; 1743 while (offset >= pos) { 1744 bh = bh->b_this_page; 1745 iblock++; 1746 pos += blocksize; 1747 } 1748 1749 err = 0; 1750 if (buffer_freed(bh)) { 1751 BUFFER_TRACE(bh, "freed: skip"); 1752 goto unlock; 1753 } 1754 1755 if (!buffer_mapped(bh)) { 1756 BUFFER_TRACE(bh, "unmapped"); 1757 ext4_get_block(inode, iblock, bh, 0); 1758 /* unmapped? It's a hole - nothing to do */ 1759 if (!buffer_mapped(bh)) { 1760 BUFFER_TRACE(bh, "still unmapped"); 1761 goto unlock; 1762 } 1763 } 1764 1765 /* Ok, it's mapped. Make sure it's up-to-date */ 1766 if (PageUptodate(page)) 1767 set_buffer_uptodate(bh); 1768 1769 if (!buffer_uptodate(bh)) { 1770 err = -EIO; 1771 ll_rw_block(READ, 1, &bh); 1772 wait_on_buffer(bh); 1773 /* Uhhuh. Read error. Complain and punt. */ 1774 if (!buffer_uptodate(bh)) 1775 goto unlock; 1776 } 1777 1778 if (ext4_should_journal_data(inode)) { 1779 BUFFER_TRACE(bh, "get write access"); 1780 err = ext4_journal_get_write_access(handle, bh); 1781 if (err) 1782 goto unlock; 1783 } 1784 1785 kaddr = kmap_atomic(page, KM_USER0); 1786 memset(kaddr + offset, 0, length); 1787 flush_dcache_page(page); 1788 kunmap_atomic(kaddr, KM_USER0); 1789 1790 BUFFER_TRACE(bh, "zeroed end of block"); 1791 1792 err = 0; 1793 if (ext4_should_journal_data(inode)) { 1794 err = ext4_journal_dirty_metadata(handle, bh); 1795 } else { 1796 if (ext4_should_order_data(inode)) 1797 err = ext4_journal_dirty_data(handle, bh); 1798 mark_buffer_dirty(bh); 1799 } 1800 1801unlock: 1802 unlock_page(page); 1803 page_cache_release(page); 1804 return err; 1805} 1806 1807/* 1808 * Probably it should be a library function... search for first non-zero word 1809 * or memcmp with zero_page, whatever is better for particular architecture. 1810 * Linus? 1811 */ 1812static inline int all_zeroes(__le32 *p, __le32 *q) 1813{ 1814 while (p < q) 1815 if (*p++) 1816 return 0; 1817 return 1; 1818} 1819 1820/** 1821 * ext4_find_shared - find the indirect blocks for partial truncation. 1822 * @inode: inode in question 1823 * @depth: depth of the affected branch 1824 * @offsets: offsets of pointers in that branch (see ext4_block_to_path) 1825 * @chain: place to store the pointers to partial indirect blocks 1826 * @top: place to the (detached) top of branch 1827 * 1828 * This is a helper function used by ext4_truncate(). 1829 * 1830 * When we do truncate() we may have to clean the ends of several 1831 * indirect blocks but leave the blocks themselves alive. Block is 1832 * partially truncated if some data below the new i_size is refered 1833 * from it (and it is on the path to the first completely truncated 1834 * data block, indeed). We have to free the top of that path along 1835 * with everything to the right of the path. Since no allocation 1836 * past the truncation point is possible until ext4_truncate() 1837 * finishes, we may safely do the latter, but top of branch may 1838 * require special attention - pageout below the truncation point 1839 * might try to populate it. 1840 * 1841 * We atomically detach the top of branch from the tree, store the 1842 * block number of its root in *@top, pointers to buffer_heads of 1843 * partially truncated blocks - in @chain[].bh and pointers to 1844 * their last elements that should not be removed - in 1845 * @chain[].p. Return value is the pointer to last filled element 1846 * of @chain. 1847 * 1848 * The work left to caller to do the actual freeing of subtrees: 1849 * a) free the subtree starting from *@top 1850 * b) free the subtrees whose roots are stored in 1851 * (@chain[i].p+1 .. end of @chain[i].bh->b_data) 1852 * c) free the subtrees growing from the inode past the @chain[0]. 1853 * (no partially truncated stuff there). */ 1854 1855static Indirect *ext4_find_shared(struct inode *inode, int depth, 1856 int offsets[4], Indirect chain[4], __le32 *top) 1857{ 1858 Indirect *partial, *p; 1859 int k, err; 1860 1861 *top = 0; 1862 /* Make k index the deepest non-null offest + 1 */ 1863 for (k = depth; k > 1 && !offsets[k-1]; k--) 1864 ; 1865 partial = ext4_get_branch(inode, k, offsets, chain, &err); 1866 /* Writer: pointers */ 1867 if (!partial) 1868 partial = chain + k-1; 1869 /* 1870 * If the branch acquired continuation since we've looked at it - 1871 * fine, it should all survive and (new) top doesn't belong to us. 1872 */ 1873 if (!partial->key && *partial->p) 1874 /* Writer: end */ 1875 goto no_top; 1876 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--) 1877 ; 1878 /* 1879 * OK, we've found the last block that must survive. The rest of our 1880 * branch should be detached before unlocking. However, if that rest 1881 * of branch is all ours and does not grow immediately from the inode 1882 * it's easier to cheat and just decrement partial->p. 1883 */ 1884 if (p == chain + k - 1 && p > chain) { 1885 p->p--; 1886 } else { 1887 *top = *p->p; 1888 /* Nope, don't do this in ext4. Must leave the tree intact */ 1889 } 1890 /* Writer: end */ 1891 1892 while(partial > p) { 1893 brelse(partial->bh); 1894 partial--; 1895 } 1896no_top: 1897 return partial; 1898} 1899 1900/* 1901 * Zero a number of block pointers in either an inode or an indirect block. 1902 * If we restart the transaction we must again get write access to the 1903 * indirect block for further modification. 1904 * 1905 * We release `count' blocks on disk, but (last - first) may be greater 1906 * than `count' because there can be holes in there. 1907 */ 1908static void ext4_clear_blocks(handle_t *handle, struct inode *inode, 1909 struct buffer_head *bh, ext4_fsblk_t block_to_free, 1910 unsigned long count, __le32 *first, __le32 *last) 1911{ 1912 __le32 *p; 1913 if (try_to_extend_transaction(handle, inode)) { 1914 if (bh) { 1915 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata"); 1916 ext4_journal_dirty_metadata(handle, bh); 1917 } 1918 ext4_mark_inode_dirty(handle, inode); 1919 ext4_journal_test_restart(handle, inode); 1920 if (bh) { 1921 BUFFER_TRACE(bh, "retaking write access"); 1922 ext4_journal_get_write_access(handle, bh); 1923 } 1924 } 1925 1926 /* 1927 * Any buffers which are on the journal will be in memory. We find 1928 * them on the hash table so jbd2_journal_revoke() will run jbd2_journal_forget() 1929 * on them. We've already detached each block from the file, so 1930 * bforget() in jbd2_journal_forget() should be safe. 1931 * 1932 * AKPM: turn on bforget in jbd2_journal_forget()!!! 1933 */ 1934 for (p = first; p < last; p++) { 1935 u32 nr = le32_to_cpu(*p); 1936 if (nr) { 1937 struct buffer_head *bh; 1938 1939 *p = 0; 1940 bh = sb_find_get_block(inode->i_sb, nr); 1941 ext4_forget(handle, 0, inode, bh, nr); 1942 } 1943 } 1944 1945 ext4_free_blocks(handle, inode, block_to_free, count); 1946} 1947 1948/** 1949 * ext4_free_data - free a list of data blocks 1950 * @handle: handle for this transaction 1951 * @inode: inode we are dealing with 1952 * @this_bh: indirect buffer_head which contains *@first and *@last 1953 * @first: array of block numbers 1954 * @last: points immediately past the end of array 1955 * 1956 * We are freeing all blocks refered from that array (numbers are stored as 1957 * little-endian 32-bit) and updating @inode->i_blocks appropriately. 1958 * 1959 * We accumulate contiguous runs of blocks to free. Conveniently, if these 1960 * blocks are contiguous then releasing them at one time will only affect one 1961 * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't 1962 * actually use a lot of journal space. 1963 * 1964 * @this_bh will be %NULL if @first and @last point into the inode's direct 1965 * block pointers. 1966 */ 1967static void ext4_free_data(handle_t *handle, struct inode *inode, 1968 struct buffer_head *this_bh, 1969 __le32 *first, __le32 *last) 1970{ 1971 ext4_fsblk_t block_to_free = 0; /* Starting block # of a run */ 1972 unsigned long count = 0; /* Number of blocks in the run */ 1973 __le32 *block_to_free_p = NULL; /* Pointer into inode/ind 1974 corresponding to 1975 block_to_free */ 1976 ext4_fsblk_t nr; /* Current block # */ 1977 __le32 *p; /* Pointer into inode/ind 1978 for current block */ 1979 int err; 1980 1981 if (this_bh) { /* For indirect block */ 1982 BUFFER_TRACE(this_bh, "get_write_access"); 1983 err = ext4_journal_get_write_access(handle, this_bh); 1984 /* Important: if we can't update the indirect pointers 1985 * to the blocks, we can't free them. */ 1986 if (err) 1987 return; 1988 } 1989 1990 for (p = first; p < last; p++) { 1991 nr = le32_to_cpu(*p); 1992 if (nr) { 1993 /* accumulate blocks to free if they're contiguous */ 1994 if (count == 0) { 1995 block_to_free = nr; 1996 block_to_free_p = p; 1997 count = 1; 1998 } else if (nr == block_to_free + count) { 1999 count++; 2000 } else { 2001 ext4_clear_blocks(handle, inode, this_bh, 2002 block_to_free, 2003 count, block_to_free_p, p); 2004 block_to_free = nr; 2005 block_to_free_p = p; 2006 count = 1; 2007 } 2008 } 2009 } 2010 2011 if (count > 0) 2012 ext4_clear_blocks(handle, inode, this_bh, block_to_free, 2013 count, block_to_free_p, p); 2014 2015 if (this_bh) { 2016 BUFFER_TRACE(this_bh, "call ext4_journal_dirty_metadata"); 2017 ext4_journal_dirty_metadata(handle, this_bh); 2018 } 2019} 2020 2021/** 2022 * ext4_free_branches - free an array of branches 2023 * @handle: JBD handle for this transaction 2024 * @inode: inode we are dealing with 2025 * @parent_bh: the buffer_head which contains *@first and *@last 2026 * @first: array of block numbers 2027 * @last: pointer immediately past the end of array 2028 * @depth: depth of the branches to free 2029 * 2030 * We are freeing all blocks refered from these branches (numbers are 2031 * stored as little-endian 32-bit) and updating @inode->i_blocks 2032 * appropriately. 2033 */ 2034static void ext4_free_branches(handle_t *handle, struct inode *inode, 2035 struct buffer_head *parent_bh, 2036 __le32 *first, __le32 *last, int depth) 2037{ 2038 ext4_fsblk_t nr; 2039 __le32 *p; 2040 2041 if (is_handle_aborted(handle)) 2042 return; 2043 2044 if (depth--) { 2045 struct buffer_head *bh; 2046 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); 2047 p = last; 2048 while (--p >= first) { 2049 nr = le32_to_cpu(*p); 2050 if (!nr) 2051 continue; /* A hole */ 2052 2053 /* Go read the buffer for the next level down */ 2054 bh = sb_bread(inode->i_sb, nr); 2055 2056 /* 2057 * A read failure? Report error and clear slot 2058 * (should be rare). 2059 */ 2060 if (!bh) { 2061 ext4_error(inode->i_sb, "ext4_free_branches", 2062 "Read failure, inode=%lu, block=%llu", 2063 inode->i_ino, nr); 2064 continue; 2065 } 2066 2067 /* This zaps the entire block. Bottom up. */ 2068 BUFFER_TRACE(bh, "free child branches"); 2069 ext4_free_branches(handle, inode, bh, 2070 (__le32*)bh->b_data, 2071 (__le32*)bh->b_data + addr_per_block, 2072 depth); 2073 2074 /* 2075 * We've probably journalled the indirect block several 2076 * times during the truncate. But it's no longer 2077 * needed and we now drop it from the transaction via 2078 * jbd2_journal_revoke(). 2079 * 2080 * That's easy if it's exclusively part of this 2081 * transaction. But if it's part of the committing 2082 * transaction then jbd2_journal_forget() will simply 2083 * brelse() it. That means that if the underlying 2084 * block is reallocated in ext4_get_block(), 2085 * unmap_underlying_metadata() will find this block 2086 * and will try to get rid of it. damn, damn. 2087 * 2088 * If this block has already been committed to the 2089 * journal, a revoke record will be written. And 2090 * revoke records must be emitted *before* clearing 2091 * this block's bit in the bitmaps. 2092 */ 2093 ext4_forget(handle, 1, inode, bh, bh->b_blocknr); 2094 2095 /* 2096 * Everything below this this pointer has been 2097 * released. Now let this top-of-subtree go. 2098 * 2099 * We want the freeing of this indirect block to be 2100 * atomic in the journal with the updating of the 2101 * bitmap block which owns it. So make some room in 2102 * the journal. 2103 * 2104 * We zero the parent pointer *after* freeing its 2105 * pointee in the bitmaps, so if extend_transaction() 2106 * for some reason fails to put the bitmap changes and 2107 * the release into the same transaction, recovery 2108 * will merely complain about releasing a free block, 2109 * rather than leaking blocks. 2110 */ 2111 if (is_handle_aborted(handle)) 2112 return; 2113 if (try_to_extend_transaction(handle, inode)) { 2114 ext4_mark_inode_dirty(handle, inode); 2115 ext4_journal_test_restart(handle, inode); 2116 } 2117 2118 ext4_free_blocks(handle, inode, nr, 1); 2119 2120 if (parent_bh) { 2121 /* 2122 * The block which we have just freed is 2123 * pointed to by an indirect block: journal it 2124 */ 2125 BUFFER_TRACE(parent_bh, "get_write_access"); 2126 if (!ext4_journal_get_write_access(handle, 2127 parent_bh)){ 2128 *p = 0; 2129 BUFFER_TRACE(parent_bh, 2130 "call ext4_journal_dirty_metadata"); 2131 ext4_journal_dirty_metadata(handle, 2132 parent_bh); 2133 } 2134 } 2135 } 2136 } else { 2137 /* We have reached the bottom of the tree. */ 2138 BUFFER_TRACE(parent_bh, "free data blocks"); 2139 ext4_free_data(handle, inode, parent_bh, first, last); 2140 } 2141} 2142 2143/* 2144 * ext4_truncate() 2145 * 2146 * We block out ext4_get_block() block instantiations across the entire 2147 * transaction, and VFS/VM ensures that ext4_truncate() cannot run 2148 * simultaneously on behalf of the same inode. 2149 * 2150 * As we work through the truncate and commmit bits of it to the journal there 2151 * is one core, guiding principle: the file's tree must always be consistent on 2152 * disk. We must be able to restart the truncate after a crash. 2153 * 2154 * The file's tree may be transiently inconsistent in memory (although it 2155 * probably isn't), but whenever we close off and commit a journal transaction, 2156 * the contents of (the filesystem + the journal) must be consistent and 2157 * restartable. It's pretty simple, really: bottom up, right to left (although 2158 * left-to-right works OK too). 2159 * 2160 * Note that at recovery time, journal replay occurs *before* the restart of 2161 * truncate against the orphan inode list. 2162 * 2163 * The committed inode has the new, desired i_size (which is the same as 2164 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see 2165 * that this inode's truncate did not complete and it will again call 2166 * ext4_truncate() to have another go. So there will be instantiated blocks 2167 * to the right of the truncation point in a crashed ext4 filesystem. But 2168 * that's fine - as long as they are linked from the inode, the post-crash 2169 * ext4_truncate() run will find them and release them. 2170 */ 2171void ext4_truncate(struct inode *inode) 2172{ 2173 handle_t *handle; 2174 struct ext4_inode_info *ei = EXT4_I(inode); 2175 __le32 *i_data = ei->i_data; 2176 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); 2177 struct address_space *mapping = inode->i_mapping; 2178 int offsets[4]; 2179 Indirect chain[4]; 2180 Indirect *partial; 2181 __le32 nr = 0; 2182 int n; 2183 long last_block; 2184 unsigned blocksize = inode->i_sb->s_blocksize; 2185 struct page *page; 2186 2187 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 2188 S_ISLNK(inode->i_mode))) 2189 return; 2190 if (ext4_inode_is_fast_symlink(inode)) 2191 return; 2192 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 2193 return; 2194 2195 /* 2196 * We have to lock the EOF page here, because lock_page() nests 2197 * outside jbd2_journal_start(). 2198 */ 2199 if ((inode->i_size & (blocksize - 1)) == 0) { 2200 /* Block boundary? Nothing to do */ 2201 page = NULL; 2202 } else { 2203 page = grab_cache_page(mapping, 2204 inode->i_size >> PAGE_CACHE_SHIFT); 2205 if (!page) 2206 return; 2207 } 2208 2209 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) 2210 return ext4_ext_truncate(inode, page); 2211 2212 handle = start_transaction(inode); 2213 if (IS_ERR(handle)) { 2214 if (page) { 2215 clear_highpage(page); 2216 flush_dcache_page(page); 2217 unlock_page(page); 2218 page_cache_release(page); 2219 } 2220 return; /* AKPM: return what? */ 2221 } 2222 2223 last_block = (inode->i_size + blocksize-1) 2224 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); 2225 2226 if (page) 2227 ext4_block_truncate_page(handle, page, mapping, inode->i_size); 2228 2229 n = ext4_block_to_path(inode, last_block, offsets, NULL); 2230 if (n == 0) 2231 goto out_stop; /* error */ 2232 2233 /* 2234 * OK. This truncate is going to happen. We add the inode to the 2235 * orphan list, so that if this truncate spans multiple transactions, 2236 * and we crash, we will resume the truncate when the filesystem 2237 * recovers. It also marks the inode dirty, to catch the new size. 2238 * 2239 * Implication: the file must always be in a sane, consistent 2240 * truncatable state while each transaction commits. 2241 */ 2242 if (ext4_orphan_add(handle, inode)) 2243 goto out_stop; 2244 2245 /* 2246 * The orphan list entry will now protect us from any crash which 2247 * occurs before the truncate completes, so it is now safe to propagate 2248 * the new, shorter inode size (held for now in i_size) into the 2249 * on-disk inode. We do this via i_disksize, which is the value which 2250 * ext4 *really* writes onto the disk inode. 2251 */ 2252 ei->i_disksize = inode->i_size; 2253 2254 /* 2255 * From here we block out all ext4_get_block() callers who want to 2256 * modify the block allocation tree. 2257 */ 2258 mutex_lock(&ei->truncate_mutex); 2259 2260 if (n == 1) { /* direct blocks */ 2261 ext4_free_data(handle, inode, NULL, i_data+offsets[0], 2262 i_data + EXT4_NDIR_BLOCKS); 2263 goto do_indirects; 2264 } 2265 2266 partial = ext4_find_shared(inode, n, offsets, chain, &nr); 2267 /* Kill the top of shared branch (not detached) */ 2268 if (nr) { 2269 if (partial == chain) { 2270 /* Shared branch grows from the inode */ 2271 ext4_free_branches(handle, inode, NULL, 2272 &nr, &nr+1, (chain+n-1) - partial); 2273 *partial->p = 0; 2274 /* 2275 * We mark the inode dirty prior to restart, 2276 * and prior to stop. No need for it here. 2277 */ 2278 } else { 2279 /* Shared branch grows from an indirect block */ 2280 BUFFER_TRACE(partial->bh, "get_write_access"); 2281 ext4_free_branches(handle, inode, partial->bh, 2282 partial->p, 2283 partial->p+1, (chain+n-1) - partial); 2284 } 2285 } 2286 /* Clear the ends of indirect blocks on the shared branch */ 2287 while (partial > chain) { 2288 ext4_free_branches(handle, inode, partial->bh, partial->p + 1, 2289 (__le32*)partial->bh->b_data+addr_per_block, 2290 (chain+n-1) - partial); 2291 BUFFER_TRACE(partial->bh, "call brelse"); 2292 brelse (partial->bh); 2293 partial--; 2294 } 2295do_indirects: 2296 /* Kill the remaining (whole) subtrees */ 2297 switch (offsets[0]) { 2298 default: 2299 nr = i_data[EXT4_IND_BLOCK]; 2300 if (nr) { 2301 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 1); 2302 i_data[EXT4_IND_BLOCK] = 0; 2303 } 2304 case EXT4_IND_BLOCK: 2305 nr = i_data[EXT4_DIND_BLOCK]; 2306 if (nr) { 2307 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 2); 2308 i_data[EXT4_DIND_BLOCK] = 0; 2309 } 2310 case EXT4_DIND_BLOCK: 2311 nr = i_data[EXT4_TIND_BLOCK]; 2312 if (nr) { 2313 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 3); 2314 i_data[EXT4_TIND_BLOCK] = 0; 2315 } 2316 case EXT4_TIND_BLOCK: 2317 ; 2318 } 2319 2320 ext4_discard_reservation(inode); 2321 2322 mutex_unlock(&ei->truncate_mutex); 2323 inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC; 2324 ext4_mark_inode_dirty(handle, inode); 2325 2326 /* 2327 * In a multi-transaction truncate, we only make the final transaction 2328 * synchronous 2329 */ 2330 if (IS_SYNC(inode)) 2331 handle->h_sync = 1; 2332out_stop: 2333 /* 2334 * If this was a simple ftruncate(), and the file will remain alive 2335 * then we need to clear up the orphan record which we created above. 2336 * However, if this was a real unlink then we were called by 2337 * ext4_delete_inode(), and we allow that function to clean up the 2338 * orphan info for us. 2339 */ 2340 if (inode->i_nlink) 2341 ext4_orphan_del(handle, inode); 2342 2343 ext4_journal_stop(handle); 2344} 2345 2346static ext4_fsblk_t ext4_get_inode_block(struct super_block *sb, 2347 unsigned long ino, struct ext4_iloc *iloc) 2348{ 2349 unsigned long desc, group_desc, block_group; 2350 unsigned long offset; 2351 ext4_fsblk_t block; 2352 struct buffer_head *bh; 2353 struct ext4_group_desc * gdp; 2354 2355 if (!ext4_valid_inum(sb, ino)) { 2356 /* 2357 * This error is already checked for in namei.c unless we are 2358 * looking at an NFS filehandle, in which case no error 2359 * report is needed 2360 */ 2361 return 0; 2362 } 2363 2364 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb); 2365 if (block_group >= EXT4_SB(sb)->s_groups_count) { 2366 ext4_error(sb,"ext4_get_inode_block","group >= groups count"); 2367 return 0; 2368 } 2369 smp_rmb(); 2370 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb); 2371 desc = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1); 2372 bh = EXT4_SB(sb)->s_group_desc[group_desc]; 2373 if (!bh) { 2374 ext4_error (sb, "ext4_get_inode_block", 2375 "Descriptor not loaded"); 2376 return 0; 2377 } 2378 2379 gdp = (struct ext4_group_desc *)((__u8 *)bh->b_data + 2380 desc * EXT4_DESC_SIZE(sb)); 2381 /* 2382 * Figure out the offset within the block group inode table 2383 */ 2384 offset = ((ino - 1) % EXT4_INODES_PER_GROUP(sb)) * 2385 EXT4_INODE_SIZE(sb); 2386 block = ext4_inode_table(sb, gdp) + 2387 (offset >> EXT4_BLOCK_SIZE_BITS(sb)); 2388 2389 iloc->block_group = block_group; 2390 iloc->offset = offset & (EXT4_BLOCK_SIZE(sb) - 1); 2391 return block; 2392} 2393 2394/* 2395 * ext4_get_inode_loc returns with an extra refcount against the inode's 2396 * underlying buffer_head on success. If 'in_mem' is true, we have all 2397 * data in memory that is needed to recreate the on-disk version of this 2398 * inode. 2399 */ 2400static int __ext4_get_inode_loc(struct inode *inode, 2401 struct ext4_iloc *iloc, int in_mem) 2402{ 2403 ext4_fsblk_t block; 2404 struct buffer_head *bh; 2405 2406 block = ext4_get_inode_block(inode->i_sb, inode->i_ino, iloc); 2407 if (!block) 2408 return -EIO; 2409 2410 bh = sb_getblk(inode->i_sb, block); 2411 if (!bh) { 2412 ext4_error (inode->i_sb, "ext4_get_inode_loc", 2413 "unable to read inode block - " 2414 "inode=%lu, block=%llu", 2415 inode->i_ino, block); 2416 return -EIO; 2417 } 2418 if (!buffer_uptodate(bh)) { 2419 lock_buffer(bh); 2420 if (buffer_uptodate(bh)) { 2421 /* someone brought it uptodate while we waited */ 2422 unlock_buffer(bh); 2423 goto has_buffer; 2424 } 2425 2426 /* 2427 * If we have all information of the inode in memory and this 2428 * is the only valid inode in the block, we need not read the 2429 * block. 2430 */ 2431 if (in_mem) { 2432 struct buffer_head *bitmap_bh; 2433 struct ext4_group_desc *desc; 2434 int inodes_per_buffer; 2435 int inode_offset, i; 2436 int block_group; 2437 int start; 2438 2439 block_group = (inode->i_ino - 1) / 2440 EXT4_INODES_PER_GROUP(inode->i_sb); 2441 inodes_per_buffer = bh->b_size / 2442 EXT4_INODE_SIZE(inode->i_sb); 2443 inode_offset = ((inode->i_ino - 1) % 2444 EXT4_INODES_PER_GROUP(inode->i_sb)); 2445 start = inode_offset & ~(inodes_per_buffer - 1); 2446 2447 /* Is the inode bitmap in cache? */ 2448 desc = ext4_get_group_desc(inode->i_sb, 2449 block_group, NULL); 2450 if (!desc) 2451 goto make_io; 2452 2453 bitmap_bh = sb_getblk(inode->i_sb, 2454 ext4_inode_bitmap(inode->i_sb, desc)); 2455 if (!bitmap_bh) 2456 goto make_io; 2457 2458 /* 2459 * If the inode bitmap isn't in cache then the 2460 * optimisation may end up performing two reads instead 2461 * of one, so skip it. 2462 */ 2463 if (!buffer_uptodate(bitmap_bh)) { 2464 brelse(bitmap_bh); 2465 goto make_io; 2466 } 2467 for (i = start; i < start + inodes_per_buffer; i++) { 2468 if (i == inode_offset) 2469 continue; 2470 if (ext4_test_bit(i, bitmap_bh->b_data)) 2471 break; 2472 } 2473 brelse(bitmap_bh); 2474 if (i == start + inodes_per_buffer) { 2475 /* all other inodes are free, so skip I/O */ 2476 memset(bh->b_data, 0, bh->b_size); 2477 set_buffer_uptodate(bh); 2478 unlock_buffer(bh); 2479 goto has_buffer; 2480 } 2481 } 2482 2483make_io: 2484 /* 2485 * There are other valid inodes in the buffer, this inode 2486 * has in-inode xattrs, or we don't have this inode in memory. 2487 * Read the block from disk. 2488 */ 2489 get_bh(bh); 2490 bh->b_end_io = end_buffer_read_sync; 2491 submit_bh(READ_META, bh); 2492 wait_on_buffer(bh); 2493 if (!buffer_uptodate(bh)) { 2494 ext4_error(inode->i_sb, "ext4_get_inode_loc", 2495 "unable to read inode block - " 2496 "inode=%lu, block=%llu", 2497 inode->i_ino, block); 2498 brelse(bh); 2499 return -EIO; 2500 } 2501 } 2502has_buffer: 2503 iloc->bh = bh; 2504 return 0; 2505} 2506 2507int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc) 2508{ 2509 /* We have all inode data except xattrs in memory here. */ 2510 return __ext4_get_inode_loc(inode, iloc, 2511 !(EXT4_I(inode)->i_state & EXT4_STATE_XATTR)); 2512} 2513 2514void ext4_set_inode_flags(struct inode *inode) 2515{ 2516 unsigned int flags = EXT4_I(inode)->i_flags; 2517 2518 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC); 2519 if (flags & EXT4_SYNC_FL) 2520 inode->i_flags |= S_SYNC; 2521 if (flags & EXT4_APPEND_FL) 2522 inode->i_flags |= S_APPEND; 2523 if (flags & EXT4_IMMUTABLE_FL) 2524 inode->i_flags |= S_IMMUTABLE; 2525 if (flags & EXT4_NOATIME_FL) 2526 inode->i_flags |= S_NOATIME; 2527 if (flags & EXT4_DIRSYNC_FL) 2528 inode->i_flags |= S_DIRSYNC; 2529} 2530 2531void ext4_read_inode(struct inode * inode) 2532{ 2533 struct ext4_iloc iloc; 2534 struct ext4_inode *raw_inode; 2535 struct ext4_inode_info *ei = EXT4_I(inode); 2536 struct buffer_head *bh; 2537 int block; 2538 2539#ifdef CONFIG_EXT4DEV_FS_POSIX_ACL 2540 ei->i_acl = EXT4_ACL_NOT_CACHED; 2541 ei->i_default_acl = EXT4_ACL_NOT_CACHED; 2542#endif 2543 ei->i_block_alloc_info = NULL; 2544 2545 if (__ext4_get_inode_loc(inode, &iloc, 0)) 2546 goto bad_inode; 2547 bh = iloc.bh; 2548 raw_inode = ext4_raw_inode(&iloc); 2549 inode->i_mode = le16_to_cpu(raw_inode->i_mode); 2550 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low); 2551 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low); 2552 if(!(test_opt (inode->i_sb, NO_UID32))) { 2553 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16; 2554 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16; 2555 } 2556 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count); 2557 inode->i_size = le32_to_cpu(raw_inode->i_size); 2558 inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime); 2559 inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime); 2560 inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime); 2561 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0; 2562 2563 ei->i_state = 0; 2564 ei->i_dir_start_lookup = 0; 2565 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime); 2566 /* We now have enough fields to check if the inode was active or not. 2567 * This is needed because nfsd might try to access dead inodes 2568 * the test is that same one that e2fsck uses 2569 * NeilBrown 1999oct15 2570 */ 2571 if (inode->i_nlink == 0) { 2572 if (inode->i_mode == 0 || 2573 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) { 2574 /* this inode is deleted */ 2575 brelse (bh); 2576 goto bad_inode; 2577 } 2578 /* The only unlinked inodes we let through here have 2579 * valid i_mode and are being read by the orphan 2580 * recovery code: that's fine, we're about to complete 2581 * the process of deleting those. */ 2582 } 2583 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks); 2584 ei->i_flags = le32_to_cpu(raw_inode->i_flags); 2585#ifdef EXT4_FRAGMENTS 2586 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr); 2587 ei->i_frag_no = raw_inode->i_frag; 2588 ei->i_frag_size = raw_inode->i_fsize; 2589#endif 2590 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl); 2591 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != 2592 cpu_to_le32(EXT4_OS_HURD)) 2593 ei->i_file_acl |= 2594 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32; 2595 if (!S_ISREG(inode->i_mode)) { 2596 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl); 2597 } else { 2598 inode->i_size |= 2599 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32; 2600 } 2601 ei->i_disksize = inode->i_size; 2602 inode->i_generation = le32_to_cpu(raw_inode->i_generation); 2603 ei->i_block_group = iloc.block_group; 2604 /* 2605 * NOTE! The in-memory inode i_data array is in little-endian order 2606 * even on big-endian machines: we do NOT byteswap the block numbers! 2607 */ 2608 for (block = 0; block < EXT4_N_BLOCKS; block++) 2609 ei->i_data[block] = raw_inode->i_block[block]; 2610 INIT_LIST_HEAD(&ei->i_orphan); 2611 2612 if (inode->i_ino >= EXT4_FIRST_INO(inode->i_sb) + 1 && 2613 EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { 2614 /* 2615 * When mke2fs creates big inodes it does not zero out 2616 * the unused bytes above EXT4_GOOD_OLD_INODE_SIZE, 2617 * so ignore those first few inodes. 2618 */ 2619 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize); 2620 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize > 2621 EXT4_INODE_SIZE(inode->i_sb)) { 2622 brelse (bh); 2623 goto bad_inode; 2624 } 2625 if (ei->i_extra_isize == 0) { 2626 /* The extra space is currently unused. Use it. */ 2627 ei->i_extra_isize = sizeof(struct ext4_inode) - 2628 EXT4_GOOD_OLD_INODE_SIZE; 2629 } else { 2630 __le32 *magic = (void *)raw_inode + 2631 EXT4_GOOD_OLD_INODE_SIZE + 2632 ei->i_extra_isize; 2633 if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) 2634 ei->i_state |= EXT4_STATE_XATTR; 2635 } 2636 } else 2637 ei->i_extra_isize = 0; 2638 2639 if (S_ISREG(inode->i_mode)) { 2640 inode->i_op = &ext4_file_inode_operations; 2641 inode->i_fop = &ext4_file_operations; 2642 ext4_set_aops(inode); 2643 } else if (S_ISDIR(inode->i_mode)) { 2644 inode->i_op = &ext4_dir_inode_operations; 2645 inode->i_fop = &ext4_dir_operations; 2646 } else if (S_ISLNK(inode->i_mode)) { 2647 if (ext4_inode_is_fast_symlink(inode)) 2648 inode->i_op = &ext4_fast_symlink_inode_operations; 2649 else { 2650 inode->i_op = &ext4_symlink_inode_operations; 2651 ext4_set_aops(inode); 2652 } 2653 } else { 2654 inode->i_op = &ext4_special_inode_operations; 2655 if (raw_inode->i_block[0]) 2656 init_special_inode(inode, inode->i_mode, 2657 old_decode_dev(le32_to_cpu(raw_inode->i_block[0]))); 2658 else 2659 init_special_inode(inode, inode->i_mode, 2660 new_decode_dev(le32_to_cpu(raw_inode->i_block[1]))); 2661 } 2662 brelse (iloc.bh); 2663 ext4_set_inode_flags(inode); 2664 return; 2665 2666bad_inode: 2667 make_bad_inode(inode); 2668 return; 2669} 2670 2671/* 2672 * Post the struct inode info into an on-disk inode location in the 2673 * buffer-cache. This gobbles the caller's reference to the 2674 * buffer_head in the inode location struct. 2675 * 2676 * The caller must have write access to iloc->bh. 2677 */ 2678static int ext4_do_update_inode(handle_t *handle, 2679 struct inode *inode, 2680 struct ext4_iloc *iloc) 2681{ 2682 struct ext4_inode *raw_inode = ext4_raw_inode(iloc); 2683 struct ext4_inode_info *ei = EXT4_I(inode); 2684 struct buffer_head *bh = iloc->bh; 2685 int err = 0, rc, block; 2686 2687 /* For fields not not tracking in the in-memory inode, 2688 * initialise them to zero for new inodes. */ 2689 if (ei->i_state & EXT4_STATE_NEW) 2690 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); 2691 2692 raw_inode->i_mode = cpu_to_le16(inode->i_mode); 2693 if(!(test_opt(inode->i_sb, NO_UID32))) { 2694 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid)); 2695 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid)); 2696/* 2697 * Fix up interoperability with old kernels. Otherwise, old inodes get 2698 * re-used with the upper 16 bits of the uid/gid intact 2699 */ 2700 if(!ei->i_dtime) { 2701 raw_inode->i_uid_high = 2702 cpu_to_le16(high_16_bits(inode->i_uid)); 2703 raw_inode->i_gid_high = 2704 cpu_to_le16(high_16_bits(inode->i_gid)); 2705 } else { 2706 raw_inode->i_uid_high = 0; 2707 raw_inode->i_gid_high = 0; 2708 } 2709 } else { 2710 raw_inode->i_uid_low = 2711 cpu_to_le16(fs_high2lowuid(inode->i_uid)); 2712 raw_inode->i_gid_low = 2713 cpu_to_le16(fs_high2lowgid(inode->i_gid)); 2714 raw_inode->i_uid_high = 0; 2715 raw_inode->i_gid_high = 0; 2716 } 2717 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); 2718 raw_inode->i_size = cpu_to_le32(ei->i_disksize); 2719 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec); 2720 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec); 2721 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec); 2722 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks); 2723 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime); 2724 raw_inode->i_flags = cpu_to_le32(ei->i_flags); 2725#ifdef EXT4_FRAGMENTS 2726 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr); 2727 raw_inode->i_frag = ei->i_frag_no; 2728 raw_inode->i_fsize = ei->i_frag_size; 2729#endif 2730 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != 2731 cpu_to_le32(EXT4_OS_HURD)) 2732 raw_inode->i_file_acl_high = 2733 cpu_to_le16(ei->i_file_acl >> 32); 2734 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl); 2735 if (!S_ISREG(inode->i_mode)) { 2736 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl); 2737 } else { 2738 raw_inode->i_size_high = 2739 cpu_to_le32(ei->i_disksize >> 32); 2740 if (ei->i_disksize > 0x7fffffffULL) { 2741 struct super_block *sb = inode->i_sb; 2742 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 2743 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) || 2744 EXT4_SB(sb)->s_es->s_rev_level == 2745 cpu_to_le32(EXT4_GOOD_OLD_REV)) { 2746 /* If this is the first large file 2747 * created, add a flag to the superblock. 2748 */ 2749 err = ext4_journal_get_write_access(handle, 2750 EXT4_SB(sb)->s_sbh); 2751 if (err) 2752 goto out_brelse; 2753 ext4_update_dynamic_rev(sb); 2754 EXT4_SET_RO_COMPAT_FEATURE(sb, 2755 EXT4_FEATURE_RO_COMPAT_LARGE_FILE); 2756 sb->s_dirt = 1; 2757 handle->h_sync = 1; 2758 err = ext4_journal_dirty_metadata(handle, 2759 EXT4_SB(sb)->s_sbh); 2760 } 2761 } 2762 } 2763 raw_inode->i_generation = cpu_to_le32(inode->i_generation); 2764 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 2765 if (old_valid_dev(inode->i_rdev)) { 2766 raw_inode->i_block[0] = 2767 cpu_to_le32(old_encode_dev(inode->i_rdev)); 2768 raw_inode->i_block[1] = 0; 2769 } else { 2770 raw_inode->i_block[0] = 0; 2771 raw_inode->i_block[1] = 2772 cpu_to_le32(new_encode_dev(inode->i_rdev)); 2773 raw_inode->i_block[2] = 0; 2774 } 2775 } else for (block = 0; block < EXT4_N_BLOCKS; block++) 2776 raw_inode->i_block[block] = ei->i_data[block]; 2777 2778 if (ei->i_extra_isize) 2779 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize); 2780 2781 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata"); 2782 rc = ext4_journal_dirty_metadata(handle, bh); 2783 if (!err) 2784 err = rc; 2785 ei->i_state &= ~EXT4_STATE_NEW; 2786 2787out_brelse: 2788 brelse (bh); 2789 ext4_std_error(inode->i_sb, err); 2790 return err; 2791} 2792 2793/* 2794 * ext4_write_inode() 2795 * 2796 * We are called from a few places: 2797 * 2798 * - Within generic_file_write() for O_SYNC files. 2799 * Here, there will be no transaction running. We wait for any running 2800 * trasnaction to commit. 2801 * 2802 * - Within sys_sync(), kupdate and such. 2803 * We wait on commit, if tol to. 2804 * 2805 * - Within prune_icache() (PF_MEMALLOC == true) 2806 * Here we simply return. We can't afford to block kswapd on the 2807 * journal commit. 2808 * 2809 * In all cases it is actually safe for us to return without doing anything, 2810 * because the inode has been copied into a raw inode buffer in 2811 * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for 2812 * knfsd. 2813 * 2814 * Note that we are absolutely dependent upon all inode dirtiers doing the 2815 * right thing: they *must* call mark_inode_dirty() after dirtying info in 2816 * which we are interested. 2817 * 2818 * It would be a bug for them to not do this. The code: 2819 * 2820 * mark_inode_dirty(inode) 2821 * stuff(); 2822 * inode->i_size = expr; 2823 * 2824 * is in error because a kswapd-driven write_inode() could occur while 2825 * `stuff()' is running, and the new i_size will be lost. Plus the inode 2826 * will no longer be on the superblock's dirty inode list. 2827 */ 2828int ext4_write_inode(struct inode *inode, int wait) 2829{ 2830 if (current->flags & PF_MEMALLOC) 2831 return 0; 2832 2833 if (ext4_journal_current_handle()) { 2834 jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n"); 2835 dump_stack(); 2836 return -EIO; 2837 } 2838 2839 if (!wait) 2840 return 0; 2841 2842 return ext4_force_commit(inode->i_sb); 2843} 2844 2845/* 2846 * ext4_setattr() 2847 * 2848 * Called from notify_change. 2849 * 2850 * We want to trap VFS attempts to truncate the file as soon as 2851 * possible. In particular, we want to make sure that when the VFS 2852 * shrinks i_size, we put the inode on the orphan list and modify 2853 * i_disksize immediately, so that during the subsequent flushing of 2854 * dirty pages and freeing of disk blocks, we can guarantee that any 2855 * commit will leave the blocks being flushed in an unused state on 2856 * disk. (On recovery, the inode will get truncated and the blocks will 2857 * be freed, so we have a strong guarantee that no future commit will 2858 * leave these blocks visible to the user.) 2859 * 2860 * Called with inode->sem down. 2861 */ 2862int ext4_setattr(struct dentry *dentry, struct iattr *attr) 2863{ 2864 struct inode *inode = dentry->d_inode; 2865 int error, rc = 0; 2866 const unsigned int ia_valid = attr->ia_valid; 2867 2868 error = inode_change_ok(inode, attr); 2869 if (error) 2870 return error; 2871 2872 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) || 2873 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) { 2874 handle_t *handle; 2875 2876 /* (user+group)*(old+new) structure, inode write (sb, 2877 * inode block, ? - but truncate inode update has it) */ 2878 handle = ext4_journal_start(inode, 2*(EXT4_QUOTA_INIT_BLOCKS(inode->i_sb)+ 2879 EXT4_QUOTA_DEL_BLOCKS(inode->i_sb))+3); 2880 if (IS_ERR(handle)) { 2881 error = PTR_ERR(handle); 2882 goto err_out; 2883 } 2884 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0; 2885 if (error) { 2886 ext4_journal_stop(handle); 2887 return error; 2888 } 2889 /* Update corresponding info in inode so that everything is in 2890 * one transaction */ 2891 if (attr->ia_valid & ATTR_UID) 2892 inode->i_uid = attr->ia_uid; 2893 if (attr->ia_valid & ATTR_GID) 2894 inode->i_gid = attr->ia_gid; 2895 error = ext4_mark_inode_dirty(handle, inode); 2896 ext4_journal_stop(handle); 2897 } 2898 2899 if (S_ISREG(inode->i_mode) && 2900 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) { 2901 handle_t *handle; 2902 2903 handle = ext4_journal_start(inode, 3); 2904 if (IS_ERR(handle)) { 2905 error = PTR_ERR(handle); 2906 goto err_out; 2907 } 2908 2909 error = ext4_orphan_add(handle, inode); 2910 EXT4_I(inode)->i_disksize = attr->ia_size; 2911 rc = ext4_mark_inode_dirty(handle, inode); 2912 if (!error) 2913 error = rc; 2914 ext4_journal_stop(handle); 2915 } 2916 2917 rc = inode_setattr(inode, attr); 2918 2919 /* If inode_setattr's call to ext4_truncate failed to get a 2920 * transaction handle at all, we need to clean up the in-core 2921 * orphan list manually. */ 2922 if (inode->i_nlink) 2923 ext4_orphan_del(NULL, inode); 2924 2925 if (!rc && (ia_valid & ATTR_MODE)) 2926 rc = ext4_acl_chmod(inode); 2927 2928err_out: 2929 ext4_std_error(inode->i_sb, error); 2930 if (!error) 2931 error = rc; 2932 return error; 2933} 2934 2935 2936/* 2937 * How many blocks doth make a writepage()? 2938 * 2939 * With N blocks per page, it may be: 2940 * N data blocks 2941 * 2 indirect block 2942 * 2 dindirect 2943 * 1 tindirect 2944 * N+5 bitmap blocks (from the above) 2945 * N+5 group descriptor summary blocks 2946 * 1 inode block 2947 * 1 superblock. 2948 * 2 * EXT4_SINGLEDATA_TRANS_BLOCKS for the quote files 2949 * 2950 * 3 * (N + 5) + 2 + 2 * EXT4_SINGLEDATA_TRANS_BLOCKS 2951 * 2952 * With ordered or writeback data it's the same, less the N data blocks. 2953 * 2954 * If the inode's direct blocks can hold an integral number of pages then a 2955 * page cannot straddle two indirect blocks, and we can only touch one indirect 2956 * and dindirect block, and the "5" above becomes "3". 2957 * 2958 * This still overestimates under most circumstances. If we were to pass the 2959 * start and end offsets in here as well we could do block_to_path() on each 2960 * block and work out the exact number of indirects which are touched. Pah. 2961 */ 2962 2963int ext4_writepage_trans_blocks(struct inode *inode) 2964{ 2965 int bpp = ext4_journal_blocks_per_page(inode); 2966 int indirects = (EXT4_NDIR_BLOCKS % bpp) ? 5 : 3; 2967 int ret; 2968 2969 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) 2970 return ext4_ext_writepage_trans_blocks(inode, bpp); 2971 2972 if (ext4_should_journal_data(inode)) 2973 ret = 3 * (bpp + indirects) + 2; 2974 else 2975 ret = 2 * (bpp + indirects) + 2; 2976 2977#ifdef CONFIG_QUOTA 2978 /* We know that structure was already allocated during DQUOT_INIT so 2979 * we will be updating only the data blocks + inodes */ 2980 ret += 2*EXT4_QUOTA_TRANS_BLOCKS(inode->i_sb); 2981#endif 2982 2983 return ret; 2984} 2985 2986/* 2987 * The caller must have previously called ext4_reserve_inode_write(). 2988 * Give this, we know that the caller already has write access to iloc->bh. 2989 */ 2990int ext4_mark_iloc_dirty(handle_t *handle, 2991 struct inode *inode, struct ext4_iloc *iloc) 2992{ 2993 int err = 0; 2994 2995 /* the do_update_inode consumes one bh->b_count */ 2996 get_bh(iloc->bh); 2997 2998 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */ 2999 err = ext4_do_update_inode(handle, inode, iloc); 3000 put_bh(iloc->bh); 3001 return err; 3002} 3003 3004/* 3005 * On success, We end up with an outstanding reference count against 3006 * iloc->bh. This _must_ be cleaned up later. 3007 */ 3008 3009int 3010ext4_reserve_inode_write(handle_t *handle, struct inode *inode, 3011 struct ext4_iloc *iloc) 3012{ 3013 int err = 0; 3014 if (handle) { 3015 err = ext4_get_inode_loc(inode, iloc); 3016 if (!err) { 3017 BUFFER_TRACE(iloc->bh, "get_write_access"); 3018 err = ext4_journal_get_write_access(handle, iloc->bh); 3019 if (err) { 3020 brelse(iloc->bh); 3021 iloc->bh = NULL; 3022 } 3023 } 3024 } 3025 ext4_std_error(inode->i_sb, err); 3026 return err; 3027} 3028 3029/* 3030 * What we do here is to mark the in-core inode as clean with respect to inode 3031 * dirtiness (it may still be data-dirty). 3032 * This means that the in-core inode may be reaped by prune_icache 3033 * without having to perform any I/O. This is a very good thing, 3034 * because *any* task may call prune_icache - even ones which 3035 * have a transaction open against a different journal. 3036 * 3037 * Is this cheating? Not really. Sure, we haven't written the 3038 * inode out, but prune_icache isn't a user-visible syncing function. 3039 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync) 3040 * we start and wait on commits. 3041 * 3042 * Is this efficient/effective? Well, we're being nice to the system 3043 * by cleaning up our inodes proactively so they can be reaped 3044 * without I/O. But we are potentially leaving up to five seconds' 3045 * worth of inodes floating about which prune_icache wants us to 3046 * write out. One way to fix that would be to get prune_icache() 3047 * to do a write_super() to free up some memory. It has the desired 3048 * effect. 3049 */ 3050int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode) 3051{ 3052 struct ext4_iloc iloc; 3053 int err; 3054 3055 might_sleep(); 3056 err = ext4_reserve_inode_write(handle, inode, &iloc); 3057 if (!err) 3058 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 3059 return err; 3060} 3061 3062/* 3063 * ext4_dirty_inode() is called from __mark_inode_dirty() 3064 * 3065 * We're really interested in the case where a file is being extended. 3066 * i_size has been changed by generic_commit_write() and we thus need 3067 * to include the updated inode in the current transaction. 3068 * 3069 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks 3070 * are allocated to the file. 3071 * 3072 * If the inode is marked synchronous, we don't honour that here - doing 3073 * so would cause a commit on atime updates, which we don't bother doing. 3074 * We handle synchronous inodes at the highest possible level. 3075 */ 3076void ext4_dirty_inode(struct inode *inode) 3077{ 3078 handle_t *current_handle = ext4_journal_current_handle(); 3079 handle_t *handle; 3080 3081 handle = ext4_journal_start(inode, 2); 3082 if (IS_ERR(handle)) 3083 goto out; 3084 if (current_handle && 3085 current_handle->h_transaction != handle->h_transaction) { 3086 /* This task has a transaction open against a different fs */ 3087 printk(KERN_EMERG "%s: transactions do not match!\n", 3088 __FUNCTION__); 3089 } else { 3090 jbd_debug(5, "marking dirty. outer handle=%p\n", 3091 current_handle); 3092 ext4_mark_inode_dirty(handle, inode); 3093 } 3094 ext4_journal_stop(handle); 3095out: 3096 return; 3097} 3098 3099 3100int ext4_change_inode_journal_flag(struct inode *inode, int val) 3101{ 3102 journal_t *journal; 3103 handle_t *handle; 3104 int err; 3105 3106 /* 3107 * We have to be very careful here: changing a data block's 3108 * journaling status dynamically is dangerous. If we write a 3109 * data block to the journal, change the status and then delete 3110 * that block, we risk forgetting to revoke the old log record 3111 * from the journal and so a subsequent replay can corrupt data. 3112 * So, first we make sure that the journal is empty and that 3113 * nobody is changing anything. 3114 */ 3115 3116 journal = EXT4_JOURNAL(inode); 3117 if (is_journal_aborted(journal) || IS_RDONLY(inode)) 3118 return -EROFS; 3119 3120 jbd2_journal_lock_updates(journal); 3121 jbd2_journal_flush(journal); 3122 3123 /* 3124 * OK, there are no updates running now, and all cached data is 3125 * synced to disk. We are now in a completely consistent state 3126 * which doesn't have anything in the journal, and we know that 3127 * no filesystem updates are running, so it is safe to modify 3128 * the inode's in-core data-journaling state flag now. 3129 */ 3130 3131 if (val) 3132 EXT4_I(inode)->i_flags |= EXT4_JOURNAL_DATA_FL; 3133 else 3134 EXT4_I(inode)->i_flags &= ~EXT4_JOURNAL_DATA_FL; 3135 ext4_set_aops(inode); 3136 3137 jbd2_journal_unlock_updates(journal); 3138 3139 /* Finally we can mark the inode as dirty. */ 3140 3141 handle = ext4_journal_start(inode, 1); 3142 if (IS_ERR(handle)) 3143 return PTR_ERR(handle); 3144 3145 err = ext4_mark_inode_dirty(handle, inode); 3146 handle->h_sync = 1; 3147 ext4_journal_stop(handle); 3148 ext4_std_error(inode->i_sb, err); 3149 3150 return err; 3151} 3152