1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/fs.h> 20 #include <linux/pagemap.h> 21 #include <linux/highmem.h> 22 #include <linux/time.h> 23 #include <linux/init.h> 24 #include <linux/string.h> 25 #include <linux/backing-dev.h> 26 #include <linux/mpage.h> 27 #include <linux/falloc.h> 28 #include <linux/swap.h> 29 #include <linux/writeback.h> 30 #include <linux/statfs.h> 31 #include <linux/compat.h> 32 #include <linux/slab.h> 33 #include "ctree.h" 34 #include "disk-io.h" 35 #include "transaction.h" 36 #include "btrfs_inode.h" 37 #include "ioctl.h" 38 #include "print-tree.h" 39 #include "tree-log.h" 40 #include "locking.h" 41 #include "compat.h" 42 43 /* 44 * when auto defrag is enabled we 45 * queue up these defrag structs to remember which 46 * inodes need defragging passes 47 */ 48 struct inode_defrag { 49 struct rb_node rb_node; 50 /* objectid */ 51 u64 ino; 52 /* 53 * transid where the defrag was added, we search for 54 * extents newer than this 55 */ 56 u64 transid; 57 58 /* root objectid */ 59 u64 root; 60 61 /* last offset we were able to defrag */ 62 u64 last_offset; 63 64 /* if we've wrapped around back to zero once already */ 65 int cycled; 66 }; 67 68 static int __compare_inode_defrag(struct inode_defrag *defrag1, 69 struct inode_defrag *defrag2) 70 { 71 if (defrag1->root > defrag2->root) 72 return 1; 73 else if (defrag1->root < defrag2->root) 74 return -1; 75 else if (defrag1->ino > defrag2->ino) 76 return 1; 77 else if (defrag1->ino < defrag2->ino) 78 return -1; 79 else 80 return 0; 81 } 82 83 /* pop a record for an inode into the defrag tree. The lock 84 * must be held already 85 * 86 * If you're inserting a record for an older transid than an 87 * existing record, the transid already in the tree is lowered 88 * 89 * If an existing record is found the defrag item you 90 * pass in is freed 91 */ 92 static void __btrfs_add_inode_defrag(struct inode *inode, 93 struct inode_defrag *defrag) 94 { 95 struct btrfs_root *root = BTRFS_I(inode)->root; 96 struct inode_defrag *entry; 97 struct rb_node **p; 98 struct rb_node *parent = NULL; 99 int ret; 100 101 p = &root->fs_info->defrag_inodes.rb_node; 102 while (*p) { 103 parent = *p; 104 entry = rb_entry(parent, struct inode_defrag, rb_node); 105 106 ret = __compare_inode_defrag(defrag, entry); 107 if (ret < 0) 108 p = &parent->rb_left; 109 else if (ret > 0) 110 p = &parent->rb_right; 111 else { 112 /* if we're reinserting an entry for 113 * an old defrag run, make sure to 114 * lower the transid of our existing record 115 */ 116 if (defrag->transid < entry->transid) 117 entry->transid = defrag->transid; 118 if (defrag->last_offset > entry->last_offset) 119 entry->last_offset = defrag->last_offset; 120 goto exists; 121 } 122 } 123 set_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags); 124 rb_link_node(&defrag->rb_node, parent, p); 125 rb_insert_color(&defrag->rb_node, &root->fs_info->defrag_inodes); 126 return; 127 128 exists: 129 kfree(defrag); 130 return; 131 132 } 133 134 /* 135 * insert a defrag record for this inode if auto defrag is 136 * enabled 137 */ 138 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 139 struct inode *inode) 140 { 141 struct btrfs_root *root = BTRFS_I(inode)->root; 142 struct inode_defrag *defrag; 143 u64 transid; 144 145 if (!btrfs_test_opt(root, AUTO_DEFRAG)) 146 return 0; 147 148 if (btrfs_fs_closing(root->fs_info)) 149 return 0; 150 151 if (test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags)) 152 return 0; 153 154 if (trans) 155 transid = trans->transid; 156 else 157 transid = BTRFS_I(inode)->root->last_trans; 158 159 defrag = kzalloc(sizeof(*defrag), GFP_NOFS); 160 if (!defrag) 161 return -ENOMEM; 162 163 defrag->ino = btrfs_ino(inode); 164 defrag->transid = transid; 165 defrag->root = root->root_key.objectid; 166 167 spin_lock(&root->fs_info->defrag_inodes_lock); 168 if (!test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags)) 169 __btrfs_add_inode_defrag(inode, defrag); 170 else 171 kfree(defrag); 172 spin_unlock(&root->fs_info->defrag_inodes_lock); 173 return 0; 174 } 175 176 /* 177 * must be called with the defrag_inodes lock held 178 */ 179 struct inode_defrag *btrfs_find_defrag_inode(struct btrfs_fs_info *info, 180 u64 root, u64 ino, 181 struct rb_node **next) 182 { 183 struct inode_defrag *entry = NULL; 184 struct inode_defrag tmp; 185 struct rb_node *p; 186 struct rb_node *parent = NULL; 187 int ret; 188 189 tmp.ino = ino; 190 tmp.root = root; 191 192 p = info->defrag_inodes.rb_node; 193 while (p) { 194 parent = p; 195 entry = rb_entry(parent, struct inode_defrag, rb_node); 196 197 ret = __compare_inode_defrag(&tmp, entry); 198 if (ret < 0) 199 p = parent->rb_left; 200 else if (ret > 0) 201 p = parent->rb_right; 202 else 203 return entry; 204 } 205 206 if (next) { 207 while (parent && __compare_inode_defrag(&tmp, entry) > 0) { 208 parent = rb_next(parent); 209 entry = rb_entry(parent, struct inode_defrag, rb_node); 210 } 211 *next = parent; 212 } 213 return NULL; 214 } 215 216 /* 217 * run through the list of inodes in the FS that need 218 * defragging 219 */ 220 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info) 221 { 222 struct inode_defrag *defrag; 223 struct btrfs_root *inode_root; 224 struct inode *inode; 225 struct rb_node *n; 226 struct btrfs_key key; 227 struct btrfs_ioctl_defrag_range_args range; 228 u64 first_ino = 0; 229 u64 root_objectid = 0; 230 int num_defrag; 231 int defrag_batch = 1024; 232 233 memset(&range, 0, sizeof(range)); 234 range.len = (u64)-1; 235 236 atomic_inc(&fs_info->defrag_running); 237 spin_lock(&fs_info->defrag_inodes_lock); 238 while(1) { 239 n = NULL; 240 241 /* find an inode to defrag */ 242 defrag = btrfs_find_defrag_inode(fs_info, root_objectid, 243 first_ino, &n); 244 if (!defrag) { 245 if (n) { 246 defrag = rb_entry(n, struct inode_defrag, 247 rb_node); 248 } else if (root_objectid || first_ino) { 249 root_objectid = 0; 250 first_ino = 0; 251 continue; 252 } else { 253 break; 254 } 255 } 256 257 /* remove it from the rbtree */ 258 first_ino = defrag->ino + 1; 259 root_objectid = defrag->root; 260 rb_erase(&defrag->rb_node, &fs_info->defrag_inodes); 261 262 if (btrfs_fs_closing(fs_info)) 263 goto next_free; 264 265 spin_unlock(&fs_info->defrag_inodes_lock); 266 267 /* get the inode */ 268 key.objectid = defrag->root; 269 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 270 key.offset = (u64)-1; 271 inode_root = btrfs_read_fs_root_no_name(fs_info, &key); 272 if (IS_ERR(inode_root)) 273 goto next; 274 275 key.objectid = defrag->ino; 276 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY); 277 key.offset = 0; 278 279 inode = btrfs_iget(fs_info->sb, &key, inode_root, NULL); 280 if (IS_ERR(inode)) 281 goto next; 282 283 /* do a chunk of defrag */ 284 clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags); 285 range.start = defrag->last_offset; 286 num_defrag = btrfs_defrag_file(inode, NULL, &range, defrag->transid, 287 defrag_batch); 288 /* 289 * if we filled the whole defrag batch, there 290 * must be more work to do. Queue this defrag 291 * again 292 */ 293 if (num_defrag == defrag_batch) { 294 defrag->last_offset = range.start; 295 __btrfs_add_inode_defrag(inode, defrag); 296 /* 297 * we don't want to kfree defrag, we added it back to 298 * the rbtree 299 */ 300 defrag = NULL; 301 } else if (defrag->last_offset && !defrag->cycled) { 302 /* 303 * we didn't fill our defrag batch, but 304 * we didn't start at zero. Make sure we loop 305 * around to the start of the file. 306 */ 307 defrag->last_offset = 0; 308 defrag->cycled = 1; 309 __btrfs_add_inode_defrag(inode, defrag); 310 defrag = NULL; 311 } 312 313 iput(inode); 314 next: 315 spin_lock(&fs_info->defrag_inodes_lock); 316 next_free: 317 kfree(defrag); 318 } 319 spin_unlock(&fs_info->defrag_inodes_lock); 320 321 atomic_dec(&fs_info->defrag_running); 322 323 /* 324 * during unmount, we use the transaction_wait queue to 325 * wait for the defragger to stop 326 */ 327 wake_up(&fs_info->transaction_wait); 328 return 0; 329 } 330 331 /* simple helper to fault in pages and copy. This should go away 332 * and be replaced with calls into generic code. 333 */ 334 static noinline int btrfs_copy_from_user(loff_t pos, int num_pages, 335 size_t write_bytes, 336 struct page **prepared_pages, 337 struct iov_iter *i) 338 { 339 size_t copied = 0; 340 size_t total_copied = 0; 341 int pg = 0; 342 int offset = pos & (PAGE_CACHE_SIZE - 1); 343 344 while (write_bytes > 0) { 345 size_t count = min_t(size_t, 346 PAGE_CACHE_SIZE - offset, write_bytes); 347 struct page *page = prepared_pages[pg]; 348 /* 349 * Copy data from userspace to the current page 350 * 351 * Disable pagefault to avoid recursive lock since 352 * the pages are already locked 353 */ 354 pagefault_disable(); 355 copied = iov_iter_copy_from_user_atomic(page, i, offset, count); 356 pagefault_enable(); 357 358 /* Flush processor's dcache for this page */ 359 flush_dcache_page(page); 360 361 /* 362 * if we get a partial write, we can end up with 363 * partially up to date pages. These add 364 * a lot of complexity, so make sure they don't 365 * happen by forcing this copy to be retried. 366 * 367 * The rest of the btrfs_file_write code will fall 368 * back to page at a time copies after we return 0. 369 */ 370 if (!PageUptodate(page) && copied < count) 371 copied = 0; 372 373 iov_iter_advance(i, copied); 374 write_bytes -= copied; 375 total_copied += copied; 376 377 /* Return to btrfs_file_aio_write to fault page */ 378 if (unlikely(copied == 0)) 379 break; 380 381 if (unlikely(copied < PAGE_CACHE_SIZE - offset)) { 382 offset += copied; 383 } else { 384 pg++; 385 offset = 0; 386 } 387 } 388 return total_copied; 389 } 390 391 /* 392 * unlocks pages after btrfs_file_write is done with them 393 */ 394 void btrfs_drop_pages(struct page **pages, size_t num_pages) 395 { 396 size_t i; 397 for (i = 0; i < num_pages; i++) { 398 /* page checked is some magic around finding pages that 399 * have been modified without going through btrfs_set_page_dirty 400 * clear it here 401 */ 402 ClearPageChecked(pages[i]); 403 unlock_page(pages[i]); 404 mark_page_accessed(pages[i]); 405 page_cache_release(pages[i]); 406 } 407 } 408 409 /* 410 * after copy_from_user, pages need to be dirtied and we need to make 411 * sure holes are created between the current EOF and the start of 412 * any next extents (if required). 413 * 414 * this also makes the decision about creating an inline extent vs 415 * doing real data extents, marking pages dirty and delalloc as required. 416 */ 417 int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode, 418 struct page **pages, size_t num_pages, 419 loff_t pos, size_t write_bytes, 420 struct extent_state **cached) 421 { 422 int err = 0; 423 int i; 424 u64 num_bytes; 425 u64 start_pos; 426 u64 end_of_last_block; 427 u64 end_pos = pos + write_bytes; 428 loff_t isize = i_size_read(inode); 429 430 start_pos = pos & ~((u64)root->sectorsize - 1); 431 num_bytes = (write_bytes + pos - start_pos + 432 root->sectorsize - 1) & ~((u64)root->sectorsize - 1); 433 434 end_of_last_block = start_pos + num_bytes - 1; 435 err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block, 436 cached); 437 if (err) 438 return err; 439 440 for (i = 0; i < num_pages; i++) { 441 struct page *p = pages[i]; 442 SetPageUptodate(p); 443 ClearPageChecked(p); 444 set_page_dirty(p); 445 } 446 447 /* 448 * we've only changed i_size in ram, and we haven't updated 449 * the disk i_size. There is no need to log the inode 450 * at this time. 451 */ 452 if (end_pos > isize) 453 i_size_write(inode, end_pos); 454 return 0; 455 } 456 457 /* 458 * this drops all the extents in the cache that intersect the range 459 * [start, end]. Existing extents are split as required. 460 */ 461 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 462 int skip_pinned) 463 { 464 struct extent_map *em; 465 struct extent_map *split = NULL; 466 struct extent_map *split2 = NULL; 467 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 468 u64 len = end - start + 1; 469 int ret; 470 int testend = 1; 471 unsigned long flags; 472 int compressed = 0; 473 474 WARN_ON(end < start); 475 if (end == (u64)-1) { 476 len = (u64)-1; 477 testend = 0; 478 } 479 while (1) { 480 if (!split) 481 split = alloc_extent_map(); 482 if (!split2) 483 split2 = alloc_extent_map(); 484 BUG_ON(!split || !split2); /* -ENOMEM */ 485 486 write_lock(&em_tree->lock); 487 em = lookup_extent_mapping(em_tree, start, len); 488 if (!em) { 489 write_unlock(&em_tree->lock); 490 break; 491 } 492 flags = em->flags; 493 if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) { 494 if (testend && em->start + em->len >= start + len) { 495 free_extent_map(em); 496 write_unlock(&em_tree->lock); 497 break; 498 } 499 start = em->start + em->len; 500 if (testend) 501 len = start + len - (em->start + em->len); 502 free_extent_map(em); 503 write_unlock(&em_tree->lock); 504 continue; 505 } 506 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 507 clear_bit(EXTENT_FLAG_PINNED, &em->flags); 508 remove_extent_mapping(em_tree, em); 509 510 if (em->block_start < EXTENT_MAP_LAST_BYTE && 511 em->start < start) { 512 split->start = em->start; 513 split->len = start - em->start; 514 split->orig_start = em->orig_start; 515 split->block_start = em->block_start; 516 517 if (compressed) 518 split->block_len = em->block_len; 519 else 520 split->block_len = split->len; 521 522 split->bdev = em->bdev; 523 split->flags = flags; 524 split->compress_type = em->compress_type; 525 ret = add_extent_mapping(em_tree, split); 526 BUG_ON(ret); /* Logic error */ 527 free_extent_map(split); 528 split = split2; 529 split2 = NULL; 530 } 531 if (em->block_start < EXTENT_MAP_LAST_BYTE && 532 testend && em->start + em->len > start + len) { 533 u64 diff = start + len - em->start; 534 535 split->start = start + len; 536 split->len = em->start + em->len - (start + len); 537 split->bdev = em->bdev; 538 split->flags = flags; 539 split->compress_type = em->compress_type; 540 541 if (compressed) { 542 split->block_len = em->block_len; 543 split->block_start = em->block_start; 544 split->orig_start = em->orig_start; 545 } else { 546 split->block_len = split->len; 547 split->block_start = em->block_start + diff; 548 split->orig_start = split->start; 549 } 550 551 ret = add_extent_mapping(em_tree, split); 552 BUG_ON(ret); /* Logic error */ 553 free_extent_map(split); 554 split = NULL; 555 } 556 write_unlock(&em_tree->lock); 557 558 /* once for us */ 559 free_extent_map(em); 560 /* once for the tree*/ 561 free_extent_map(em); 562 } 563 if (split) 564 free_extent_map(split); 565 if (split2) 566 free_extent_map(split2); 567 return 0; 568 } 569 570 /* 571 * this is very complex, but the basic idea is to drop all extents 572 * in the range start - end. hint_block is filled in with a block number 573 * that would be a good hint to the block allocator for this file. 574 * 575 * If an extent intersects the range but is not entirely inside the range 576 * it is either truncated or split. Anything entirely inside the range 577 * is deleted from the tree. 578 */ 579 int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode, 580 u64 start, u64 end, u64 *hint_byte, int drop_cache) 581 { 582 struct btrfs_root *root = BTRFS_I(inode)->root; 583 struct extent_buffer *leaf; 584 struct btrfs_file_extent_item *fi; 585 struct btrfs_path *path; 586 struct btrfs_key key; 587 struct btrfs_key new_key; 588 u64 ino = btrfs_ino(inode); 589 u64 search_start = start; 590 u64 disk_bytenr = 0; 591 u64 num_bytes = 0; 592 u64 extent_offset = 0; 593 u64 extent_end = 0; 594 int del_nr = 0; 595 int del_slot = 0; 596 int extent_type; 597 int recow; 598 int ret; 599 int modify_tree = -1; 600 601 if (drop_cache) 602 btrfs_drop_extent_cache(inode, start, end - 1, 0); 603 604 path = btrfs_alloc_path(); 605 if (!path) 606 return -ENOMEM; 607 608 if (start >= BTRFS_I(inode)->disk_i_size) 609 modify_tree = 0; 610 611 while (1) { 612 recow = 0; 613 ret = btrfs_lookup_file_extent(trans, root, path, ino, 614 search_start, modify_tree); 615 if (ret < 0) 616 break; 617 if (ret > 0 && path->slots[0] > 0 && search_start == start) { 618 leaf = path->nodes[0]; 619 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1); 620 if (key.objectid == ino && 621 key.type == BTRFS_EXTENT_DATA_KEY) 622 path->slots[0]--; 623 } 624 ret = 0; 625 next_slot: 626 leaf = path->nodes[0]; 627 if (path->slots[0] >= btrfs_header_nritems(leaf)) { 628 BUG_ON(del_nr > 0); 629 ret = btrfs_next_leaf(root, path); 630 if (ret < 0) 631 break; 632 if (ret > 0) { 633 ret = 0; 634 break; 635 } 636 leaf = path->nodes[0]; 637 recow = 1; 638 } 639 640 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 641 if (key.objectid > ino || 642 key.type > BTRFS_EXTENT_DATA_KEY || key.offset >= end) 643 break; 644 645 fi = btrfs_item_ptr(leaf, path->slots[0], 646 struct btrfs_file_extent_item); 647 extent_type = btrfs_file_extent_type(leaf, fi); 648 649 if (extent_type == BTRFS_FILE_EXTENT_REG || 650 extent_type == BTRFS_FILE_EXTENT_PREALLOC) { 651 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 652 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); 653 extent_offset = btrfs_file_extent_offset(leaf, fi); 654 extent_end = key.offset + 655 btrfs_file_extent_num_bytes(leaf, fi); 656 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 657 extent_end = key.offset + 658 btrfs_file_extent_inline_len(leaf, fi); 659 } else { 660 WARN_ON(1); 661 extent_end = search_start; 662 } 663 664 if (extent_end <= search_start) { 665 path->slots[0]++; 666 goto next_slot; 667 } 668 669 search_start = max(key.offset, start); 670 if (recow || !modify_tree) { 671 modify_tree = -1; 672 btrfs_release_path(path); 673 continue; 674 } 675 676 /* 677 * | - range to drop - | 678 * | -------- extent -------- | 679 */ 680 if (start > key.offset && end < extent_end) { 681 BUG_ON(del_nr > 0); 682 BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE); 683 684 memcpy(&new_key, &key, sizeof(new_key)); 685 new_key.offset = start; 686 ret = btrfs_duplicate_item(trans, root, path, 687 &new_key); 688 if (ret == -EAGAIN) { 689 btrfs_release_path(path); 690 continue; 691 } 692 if (ret < 0) 693 break; 694 695 leaf = path->nodes[0]; 696 fi = btrfs_item_ptr(leaf, path->slots[0] - 1, 697 struct btrfs_file_extent_item); 698 btrfs_set_file_extent_num_bytes(leaf, fi, 699 start - key.offset); 700 701 fi = btrfs_item_ptr(leaf, path->slots[0], 702 struct btrfs_file_extent_item); 703 704 extent_offset += start - key.offset; 705 btrfs_set_file_extent_offset(leaf, fi, extent_offset); 706 btrfs_set_file_extent_num_bytes(leaf, fi, 707 extent_end - start); 708 btrfs_mark_buffer_dirty(leaf); 709 710 if (disk_bytenr > 0) { 711 ret = btrfs_inc_extent_ref(trans, root, 712 disk_bytenr, num_bytes, 0, 713 root->root_key.objectid, 714 new_key.objectid, 715 start - extent_offset, 0); 716 BUG_ON(ret); /* -ENOMEM */ 717 *hint_byte = disk_bytenr; 718 } 719 key.offset = start; 720 } 721 /* 722 * | ---- range to drop ----- | 723 * | -------- extent -------- | 724 */ 725 if (start <= key.offset && end < extent_end) { 726 BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE); 727 728 memcpy(&new_key, &key, sizeof(new_key)); 729 new_key.offset = end; 730 btrfs_set_item_key_safe(trans, root, path, &new_key); 731 732 extent_offset += end - key.offset; 733 btrfs_set_file_extent_offset(leaf, fi, extent_offset); 734 btrfs_set_file_extent_num_bytes(leaf, fi, 735 extent_end - end); 736 btrfs_mark_buffer_dirty(leaf); 737 if (disk_bytenr > 0) { 738 inode_sub_bytes(inode, end - key.offset); 739 *hint_byte = disk_bytenr; 740 } 741 break; 742 } 743 744 search_start = extent_end; 745 /* 746 * | ---- range to drop ----- | 747 * | -------- extent -------- | 748 */ 749 if (start > key.offset && end >= extent_end) { 750 BUG_ON(del_nr > 0); 751 BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE); 752 753 btrfs_set_file_extent_num_bytes(leaf, fi, 754 start - key.offset); 755 btrfs_mark_buffer_dirty(leaf); 756 if (disk_bytenr > 0) { 757 inode_sub_bytes(inode, extent_end - start); 758 *hint_byte = disk_bytenr; 759 } 760 if (end == extent_end) 761 break; 762 763 path->slots[0]++; 764 goto next_slot; 765 } 766 767 /* 768 * | ---- range to drop ----- | 769 * | ------ extent ------ | 770 */ 771 if (start <= key.offset && end >= extent_end) { 772 if (del_nr == 0) { 773 del_slot = path->slots[0]; 774 del_nr = 1; 775 } else { 776 BUG_ON(del_slot + del_nr != path->slots[0]); 777 del_nr++; 778 } 779 780 if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 781 inode_sub_bytes(inode, 782 extent_end - key.offset); 783 extent_end = ALIGN(extent_end, 784 root->sectorsize); 785 } else if (disk_bytenr > 0) { 786 ret = btrfs_free_extent(trans, root, 787 disk_bytenr, num_bytes, 0, 788 root->root_key.objectid, 789 key.objectid, key.offset - 790 extent_offset, 0); 791 BUG_ON(ret); /* -ENOMEM */ 792 inode_sub_bytes(inode, 793 extent_end - key.offset); 794 *hint_byte = disk_bytenr; 795 } 796 797 if (end == extent_end) 798 break; 799 800 if (path->slots[0] + 1 < btrfs_header_nritems(leaf)) { 801 path->slots[0]++; 802 goto next_slot; 803 } 804 805 ret = btrfs_del_items(trans, root, path, del_slot, 806 del_nr); 807 if (ret) { 808 btrfs_abort_transaction(trans, root, ret); 809 goto out; 810 } 811 812 del_nr = 0; 813 del_slot = 0; 814 815 btrfs_release_path(path); 816 continue; 817 } 818 819 BUG_ON(1); 820 } 821 822 if (!ret && del_nr > 0) { 823 ret = btrfs_del_items(trans, root, path, del_slot, del_nr); 824 if (ret) 825 btrfs_abort_transaction(trans, root, ret); 826 } 827 828 out: 829 btrfs_free_path(path); 830 return ret; 831 } 832 833 static int extent_mergeable(struct extent_buffer *leaf, int slot, 834 u64 objectid, u64 bytenr, u64 orig_offset, 835 u64 *start, u64 *end) 836 { 837 struct btrfs_file_extent_item *fi; 838 struct btrfs_key key; 839 u64 extent_end; 840 841 if (slot < 0 || slot >= btrfs_header_nritems(leaf)) 842 return 0; 843 844 btrfs_item_key_to_cpu(leaf, &key, slot); 845 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY) 846 return 0; 847 848 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); 849 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG || 850 btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr || 851 btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset || 852 btrfs_file_extent_compression(leaf, fi) || 853 btrfs_file_extent_encryption(leaf, fi) || 854 btrfs_file_extent_other_encoding(leaf, fi)) 855 return 0; 856 857 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi); 858 if ((*start && *start != key.offset) || (*end && *end != extent_end)) 859 return 0; 860 861 *start = key.offset; 862 *end = extent_end; 863 return 1; 864 } 865 866 /* 867 * Mark extent in the range start - end as written. 868 * 869 * This changes extent type from 'pre-allocated' to 'regular'. If only 870 * part of extent is marked as written, the extent will be split into 871 * two or three. 872 */ 873 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, 874 struct inode *inode, u64 start, u64 end) 875 { 876 struct btrfs_root *root = BTRFS_I(inode)->root; 877 struct extent_buffer *leaf; 878 struct btrfs_path *path; 879 struct btrfs_file_extent_item *fi; 880 struct btrfs_key key; 881 struct btrfs_key new_key; 882 u64 bytenr; 883 u64 num_bytes; 884 u64 extent_end; 885 u64 orig_offset; 886 u64 other_start; 887 u64 other_end; 888 u64 split; 889 int del_nr = 0; 890 int del_slot = 0; 891 int recow; 892 int ret; 893 u64 ino = btrfs_ino(inode); 894 895 btrfs_drop_extent_cache(inode, start, end - 1, 0); 896 897 path = btrfs_alloc_path(); 898 if (!path) 899 return -ENOMEM; 900 again: 901 recow = 0; 902 split = start; 903 key.objectid = ino; 904 key.type = BTRFS_EXTENT_DATA_KEY; 905 key.offset = split; 906 907 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 908 if (ret < 0) 909 goto out; 910 if (ret > 0 && path->slots[0] > 0) 911 path->slots[0]--; 912 913 leaf = path->nodes[0]; 914 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 915 BUG_ON(key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY); 916 fi = btrfs_item_ptr(leaf, path->slots[0], 917 struct btrfs_file_extent_item); 918 BUG_ON(btrfs_file_extent_type(leaf, fi) != 919 BTRFS_FILE_EXTENT_PREALLOC); 920 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi); 921 BUG_ON(key.offset > start || extent_end < end); 922 923 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 924 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); 925 orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi); 926 memcpy(&new_key, &key, sizeof(new_key)); 927 928 if (start == key.offset && end < extent_end) { 929 other_start = 0; 930 other_end = start; 931 if (extent_mergeable(leaf, path->slots[0] - 1, 932 ino, bytenr, orig_offset, 933 &other_start, &other_end)) { 934 new_key.offset = end; 935 btrfs_set_item_key_safe(trans, root, path, &new_key); 936 fi = btrfs_item_ptr(leaf, path->slots[0], 937 struct btrfs_file_extent_item); 938 btrfs_set_file_extent_num_bytes(leaf, fi, 939 extent_end - end); 940 btrfs_set_file_extent_offset(leaf, fi, 941 end - orig_offset); 942 fi = btrfs_item_ptr(leaf, path->slots[0] - 1, 943 struct btrfs_file_extent_item); 944 btrfs_set_file_extent_num_bytes(leaf, fi, 945 end - other_start); 946 btrfs_mark_buffer_dirty(leaf); 947 goto out; 948 } 949 } 950 951 if (start > key.offset && end == extent_end) { 952 other_start = end; 953 other_end = 0; 954 if (extent_mergeable(leaf, path->slots[0] + 1, 955 ino, bytenr, orig_offset, 956 &other_start, &other_end)) { 957 fi = btrfs_item_ptr(leaf, path->slots[0], 958 struct btrfs_file_extent_item); 959 btrfs_set_file_extent_num_bytes(leaf, fi, 960 start - key.offset); 961 path->slots[0]++; 962 new_key.offset = start; 963 btrfs_set_item_key_safe(trans, root, path, &new_key); 964 965 fi = btrfs_item_ptr(leaf, path->slots[0], 966 struct btrfs_file_extent_item); 967 btrfs_set_file_extent_num_bytes(leaf, fi, 968 other_end - start); 969 btrfs_set_file_extent_offset(leaf, fi, 970 start - orig_offset); 971 btrfs_mark_buffer_dirty(leaf); 972 goto out; 973 } 974 } 975 976 while (start > key.offset || end < extent_end) { 977 if (key.offset == start) 978 split = end; 979 980 new_key.offset = split; 981 ret = btrfs_duplicate_item(trans, root, path, &new_key); 982 if (ret == -EAGAIN) { 983 btrfs_release_path(path); 984 goto again; 985 } 986 if (ret < 0) { 987 btrfs_abort_transaction(trans, root, ret); 988 goto out; 989 } 990 991 leaf = path->nodes[0]; 992 fi = btrfs_item_ptr(leaf, path->slots[0] - 1, 993 struct btrfs_file_extent_item); 994 btrfs_set_file_extent_num_bytes(leaf, fi, 995 split - key.offset); 996 997 fi = btrfs_item_ptr(leaf, path->slots[0], 998 struct btrfs_file_extent_item); 999 1000 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset); 1001 btrfs_set_file_extent_num_bytes(leaf, fi, 1002 extent_end - split); 1003 btrfs_mark_buffer_dirty(leaf); 1004 1005 ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, 0, 1006 root->root_key.objectid, 1007 ino, orig_offset, 0); 1008 BUG_ON(ret); /* -ENOMEM */ 1009 1010 if (split == start) { 1011 key.offset = start; 1012 } else { 1013 BUG_ON(start != key.offset); 1014 path->slots[0]--; 1015 extent_end = end; 1016 } 1017 recow = 1; 1018 } 1019 1020 other_start = end; 1021 other_end = 0; 1022 if (extent_mergeable(leaf, path->slots[0] + 1, 1023 ino, bytenr, orig_offset, 1024 &other_start, &other_end)) { 1025 if (recow) { 1026 btrfs_release_path(path); 1027 goto again; 1028 } 1029 extent_end = other_end; 1030 del_slot = path->slots[0] + 1; 1031 del_nr++; 1032 ret = btrfs_free_extent(trans, root, bytenr, num_bytes, 1033 0, root->root_key.objectid, 1034 ino, orig_offset, 0); 1035 BUG_ON(ret); /* -ENOMEM */ 1036 } 1037 other_start = 0; 1038 other_end = start; 1039 if (extent_mergeable(leaf, path->slots[0] - 1, 1040 ino, bytenr, orig_offset, 1041 &other_start, &other_end)) { 1042 if (recow) { 1043 btrfs_release_path(path); 1044 goto again; 1045 } 1046 key.offset = other_start; 1047 del_slot = path->slots[0]; 1048 del_nr++; 1049 ret = btrfs_free_extent(trans, root, bytenr, num_bytes, 1050 0, root->root_key.objectid, 1051 ino, orig_offset, 0); 1052 BUG_ON(ret); /* -ENOMEM */ 1053 } 1054 if (del_nr == 0) { 1055 fi = btrfs_item_ptr(leaf, path->slots[0], 1056 struct btrfs_file_extent_item); 1057 btrfs_set_file_extent_type(leaf, fi, 1058 BTRFS_FILE_EXTENT_REG); 1059 btrfs_mark_buffer_dirty(leaf); 1060 } else { 1061 fi = btrfs_item_ptr(leaf, del_slot - 1, 1062 struct btrfs_file_extent_item); 1063 btrfs_set_file_extent_type(leaf, fi, 1064 BTRFS_FILE_EXTENT_REG); 1065 btrfs_set_file_extent_num_bytes(leaf, fi, 1066 extent_end - key.offset); 1067 btrfs_mark_buffer_dirty(leaf); 1068 1069 ret = btrfs_del_items(trans, root, path, del_slot, del_nr); 1070 if (ret < 0) { 1071 btrfs_abort_transaction(trans, root, ret); 1072 goto out; 1073 } 1074 } 1075 out: 1076 btrfs_free_path(path); 1077 return 0; 1078 } 1079 1080 /* 1081 * on error we return an unlocked page and the error value 1082 * on success we return a locked page and 0 1083 */ 1084 static int prepare_uptodate_page(struct page *page, u64 pos, 1085 bool force_uptodate) 1086 { 1087 int ret = 0; 1088 1089 if (((pos & (PAGE_CACHE_SIZE - 1)) || force_uptodate) && 1090 !PageUptodate(page)) { 1091 ret = btrfs_readpage(NULL, page); 1092 if (ret) 1093 return ret; 1094 lock_page(page); 1095 if (!PageUptodate(page)) { 1096 unlock_page(page); 1097 return -EIO; 1098 } 1099 } 1100 return 0; 1101 } 1102 1103 /* 1104 * this gets pages into the page cache and locks them down, it also properly 1105 * waits for data=ordered extents to finish before allowing the pages to be 1106 * modified. 1107 */ 1108 static noinline int prepare_pages(struct btrfs_root *root, struct file *file, 1109 struct page **pages, size_t num_pages, 1110 loff_t pos, unsigned long first_index, 1111 size_t write_bytes, bool force_uptodate) 1112 { 1113 struct extent_state *cached_state = NULL; 1114 int i; 1115 unsigned long index = pos >> PAGE_CACHE_SHIFT; 1116 struct inode *inode = fdentry(file)->d_inode; 1117 gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping); 1118 int err = 0; 1119 int faili = 0; 1120 u64 start_pos; 1121 u64 last_pos; 1122 1123 start_pos = pos & ~((u64)root->sectorsize - 1); 1124 last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT; 1125 1126 again: 1127 for (i = 0; i < num_pages; i++) { 1128 pages[i] = find_or_create_page(inode->i_mapping, index + i, 1129 mask | __GFP_WRITE); 1130 if (!pages[i]) { 1131 faili = i - 1; 1132 err = -ENOMEM; 1133 goto fail; 1134 } 1135 1136 if (i == 0) 1137 err = prepare_uptodate_page(pages[i], pos, 1138 force_uptodate); 1139 if (i == num_pages - 1) 1140 err = prepare_uptodate_page(pages[i], 1141 pos + write_bytes, false); 1142 if (err) { 1143 page_cache_release(pages[i]); 1144 faili = i - 1; 1145 goto fail; 1146 } 1147 wait_on_page_writeback(pages[i]); 1148 } 1149 err = 0; 1150 if (start_pos < inode->i_size) { 1151 struct btrfs_ordered_extent *ordered; 1152 lock_extent_bits(&BTRFS_I(inode)->io_tree, 1153 start_pos, last_pos - 1, 0, &cached_state); 1154 ordered = btrfs_lookup_first_ordered_extent(inode, 1155 last_pos - 1); 1156 if (ordered && 1157 ordered->file_offset + ordered->len > start_pos && 1158 ordered->file_offset < last_pos) { 1159 btrfs_put_ordered_extent(ordered); 1160 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 1161 start_pos, last_pos - 1, 1162 &cached_state, GFP_NOFS); 1163 for (i = 0; i < num_pages; i++) { 1164 unlock_page(pages[i]); 1165 page_cache_release(pages[i]); 1166 } 1167 btrfs_wait_ordered_range(inode, start_pos, 1168 last_pos - start_pos); 1169 goto again; 1170 } 1171 if (ordered) 1172 btrfs_put_ordered_extent(ordered); 1173 1174 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos, 1175 last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC | 1176 EXTENT_DO_ACCOUNTING, 0, 0, &cached_state, 1177 GFP_NOFS); 1178 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 1179 start_pos, last_pos - 1, &cached_state, 1180 GFP_NOFS); 1181 } 1182 for (i = 0; i < num_pages; i++) { 1183 if (clear_page_dirty_for_io(pages[i])) 1184 account_page_redirty(pages[i]); 1185 set_page_extent_mapped(pages[i]); 1186 WARN_ON(!PageLocked(pages[i])); 1187 } 1188 return 0; 1189 fail: 1190 while (faili >= 0) { 1191 unlock_page(pages[faili]); 1192 page_cache_release(pages[faili]); 1193 faili--; 1194 } 1195 return err; 1196 1197 } 1198 1199 static noinline ssize_t __btrfs_buffered_write(struct file *file, 1200 struct iov_iter *i, 1201 loff_t pos) 1202 { 1203 struct inode *inode = fdentry(file)->d_inode; 1204 struct btrfs_root *root = BTRFS_I(inode)->root; 1205 struct page **pages = NULL; 1206 unsigned long first_index; 1207 size_t num_written = 0; 1208 int nrptrs; 1209 int ret = 0; 1210 bool force_page_uptodate = false; 1211 1212 nrptrs = min((iov_iter_count(i) + PAGE_CACHE_SIZE - 1) / 1213 PAGE_CACHE_SIZE, PAGE_CACHE_SIZE / 1214 (sizeof(struct page *))); 1215 nrptrs = min(nrptrs, current->nr_dirtied_pause - current->nr_dirtied); 1216 nrptrs = max(nrptrs, 8); 1217 pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL); 1218 if (!pages) 1219 return -ENOMEM; 1220 1221 first_index = pos >> PAGE_CACHE_SHIFT; 1222 1223 while (iov_iter_count(i) > 0) { 1224 size_t offset = pos & (PAGE_CACHE_SIZE - 1); 1225 size_t write_bytes = min(iov_iter_count(i), 1226 nrptrs * (size_t)PAGE_CACHE_SIZE - 1227 offset); 1228 size_t num_pages = (write_bytes + offset + 1229 PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; 1230 size_t dirty_pages; 1231 size_t copied; 1232 1233 WARN_ON(num_pages > nrptrs); 1234 1235 /* 1236 * Fault pages before locking them in prepare_pages 1237 * to avoid recursive lock 1238 */ 1239 if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) { 1240 ret = -EFAULT; 1241 break; 1242 } 1243 1244 ret = btrfs_delalloc_reserve_space(inode, 1245 num_pages << PAGE_CACHE_SHIFT); 1246 if (ret) 1247 break; 1248 1249 /* 1250 * This is going to setup the pages array with the number of 1251 * pages we want, so we don't really need to worry about the 1252 * contents of pages from loop to loop 1253 */ 1254 ret = prepare_pages(root, file, pages, num_pages, 1255 pos, first_index, write_bytes, 1256 force_page_uptodate); 1257 if (ret) { 1258 btrfs_delalloc_release_space(inode, 1259 num_pages << PAGE_CACHE_SHIFT); 1260 break; 1261 } 1262 1263 copied = btrfs_copy_from_user(pos, num_pages, 1264 write_bytes, pages, i); 1265 1266 /* 1267 * if we have trouble faulting in the pages, fall 1268 * back to one page at a time 1269 */ 1270 if (copied < write_bytes) 1271 nrptrs = 1; 1272 1273 if (copied == 0) { 1274 force_page_uptodate = true; 1275 dirty_pages = 0; 1276 } else { 1277 force_page_uptodate = false; 1278 dirty_pages = (copied + offset + 1279 PAGE_CACHE_SIZE - 1) >> 1280 PAGE_CACHE_SHIFT; 1281 } 1282 1283 /* 1284 * If we had a short copy we need to release the excess delaloc 1285 * bytes we reserved. We need to increment outstanding_extents 1286 * because btrfs_delalloc_release_space will decrement it, but 1287 * we still have an outstanding extent for the chunk we actually 1288 * managed to copy. 1289 */ 1290 if (num_pages > dirty_pages) { 1291 if (copied > 0) { 1292 spin_lock(&BTRFS_I(inode)->lock); 1293 BTRFS_I(inode)->outstanding_extents++; 1294 spin_unlock(&BTRFS_I(inode)->lock); 1295 } 1296 btrfs_delalloc_release_space(inode, 1297 (num_pages - dirty_pages) << 1298 PAGE_CACHE_SHIFT); 1299 } 1300 1301 if (copied > 0) { 1302 ret = btrfs_dirty_pages(root, inode, pages, 1303 dirty_pages, pos, copied, 1304 NULL); 1305 if (ret) { 1306 btrfs_delalloc_release_space(inode, 1307 dirty_pages << PAGE_CACHE_SHIFT); 1308 btrfs_drop_pages(pages, num_pages); 1309 break; 1310 } 1311 } 1312 1313 btrfs_drop_pages(pages, num_pages); 1314 1315 cond_resched(); 1316 1317 balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1318 dirty_pages); 1319 if (dirty_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1) 1320 btrfs_btree_balance_dirty(root, 1); 1321 1322 pos += copied; 1323 num_written += copied; 1324 } 1325 1326 kfree(pages); 1327 1328 return num_written ? num_written : ret; 1329 } 1330 1331 static ssize_t __btrfs_direct_write(struct kiocb *iocb, 1332 const struct iovec *iov, 1333 unsigned long nr_segs, loff_t pos, 1334 loff_t *ppos, size_t count, size_t ocount) 1335 { 1336 struct file *file = iocb->ki_filp; 1337 struct inode *inode = fdentry(file)->d_inode; 1338 struct iov_iter i; 1339 ssize_t written; 1340 ssize_t written_buffered; 1341 loff_t endbyte; 1342 int err; 1343 1344 written = generic_file_direct_write(iocb, iov, &nr_segs, pos, ppos, 1345 count, ocount); 1346 1347 /* 1348 * the generic O_DIRECT will update in-memory i_size after the 1349 * DIOs are done. But our endio handlers that update the on 1350 * disk i_size never update past the in memory i_size. So we 1351 * need one more update here to catch any additions to the 1352 * file 1353 */ 1354 if (inode->i_size != BTRFS_I(inode)->disk_i_size) { 1355 btrfs_ordered_update_i_size(inode, inode->i_size, NULL); 1356 mark_inode_dirty(inode); 1357 } 1358 1359 if (written < 0 || written == count) 1360 return written; 1361 1362 pos += written; 1363 count -= written; 1364 iov_iter_init(&i, iov, nr_segs, count, written); 1365 written_buffered = __btrfs_buffered_write(file, &i, pos); 1366 if (written_buffered < 0) { 1367 err = written_buffered; 1368 goto out; 1369 } 1370 endbyte = pos + written_buffered - 1; 1371 err = filemap_write_and_wait_range(file->f_mapping, pos, endbyte); 1372 if (err) 1373 goto out; 1374 written += written_buffered; 1375 *ppos = pos + written_buffered; 1376 invalidate_mapping_pages(file->f_mapping, pos >> PAGE_CACHE_SHIFT, 1377 endbyte >> PAGE_CACHE_SHIFT); 1378 out: 1379 return written ? written : err; 1380 } 1381 1382 static ssize_t btrfs_file_aio_write(struct kiocb *iocb, 1383 const struct iovec *iov, 1384 unsigned long nr_segs, loff_t pos) 1385 { 1386 struct file *file = iocb->ki_filp; 1387 struct inode *inode = fdentry(file)->d_inode; 1388 struct btrfs_root *root = BTRFS_I(inode)->root; 1389 loff_t *ppos = &iocb->ki_pos; 1390 u64 start_pos; 1391 ssize_t num_written = 0; 1392 ssize_t err = 0; 1393 size_t count, ocount; 1394 1395 vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE); 1396 1397 mutex_lock(&inode->i_mutex); 1398 1399 err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ); 1400 if (err) { 1401 mutex_unlock(&inode->i_mutex); 1402 goto out; 1403 } 1404 count = ocount; 1405 1406 current->backing_dev_info = inode->i_mapping->backing_dev_info; 1407 err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode)); 1408 if (err) { 1409 mutex_unlock(&inode->i_mutex); 1410 goto out; 1411 } 1412 1413 if (count == 0) { 1414 mutex_unlock(&inode->i_mutex); 1415 goto out; 1416 } 1417 1418 err = file_remove_suid(file); 1419 if (err) { 1420 mutex_unlock(&inode->i_mutex); 1421 goto out; 1422 } 1423 1424 /* 1425 * If BTRFS flips readonly due to some impossible error 1426 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR), 1427 * although we have opened a file as writable, we have 1428 * to stop this write operation to ensure FS consistency. 1429 */ 1430 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { 1431 mutex_unlock(&inode->i_mutex); 1432 err = -EROFS; 1433 goto out; 1434 } 1435 1436 err = file_update_time(file); 1437 if (err) { 1438 mutex_unlock(&inode->i_mutex); 1439 goto out; 1440 } 1441 1442 start_pos = round_down(pos, root->sectorsize); 1443 if (start_pos > i_size_read(inode)) { 1444 err = btrfs_cont_expand(inode, i_size_read(inode), start_pos); 1445 if (err) { 1446 mutex_unlock(&inode->i_mutex); 1447 goto out; 1448 } 1449 } 1450 1451 if (unlikely(file->f_flags & O_DIRECT)) { 1452 num_written = __btrfs_direct_write(iocb, iov, nr_segs, 1453 pos, ppos, count, ocount); 1454 } else { 1455 struct iov_iter i; 1456 1457 iov_iter_init(&i, iov, nr_segs, count, num_written); 1458 1459 num_written = __btrfs_buffered_write(file, &i, pos); 1460 if (num_written > 0) 1461 *ppos = pos + num_written; 1462 } 1463 1464 mutex_unlock(&inode->i_mutex); 1465 1466 /* 1467 * we want to make sure fsync finds this change 1468 * but we haven't joined a transaction running right now. 1469 * 1470 * Later on, someone is sure to update the inode and get the 1471 * real transid recorded. 1472 * 1473 * We set last_trans now to the fs_info generation + 1, 1474 * this will either be one more than the running transaction 1475 * or the generation used for the next transaction if there isn't 1476 * one running right now. 1477 */ 1478 BTRFS_I(inode)->last_trans = root->fs_info->generation + 1; 1479 if (num_written > 0 || num_written == -EIOCBQUEUED) { 1480 err = generic_write_sync(file, pos, num_written); 1481 if (err < 0 && num_written > 0) 1482 num_written = err; 1483 } 1484 out: 1485 current->backing_dev_info = NULL; 1486 return num_written ? num_written : err; 1487 } 1488 1489 int btrfs_release_file(struct inode *inode, struct file *filp) 1490 { 1491 /* 1492 * ordered_data_close is set by settattr when we are about to truncate 1493 * a file from a non-zero size to a zero size. This tries to 1494 * flush down new bytes that may have been written if the 1495 * application were using truncate to replace a file in place. 1496 */ 1497 if (test_and_clear_bit(BTRFS_INODE_ORDERED_DATA_CLOSE, 1498 &BTRFS_I(inode)->runtime_flags)) { 1499 btrfs_add_ordered_operation(NULL, BTRFS_I(inode)->root, inode); 1500 if (inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT) 1501 filemap_flush(inode->i_mapping); 1502 } 1503 if (filp->private_data) 1504 btrfs_ioctl_trans_end(filp); 1505 return 0; 1506 } 1507 1508 /* 1509 * fsync call for both files and directories. This logs the inode into 1510 * the tree log instead of forcing full commits whenever possible. 1511 * 1512 * It needs to call filemap_fdatawait so that all ordered extent updates are 1513 * in the metadata btree are up to date for copying to the log. 1514 * 1515 * It drops the inode mutex before doing the tree log commit. This is an 1516 * important optimization for directories because holding the mutex prevents 1517 * new operations on the dir while we write to disk. 1518 */ 1519 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) 1520 { 1521 struct dentry *dentry = file->f_path.dentry; 1522 struct inode *inode = dentry->d_inode; 1523 struct btrfs_root *root = BTRFS_I(inode)->root; 1524 int ret = 0; 1525 struct btrfs_trans_handle *trans; 1526 1527 trace_btrfs_sync_file(file, datasync); 1528 1529 mutex_lock(&inode->i_mutex); 1530 1531 /* 1532 * we wait first, since the writeback may change the inode, also wait 1533 * ordered range does a filemape_write_and_wait_range which is why we 1534 * don't do it above like other file systems. 1535 */ 1536 root->log_batch++; 1537 btrfs_wait_ordered_range(inode, start, end); 1538 root->log_batch++; 1539 1540 /* 1541 * check the transaction that last modified this inode 1542 * and see if its already been committed 1543 */ 1544 if (!BTRFS_I(inode)->last_trans) { 1545 mutex_unlock(&inode->i_mutex); 1546 goto out; 1547 } 1548 1549 /* 1550 * if the last transaction that changed this file was before 1551 * the current transaction, we can bail out now without any 1552 * syncing 1553 */ 1554 smp_mb(); 1555 if (btrfs_inode_in_log(inode, root->fs_info->generation) || 1556 BTRFS_I(inode)->last_trans <= 1557 root->fs_info->last_trans_committed) { 1558 BTRFS_I(inode)->last_trans = 0; 1559 mutex_unlock(&inode->i_mutex); 1560 goto out; 1561 } 1562 1563 /* 1564 * ok we haven't committed the transaction yet, lets do a commit 1565 */ 1566 if (file->private_data) 1567 btrfs_ioctl_trans_end(file); 1568 1569 trans = btrfs_start_transaction(root, 0); 1570 if (IS_ERR(trans)) { 1571 ret = PTR_ERR(trans); 1572 mutex_unlock(&inode->i_mutex); 1573 goto out; 1574 } 1575 1576 ret = btrfs_log_dentry_safe(trans, root, dentry); 1577 if (ret < 0) { 1578 mutex_unlock(&inode->i_mutex); 1579 goto out; 1580 } 1581 1582 /* we've logged all the items and now have a consistent 1583 * version of the file in the log. It is possible that 1584 * someone will come in and modify the file, but that's 1585 * fine because the log is consistent on disk, and we 1586 * have references to all of the file's extents 1587 * 1588 * It is possible that someone will come in and log the 1589 * file again, but that will end up using the synchronization 1590 * inside btrfs_sync_log to keep things safe. 1591 */ 1592 mutex_unlock(&inode->i_mutex); 1593 1594 if (ret != BTRFS_NO_LOG_SYNC) { 1595 if (ret > 0) { 1596 ret = btrfs_commit_transaction(trans, root); 1597 } else { 1598 ret = btrfs_sync_log(trans, root); 1599 if (ret == 0) 1600 ret = btrfs_end_transaction(trans, root); 1601 else 1602 ret = btrfs_commit_transaction(trans, root); 1603 } 1604 } else { 1605 ret = btrfs_end_transaction(trans, root); 1606 } 1607 out: 1608 return ret > 0 ? -EIO : ret; 1609 } 1610 1611 static const struct vm_operations_struct btrfs_file_vm_ops = { 1612 .fault = filemap_fault, 1613 .page_mkwrite = btrfs_page_mkwrite, 1614 }; 1615 1616 static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma) 1617 { 1618 struct address_space *mapping = filp->f_mapping; 1619 1620 if (!mapping->a_ops->readpage) 1621 return -ENOEXEC; 1622 1623 file_accessed(filp); 1624 vma->vm_ops = &btrfs_file_vm_ops; 1625 vma->vm_flags |= VM_CAN_NONLINEAR; 1626 1627 return 0; 1628 } 1629 1630 static long btrfs_fallocate(struct file *file, int mode, 1631 loff_t offset, loff_t len) 1632 { 1633 struct inode *inode = file->f_path.dentry->d_inode; 1634 struct extent_state *cached_state = NULL; 1635 u64 cur_offset; 1636 u64 last_byte; 1637 u64 alloc_start; 1638 u64 alloc_end; 1639 u64 alloc_hint = 0; 1640 u64 locked_end; 1641 u64 mask = BTRFS_I(inode)->root->sectorsize - 1; 1642 struct extent_map *em; 1643 int ret; 1644 1645 alloc_start = offset & ~mask; 1646 alloc_end = (offset + len + mask) & ~mask; 1647 1648 /* We only support the FALLOC_FL_KEEP_SIZE mode */ 1649 if (mode & ~FALLOC_FL_KEEP_SIZE) 1650 return -EOPNOTSUPP; 1651 1652 /* 1653 * Make sure we have enough space before we do the 1654 * allocation. 1655 */ 1656 ret = btrfs_check_data_free_space(inode, len); 1657 if (ret) 1658 return ret; 1659 1660 /* 1661 * wait for ordered IO before we have any locks. We'll loop again 1662 * below with the locks held. 1663 */ 1664 btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start); 1665 1666 mutex_lock(&inode->i_mutex); 1667 ret = inode_newsize_ok(inode, alloc_end); 1668 if (ret) 1669 goto out; 1670 1671 if (alloc_start > inode->i_size) { 1672 ret = btrfs_cont_expand(inode, i_size_read(inode), 1673 alloc_start); 1674 if (ret) 1675 goto out; 1676 } 1677 1678 locked_end = alloc_end - 1; 1679 while (1) { 1680 struct btrfs_ordered_extent *ordered; 1681 1682 /* the extent lock is ordered inside the running 1683 * transaction 1684 */ 1685 lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start, 1686 locked_end, 0, &cached_state); 1687 ordered = btrfs_lookup_first_ordered_extent(inode, 1688 alloc_end - 1); 1689 if (ordered && 1690 ordered->file_offset + ordered->len > alloc_start && 1691 ordered->file_offset < alloc_end) { 1692 btrfs_put_ordered_extent(ordered); 1693 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 1694 alloc_start, locked_end, 1695 &cached_state, GFP_NOFS); 1696 /* 1697 * we can't wait on the range with the transaction 1698 * running or with the extent lock held 1699 */ 1700 btrfs_wait_ordered_range(inode, alloc_start, 1701 alloc_end - alloc_start); 1702 } else { 1703 if (ordered) 1704 btrfs_put_ordered_extent(ordered); 1705 break; 1706 } 1707 } 1708 1709 cur_offset = alloc_start; 1710 while (1) { 1711 u64 actual_end; 1712 1713 em = btrfs_get_extent(inode, NULL, 0, cur_offset, 1714 alloc_end - cur_offset, 0); 1715 if (IS_ERR_OR_NULL(em)) { 1716 if (!em) 1717 ret = -ENOMEM; 1718 else 1719 ret = PTR_ERR(em); 1720 break; 1721 } 1722 last_byte = min(extent_map_end(em), alloc_end); 1723 actual_end = min_t(u64, extent_map_end(em), offset + len); 1724 last_byte = (last_byte + mask) & ~mask; 1725 1726 if (em->block_start == EXTENT_MAP_HOLE || 1727 (cur_offset >= inode->i_size && 1728 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) { 1729 ret = btrfs_prealloc_file_range(inode, mode, cur_offset, 1730 last_byte - cur_offset, 1731 1 << inode->i_blkbits, 1732 offset + len, 1733 &alloc_hint); 1734 1735 if (ret < 0) { 1736 free_extent_map(em); 1737 break; 1738 } 1739 } else if (actual_end > inode->i_size && 1740 !(mode & FALLOC_FL_KEEP_SIZE)) { 1741 /* 1742 * We didn't need to allocate any more space, but we 1743 * still extended the size of the file so we need to 1744 * update i_size. 1745 */ 1746 inode->i_ctime = CURRENT_TIME; 1747 i_size_write(inode, actual_end); 1748 btrfs_ordered_update_i_size(inode, actual_end, NULL); 1749 } 1750 free_extent_map(em); 1751 1752 cur_offset = last_byte; 1753 if (cur_offset >= alloc_end) { 1754 ret = 0; 1755 break; 1756 } 1757 } 1758 unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end, 1759 &cached_state, GFP_NOFS); 1760 out: 1761 mutex_unlock(&inode->i_mutex); 1762 /* Let go of our reservation. */ 1763 btrfs_free_reserved_data_space(inode, len); 1764 return ret; 1765 } 1766 1767 static int find_desired_extent(struct inode *inode, loff_t *offset, int origin) 1768 { 1769 struct btrfs_root *root = BTRFS_I(inode)->root; 1770 struct extent_map *em; 1771 struct extent_state *cached_state = NULL; 1772 u64 lockstart = *offset; 1773 u64 lockend = i_size_read(inode); 1774 u64 start = *offset; 1775 u64 orig_start = *offset; 1776 u64 len = i_size_read(inode); 1777 u64 last_end = 0; 1778 int ret = 0; 1779 1780 lockend = max_t(u64, root->sectorsize, lockend); 1781 if (lockend <= lockstart) 1782 lockend = lockstart + root->sectorsize; 1783 1784 len = lockend - lockstart + 1; 1785 1786 len = max_t(u64, len, root->sectorsize); 1787 if (inode->i_size == 0) 1788 return -ENXIO; 1789 1790 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, 0, 1791 &cached_state); 1792 1793 /* 1794 * Delalloc is such a pain. If we have a hole and we have pending 1795 * delalloc for a portion of the hole we will get back a hole that 1796 * exists for the entire range since it hasn't been actually written 1797 * yet. So to take care of this case we need to look for an extent just 1798 * before the position we want in case there is outstanding delalloc 1799 * going on here. 1800 */ 1801 if (origin == SEEK_HOLE && start != 0) { 1802 if (start <= root->sectorsize) 1803 em = btrfs_get_extent_fiemap(inode, NULL, 0, 0, 1804 root->sectorsize, 0); 1805 else 1806 em = btrfs_get_extent_fiemap(inode, NULL, 0, 1807 start - root->sectorsize, 1808 root->sectorsize, 0); 1809 if (IS_ERR(em)) { 1810 ret = PTR_ERR(em); 1811 goto out; 1812 } 1813 last_end = em->start + em->len; 1814 if (em->block_start == EXTENT_MAP_DELALLOC) 1815 last_end = min_t(u64, last_end, inode->i_size); 1816 free_extent_map(em); 1817 } 1818 1819 while (1) { 1820 em = btrfs_get_extent_fiemap(inode, NULL, 0, start, len, 0); 1821 if (IS_ERR(em)) { 1822 ret = PTR_ERR(em); 1823 break; 1824 } 1825 1826 if (em->block_start == EXTENT_MAP_HOLE) { 1827 if (test_bit(EXTENT_FLAG_VACANCY, &em->flags)) { 1828 if (last_end <= orig_start) { 1829 free_extent_map(em); 1830 ret = -ENXIO; 1831 break; 1832 } 1833 } 1834 1835 if (origin == SEEK_HOLE) { 1836 *offset = start; 1837 free_extent_map(em); 1838 break; 1839 } 1840 } else { 1841 if (origin == SEEK_DATA) { 1842 if (em->block_start == EXTENT_MAP_DELALLOC) { 1843 if (start >= inode->i_size) { 1844 free_extent_map(em); 1845 ret = -ENXIO; 1846 break; 1847 } 1848 } 1849 1850 *offset = start; 1851 free_extent_map(em); 1852 break; 1853 } 1854 } 1855 1856 start = em->start + em->len; 1857 last_end = em->start + em->len; 1858 1859 if (em->block_start == EXTENT_MAP_DELALLOC) 1860 last_end = min_t(u64, last_end, inode->i_size); 1861 1862 if (test_bit(EXTENT_FLAG_VACANCY, &em->flags)) { 1863 free_extent_map(em); 1864 ret = -ENXIO; 1865 break; 1866 } 1867 free_extent_map(em); 1868 cond_resched(); 1869 } 1870 if (!ret) 1871 *offset = min(*offset, inode->i_size); 1872 out: 1873 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend, 1874 &cached_state, GFP_NOFS); 1875 return ret; 1876 } 1877 1878 static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int origin) 1879 { 1880 struct inode *inode = file->f_mapping->host; 1881 int ret; 1882 1883 mutex_lock(&inode->i_mutex); 1884 switch (origin) { 1885 case SEEK_END: 1886 case SEEK_CUR: 1887 offset = generic_file_llseek(file, offset, origin); 1888 goto out; 1889 case SEEK_DATA: 1890 case SEEK_HOLE: 1891 if (offset >= i_size_read(inode)) { 1892 mutex_unlock(&inode->i_mutex); 1893 return -ENXIO; 1894 } 1895 1896 ret = find_desired_extent(inode, &offset, origin); 1897 if (ret) { 1898 mutex_unlock(&inode->i_mutex); 1899 return ret; 1900 } 1901 } 1902 1903 if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET)) { 1904 offset = -EINVAL; 1905 goto out; 1906 } 1907 if (offset > inode->i_sb->s_maxbytes) { 1908 offset = -EINVAL; 1909 goto out; 1910 } 1911 1912 /* Special lock needed here? */ 1913 if (offset != file->f_pos) { 1914 file->f_pos = offset; 1915 file->f_version = 0; 1916 } 1917 out: 1918 mutex_unlock(&inode->i_mutex); 1919 return offset; 1920 } 1921 1922 const struct file_operations btrfs_file_operations = { 1923 .llseek = btrfs_file_llseek, 1924 .read = do_sync_read, 1925 .write = do_sync_write, 1926 .aio_read = generic_file_aio_read, 1927 .splice_read = generic_file_splice_read, 1928 .aio_write = btrfs_file_aio_write, 1929 .mmap = btrfs_file_mmap, 1930 .open = generic_file_open, 1931 .release = btrfs_release_file, 1932 .fsync = btrfs_sync_file, 1933 .fallocate = btrfs_fallocate, 1934 .unlocked_ioctl = btrfs_ioctl, 1935 #ifdef CONFIG_COMPAT 1936 .compat_ioctl = btrfs_ioctl, 1937 #endif 1938 }; 1939