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/kernel.h> 20 #include <linux/bio.h> 21 #include <linux/buffer_head.h> 22 #include <linux/file.h> 23 #include <linux/fs.h> 24 #include <linux/pagemap.h> 25 #include <linux/highmem.h> 26 #include <linux/time.h> 27 #include <linux/init.h> 28 #include <linux/string.h> 29 #include <linux/backing-dev.h> 30 #include <linux/mpage.h> 31 #include <linux/swap.h> 32 #include <linux/writeback.h> 33 #include <linux/statfs.h> 34 #include <linux/compat.h> 35 #include <linux/aio.h> 36 #include <linux/bit_spinlock.h> 37 #include <linux/xattr.h> 38 #include <linux/posix_acl.h> 39 #include <linux/falloc.h> 40 #include <linux/slab.h> 41 #include <linux/ratelimit.h> 42 #include <linux/mount.h> 43 #include <linux/btrfs.h> 44 #include <linux/blkdev.h> 45 #include <linux/posix_acl_xattr.h> 46 #include "ctree.h" 47 #include "disk-io.h" 48 #include "transaction.h" 49 #include "btrfs_inode.h" 50 #include "print-tree.h" 51 #include "ordered-data.h" 52 #include "xattr.h" 53 #include "tree-log.h" 54 #include "volumes.h" 55 #include "compression.h" 56 #include "locking.h" 57 #include "free-space-cache.h" 58 #include "inode-map.h" 59 #include "backref.h" 60 #include "hash.h" 61 #include "props.h" 62 63 struct btrfs_iget_args { 64 struct btrfs_key *location; 65 struct btrfs_root *root; 66 }; 67 68 static const struct inode_operations btrfs_dir_inode_operations; 69 static const struct inode_operations btrfs_symlink_inode_operations; 70 static const struct inode_operations btrfs_dir_ro_inode_operations; 71 static const struct inode_operations btrfs_special_inode_operations; 72 static const struct inode_operations btrfs_file_inode_operations; 73 static const struct address_space_operations btrfs_aops; 74 static const struct address_space_operations btrfs_symlink_aops; 75 static const struct file_operations btrfs_dir_file_operations; 76 static struct extent_io_ops btrfs_extent_io_ops; 77 78 static struct kmem_cache *btrfs_inode_cachep; 79 static struct kmem_cache *btrfs_delalloc_work_cachep; 80 struct kmem_cache *btrfs_trans_handle_cachep; 81 struct kmem_cache *btrfs_transaction_cachep; 82 struct kmem_cache *btrfs_path_cachep; 83 struct kmem_cache *btrfs_free_space_cachep; 84 85 #define S_SHIFT 12 86 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = { 87 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE, 88 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR, 89 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV, 90 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV, 91 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO, 92 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK, 93 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK, 94 }; 95 96 static int btrfs_setsize(struct inode *inode, struct iattr *attr); 97 static int btrfs_truncate(struct inode *inode); 98 static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent); 99 static noinline int cow_file_range(struct inode *inode, 100 struct page *locked_page, 101 u64 start, u64 end, int *page_started, 102 unsigned long *nr_written, int unlock); 103 static struct extent_map *create_pinned_em(struct inode *inode, u64 start, 104 u64 len, u64 orig_start, 105 u64 block_start, u64 block_len, 106 u64 orig_block_len, u64 ram_bytes, 107 int type); 108 109 static int btrfs_dirty_inode(struct inode *inode); 110 111 static int btrfs_init_inode_security(struct btrfs_trans_handle *trans, 112 struct inode *inode, struct inode *dir, 113 const struct qstr *qstr) 114 { 115 int err; 116 117 err = btrfs_init_acl(trans, inode, dir); 118 if (!err) 119 err = btrfs_xattr_security_init(trans, inode, dir, qstr); 120 return err; 121 } 122 123 /* 124 * this does all the hard work for inserting an inline extent into 125 * the btree. The caller should have done a btrfs_drop_extents so that 126 * no overlapping inline items exist in the btree 127 */ 128 static int insert_inline_extent(struct btrfs_trans_handle *trans, 129 struct btrfs_path *path, int extent_inserted, 130 struct btrfs_root *root, struct inode *inode, 131 u64 start, size_t size, size_t compressed_size, 132 int compress_type, 133 struct page **compressed_pages) 134 { 135 struct extent_buffer *leaf; 136 struct page *page = NULL; 137 char *kaddr; 138 unsigned long ptr; 139 struct btrfs_file_extent_item *ei; 140 int err = 0; 141 int ret; 142 size_t cur_size = size; 143 unsigned long offset; 144 145 if (compressed_size && compressed_pages) 146 cur_size = compressed_size; 147 148 inode_add_bytes(inode, size); 149 150 if (!extent_inserted) { 151 struct btrfs_key key; 152 size_t datasize; 153 154 key.objectid = btrfs_ino(inode); 155 key.offset = start; 156 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY); 157 158 datasize = btrfs_file_extent_calc_inline_size(cur_size); 159 path->leave_spinning = 1; 160 ret = btrfs_insert_empty_item(trans, root, path, &key, 161 datasize); 162 if (ret) { 163 err = ret; 164 goto fail; 165 } 166 } 167 leaf = path->nodes[0]; 168 ei = btrfs_item_ptr(leaf, path->slots[0], 169 struct btrfs_file_extent_item); 170 btrfs_set_file_extent_generation(leaf, ei, trans->transid); 171 btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE); 172 btrfs_set_file_extent_encryption(leaf, ei, 0); 173 btrfs_set_file_extent_other_encoding(leaf, ei, 0); 174 btrfs_set_file_extent_ram_bytes(leaf, ei, size); 175 ptr = btrfs_file_extent_inline_start(ei); 176 177 if (compress_type != BTRFS_COMPRESS_NONE) { 178 struct page *cpage; 179 int i = 0; 180 while (compressed_size > 0) { 181 cpage = compressed_pages[i]; 182 cur_size = min_t(unsigned long, compressed_size, 183 PAGE_CACHE_SIZE); 184 185 kaddr = kmap_atomic(cpage); 186 write_extent_buffer(leaf, kaddr, ptr, cur_size); 187 kunmap_atomic(kaddr); 188 189 i++; 190 ptr += cur_size; 191 compressed_size -= cur_size; 192 } 193 btrfs_set_file_extent_compression(leaf, ei, 194 compress_type); 195 } else { 196 page = find_get_page(inode->i_mapping, 197 start >> PAGE_CACHE_SHIFT); 198 btrfs_set_file_extent_compression(leaf, ei, 0); 199 kaddr = kmap_atomic(page); 200 offset = start & (PAGE_CACHE_SIZE - 1); 201 write_extent_buffer(leaf, kaddr + offset, ptr, size); 202 kunmap_atomic(kaddr); 203 page_cache_release(page); 204 } 205 btrfs_mark_buffer_dirty(leaf); 206 btrfs_release_path(path); 207 208 /* 209 * we're an inline extent, so nobody can 210 * extend the file past i_size without locking 211 * a page we already have locked. 212 * 213 * We must do any isize and inode updates 214 * before we unlock the pages. Otherwise we 215 * could end up racing with unlink. 216 */ 217 BTRFS_I(inode)->disk_i_size = inode->i_size; 218 ret = btrfs_update_inode(trans, root, inode); 219 220 return ret; 221 fail: 222 return err; 223 } 224 225 226 /* 227 * conditionally insert an inline extent into the file. This 228 * does the checks required to make sure the data is small enough 229 * to fit as an inline extent. 230 */ 231 static noinline int cow_file_range_inline(struct btrfs_root *root, 232 struct inode *inode, u64 start, 233 u64 end, size_t compressed_size, 234 int compress_type, 235 struct page **compressed_pages) 236 { 237 struct btrfs_trans_handle *trans; 238 u64 isize = i_size_read(inode); 239 u64 actual_end = min(end + 1, isize); 240 u64 inline_len = actual_end - start; 241 u64 aligned_end = ALIGN(end, root->sectorsize); 242 u64 data_len = inline_len; 243 int ret; 244 struct btrfs_path *path; 245 int extent_inserted = 0; 246 u32 extent_item_size; 247 248 if (compressed_size) 249 data_len = compressed_size; 250 251 if (start > 0 || 252 actual_end >= PAGE_CACHE_SIZE || 253 data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) || 254 (!compressed_size && 255 (actual_end & (root->sectorsize - 1)) == 0) || 256 end + 1 < isize || 257 data_len > root->fs_info->max_inline) { 258 return 1; 259 } 260 261 path = btrfs_alloc_path(); 262 if (!path) 263 return -ENOMEM; 264 265 trans = btrfs_join_transaction(root); 266 if (IS_ERR(trans)) { 267 btrfs_free_path(path); 268 return PTR_ERR(trans); 269 } 270 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 271 272 if (compressed_size && compressed_pages) 273 extent_item_size = btrfs_file_extent_calc_inline_size( 274 compressed_size); 275 else 276 extent_item_size = btrfs_file_extent_calc_inline_size( 277 inline_len); 278 279 ret = __btrfs_drop_extents(trans, root, inode, path, 280 start, aligned_end, NULL, 281 1, 1, extent_item_size, &extent_inserted); 282 if (ret) { 283 btrfs_abort_transaction(trans, root, ret); 284 goto out; 285 } 286 287 if (isize > actual_end) 288 inline_len = min_t(u64, isize, actual_end); 289 ret = insert_inline_extent(trans, path, extent_inserted, 290 root, inode, start, 291 inline_len, compressed_size, 292 compress_type, compressed_pages); 293 if (ret && ret != -ENOSPC) { 294 btrfs_abort_transaction(trans, root, ret); 295 goto out; 296 } else if (ret == -ENOSPC) { 297 ret = 1; 298 goto out; 299 } 300 301 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags); 302 btrfs_delalloc_release_metadata(inode, end + 1 - start); 303 btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0); 304 out: 305 btrfs_free_path(path); 306 btrfs_end_transaction(trans, root); 307 return ret; 308 } 309 310 struct async_extent { 311 u64 start; 312 u64 ram_size; 313 u64 compressed_size; 314 struct page **pages; 315 unsigned long nr_pages; 316 int compress_type; 317 struct list_head list; 318 }; 319 320 struct async_cow { 321 struct inode *inode; 322 struct btrfs_root *root; 323 struct page *locked_page; 324 u64 start; 325 u64 end; 326 struct list_head extents; 327 struct btrfs_work work; 328 }; 329 330 static noinline int add_async_extent(struct async_cow *cow, 331 u64 start, u64 ram_size, 332 u64 compressed_size, 333 struct page **pages, 334 unsigned long nr_pages, 335 int compress_type) 336 { 337 struct async_extent *async_extent; 338 339 async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS); 340 BUG_ON(!async_extent); /* -ENOMEM */ 341 async_extent->start = start; 342 async_extent->ram_size = ram_size; 343 async_extent->compressed_size = compressed_size; 344 async_extent->pages = pages; 345 async_extent->nr_pages = nr_pages; 346 async_extent->compress_type = compress_type; 347 list_add_tail(&async_extent->list, &cow->extents); 348 return 0; 349 } 350 351 /* 352 * we create compressed extents in two phases. The first 353 * phase compresses a range of pages that have already been 354 * locked (both pages and state bits are locked). 355 * 356 * This is done inside an ordered work queue, and the compression 357 * is spread across many cpus. The actual IO submission is step 358 * two, and the ordered work queue takes care of making sure that 359 * happens in the same order things were put onto the queue by 360 * writepages and friends. 361 * 362 * If this code finds it can't get good compression, it puts an 363 * entry onto the work queue to write the uncompressed bytes. This 364 * makes sure that both compressed inodes and uncompressed inodes 365 * are written in the same order that the flusher thread sent them 366 * down. 367 */ 368 static noinline int compress_file_range(struct inode *inode, 369 struct page *locked_page, 370 u64 start, u64 end, 371 struct async_cow *async_cow, 372 int *num_added) 373 { 374 struct btrfs_root *root = BTRFS_I(inode)->root; 375 u64 num_bytes; 376 u64 blocksize = root->sectorsize; 377 u64 actual_end; 378 u64 isize = i_size_read(inode); 379 int ret = 0; 380 struct page **pages = NULL; 381 unsigned long nr_pages; 382 unsigned long nr_pages_ret = 0; 383 unsigned long total_compressed = 0; 384 unsigned long total_in = 0; 385 unsigned long max_compressed = 128 * 1024; 386 unsigned long max_uncompressed = 128 * 1024; 387 int i; 388 int will_compress; 389 int compress_type = root->fs_info->compress_type; 390 int redirty = 0; 391 392 /* if this is a small write inside eof, kick off a defrag */ 393 if ((end - start + 1) < 16 * 1024 && 394 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) 395 btrfs_add_inode_defrag(NULL, inode); 396 397 /* 398 * skip compression for a small file range(<=blocksize) that 399 * isn't an inline extent, since it dosen't save disk space at all. 400 */ 401 if ((end - start + 1) <= blocksize && 402 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) 403 goto cleanup_and_bail_uncompressed; 404 405 actual_end = min_t(u64, isize, end + 1); 406 again: 407 will_compress = 0; 408 nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1; 409 nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE); 410 411 /* 412 * we don't want to send crud past the end of i_size through 413 * compression, that's just a waste of CPU time. So, if the 414 * end of the file is before the start of our current 415 * requested range of bytes, we bail out to the uncompressed 416 * cleanup code that can deal with all of this. 417 * 418 * It isn't really the fastest way to fix things, but this is a 419 * very uncommon corner. 420 */ 421 if (actual_end <= start) 422 goto cleanup_and_bail_uncompressed; 423 424 total_compressed = actual_end - start; 425 426 /* we want to make sure that amount of ram required to uncompress 427 * an extent is reasonable, so we limit the total size in ram 428 * of a compressed extent to 128k. This is a crucial number 429 * because it also controls how easily we can spread reads across 430 * cpus for decompression. 431 * 432 * We also want to make sure the amount of IO required to do 433 * a random read is reasonably small, so we limit the size of 434 * a compressed extent to 128k. 435 */ 436 total_compressed = min(total_compressed, max_uncompressed); 437 num_bytes = ALIGN(end - start + 1, blocksize); 438 num_bytes = max(blocksize, num_bytes); 439 total_in = 0; 440 ret = 0; 441 442 /* 443 * we do compression for mount -o compress and when the 444 * inode has not been flagged as nocompress. This flag can 445 * change at any time if we discover bad compression ratios. 446 */ 447 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) && 448 (btrfs_test_opt(root, COMPRESS) || 449 (BTRFS_I(inode)->force_compress) || 450 (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) { 451 WARN_ON(pages); 452 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS); 453 if (!pages) { 454 /* just bail out to the uncompressed code */ 455 goto cont; 456 } 457 458 if (BTRFS_I(inode)->force_compress) 459 compress_type = BTRFS_I(inode)->force_compress; 460 461 /* 462 * we need to call clear_page_dirty_for_io on each 463 * page in the range. Otherwise applications with the file 464 * mmap'd can wander in and change the page contents while 465 * we are compressing them. 466 * 467 * If the compression fails for any reason, we set the pages 468 * dirty again later on. 469 */ 470 extent_range_clear_dirty_for_io(inode, start, end); 471 redirty = 1; 472 ret = btrfs_compress_pages(compress_type, 473 inode->i_mapping, start, 474 total_compressed, pages, 475 nr_pages, &nr_pages_ret, 476 &total_in, 477 &total_compressed, 478 max_compressed); 479 480 if (!ret) { 481 unsigned long offset = total_compressed & 482 (PAGE_CACHE_SIZE - 1); 483 struct page *page = pages[nr_pages_ret - 1]; 484 char *kaddr; 485 486 /* zero the tail end of the last page, we might be 487 * sending it down to disk 488 */ 489 if (offset) { 490 kaddr = kmap_atomic(page); 491 memset(kaddr + offset, 0, 492 PAGE_CACHE_SIZE - offset); 493 kunmap_atomic(kaddr); 494 } 495 will_compress = 1; 496 } 497 } 498 cont: 499 if (start == 0) { 500 /* lets try to make an inline extent */ 501 if (ret || total_in < (actual_end - start)) { 502 /* we didn't compress the entire range, try 503 * to make an uncompressed inline extent. 504 */ 505 ret = cow_file_range_inline(root, inode, start, end, 506 0, 0, NULL); 507 } else { 508 /* try making a compressed inline extent */ 509 ret = cow_file_range_inline(root, inode, start, end, 510 total_compressed, 511 compress_type, pages); 512 } 513 if (ret <= 0) { 514 unsigned long clear_flags = EXTENT_DELALLOC | 515 EXTENT_DEFRAG; 516 clear_flags |= (ret < 0) ? EXTENT_DO_ACCOUNTING : 0; 517 518 /* 519 * inline extent creation worked or returned error, 520 * we don't need to create any more async work items. 521 * Unlock and free up our temp pages. 522 */ 523 extent_clear_unlock_delalloc(inode, start, end, NULL, 524 clear_flags, PAGE_UNLOCK | 525 PAGE_CLEAR_DIRTY | 526 PAGE_SET_WRITEBACK | 527 PAGE_END_WRITEBACK); 528 goto free_pages_out; 529 } 530 } 531 532 if (will_compress) { 533 /* 534 * we aren't doing an inline extent round the compressed size 535 * up to a block size boundary so the allocator does sane 536 * things 537 */ 538 total_compressed = ALIGN(total_compressed, blocksize); 539 540 /* 541 * one last check to make sure the compression is really a 542 * win, compare the page count read with the blocks on disk 543 */ 544 total_in = ALIGN(total_in, PAGE_CACHE_SIZE); 545 if (total_compressed >= total_in) { 546 will_compress = 0; 547 } else { 548 num_bytes = total_in; 549 } 550 } 551 if (!will_compress && pages) { 552 /* 553 * the compression code ran but failed to make things smaller, 554 * free any pages it allocated and our page pointer array 555 */ 556 for (i = 0; i < nr_pages_ret; i++) { 557 WARN_ON(pages[i]->mapping); 558 page_cache_release(pages[i]); 559 } 560 kfree(pages); 561 pages = NULL; 562 total_compressed = 0; 563 nr_pages_ret = 0; 564 565 /* flag the file so we don't compress in the future */ 566 if (!btrfs_test_opt(root, FORCE_COMPRESS) && 567 !(BTRFS_I(inode)->force_compress)) { 568 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; 569 } 570 } 571 if (will_compress) { 572 *num_added += 1; 573 574 /* the async work queues will take care of doing actual 575 * allocation on disk for these compressed pages, 576 * and will submit them to the elevator. 577 */ 578 add_async_extent(async_cow, start, num_bytes, 579 total_compressed, pages, nr_pages_ret, 580 compress_type); 581 582 if (start + num_bytes < end) { 583 start += num_bytes; 584 pages = NULL; 585 cond_resched(); 586 goto again; 587 } 588 } else { 589 cleanup_and_bail_uncompressed: 590 /* 591 * No compression, but we still need to write the pages in 592 * the file we've been given so far. redirty the locked 593 * page if it corresponds to our extent and set things up 594 * for the async work queue to run cow_file_range to do 595 * the normal delalloc dance 596 */ 597 if (page_offset(locked_page) >= start && 598 page_offset(locked_page) <= end) { 599 __set_page_dirty_nobuffers(locked_page); 600 /* unlocked later on in the async handlers */ 601 } 602 if (redirty) 603 extent_range_redirty_for_io(inode, start, end); 604 add_async_extent(async_cow, start, end - start + 1, 605 0, NULL, 0, BTRFS_COMPRESS_NONE); 606 *num_added += 1; 607 } 608 609 out: 610 return ret; 611 612 free_pages_out: 613 for (i = 0; i < nr_pages_ret; i++) { 614 WARN_ON(pages[i]->mapping); 615 page_cache_release(pages[i]); 616 } 617 kfree(pages); 618 619 goto out; 620 } 621 622 /* 623 * phase two of compressed writeback. This is the ordered portion 624 * of the code, which only gets called in the order the work was 625 * queued. We walk all the async extents created by compress_file_range 626 * and send them down to the disk. 627 */ 628 static noinline int submit_compressed_extents(struct inode *inode, 629 struct async_cow *async_cow) 630 { 631 struct async_extent *async_extent; 632 u64 alloc_hint = 0; 633 struct btrfs_key ins; 634 struct extent_map *em; 635 struct btrfs_root *root = BTRFS_I(inode)->root; 636 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 637 struct extent_io_tree *io_tree; 638 int ret = 0; 639 640 if (list_empty(&async_cow->extents)) 641 return 0; 642 643 again: 644 while (!list_empty(&async_cow->extents)) { 645 async_extent = list_entry(async_cow->extents.next, 646 struct async_extent, list); 647 list_del(&async_extent->list); 648 649 io_tree = &BTRFS_I(inode)->io_tree; 650 651 retry: 652 /* did the compression code fall back to uncompressed IO? */ 653 if (!async_extent->pages) { 654 int page_started = 0; 655 unsigned long nr_written = 0; 656 657 lock_extent(io_tree, async_extent->start, 658 async_extent->start + 659 async_extent->ram_size - 1); 660 661 /* allocate blocks */ 662 ret = cow_file_range(inode, async_cow->locked_page, 663 async_extent->start, 664 async_extent->start + 665 async_extent->ram_size - 1, 666 &page_started, &nr_written, 0); 667 668 /* JDM XXX */ 669 670 /* 671 * if page_started, cow_file_range inserted an 672 * inline extent and took care of all the unlocking 673 * and IO for us. Otherwise, we need to submit 674 * all those pages down to the drive. 675 */ 676 if (!page_started && !ret) 677 extent_write_locked_range(io_tree, 678 inode, async_extent->start, 679 async_extent->start + 680 async_extent->ram_size - 1, 681 btrfs_get_extent, 682 WB_SYNC_ALL); 683 else if (ret) 684 unlock_page(async_cow->locked_page); 685 kfree(async_extent); 686 cond_resched(); 687 continue; 688 } 689 690 lock_extent(io_tree, async_extent->start, 691 async_extent->start + async_extent->ram_size - 1); 692 693 ret = btrfs_reserve_extent(root, 694 async_extent->compressed_size, 695 async_extent->compressed_size, 696 0, alloc_hint, &ins, 1, 1); 697 if (ret) { 698 int i; 699 700 for (i = 0; i < async_extent->nr_pages; i++) { 701 WARN_ON(async_extent->pages[i]->mapping); 702 page_cache_release(async_extent->pages[i]); 703 } 704 kfree(async_extent->pages); 705 async_extent->nr_pages = 0; 706 async_extent->pages = NULL; 707 708 if (ret == -ENOSPC) { 709 unlock_extent(io_tree, async_extent->start, 710 async_extent->start + 711 async_extent->ram_size - 1); 712 713 /* 714 * we need to redirty the pages if we decide to 715 * fallback to uncompressed IO, otherwise we 716 * will not submit these pages down to lower 717 * layers. 718 */ 719 extent_range_redirty_for_io(inode, 720 async_extent->start, 721 async_extent->start + 722 async_extent->ram_size - 1); 723 724 goto retry; 725 } 726 goto out_free; 727 } 728 729 /* 730 * here we're doing allocation and writeback of the 731 * compressed pages 732 */ 733 btrfs_drop_extent_cache(inode, async_extent->start, 734 async_extent->start + 735 async_extent->ram_size - 1, 0); 736 737 em = alloc_extent_map(); 738 if (!em) { 739 ret = -ENOMEM; 740 goto out_free_reserve; 741 } 742 em->start = async_extent->start; 743 em->len = async_extent->ram_size; 744 em->orig_start = em->start; 745 em->mod_start = em->start; 746 em->mod_len = em->len; 747 748 em->block_start = ins.objectid; 749 em->block_len = ins.offset; 750 em->orig_block_len = ins.offset; 751 em->ram_bytes = async_extent->ram_size; 752 em->bdev = root->fs_info->fs_devices->latest_bdev; 753 em->compress_type = async_extent->compress_type; 754 set_bit(EXTENT_FLAG_PINNED, &em->flags); 755 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 756 em->generation = -1; 757 758 while (1) { 759 write_lock(&em_tree->lock); 760 ret = add_extent_mapping(em_tree, em, 1); 761 write_unlock(&em_tree->lock); 762 if (ret != -EEXIST) { 763 free_extent_map(em); 764 break; 765 } 766 btrfs_drop_extent_cache(inode, async_extent->start, 767 async_extent->start + 768 async_extent->ram_size - 1, 0); 769 } 770 771 if (ret) 772 goto out_free_reserve; 773 774 ret = btrfs_add_ordered_extent_compress(inode, 775 async_extent->start, 776 ins.objectid, 777 async_extent->ram_size, 778 ins.offset, 779 BTRFS_ORDERED_COMPRESSED, 780 async_extent->compress_type); 781 if (ret) 782 goto out_free_reserve; 783 784 /* 785 * clear dirty, set writeback and unlock the pages. 786 */ 787 extent_clear_unlock_delalloc(inode, async_extent->start, 788 async_extent->start + 789 async_extent->ram_size - 1, 790 NULL, EXTENT_LOCKED | EXTENT_DELALLOC, 791 PAGE_UNLOCK | PAGE_CLEAR_DIRTY | 792 PAGE_SET_WRITEBACK); 793 ret = btrfs_submit_compressed_write(inode, 794 async_extent->start, 795 async_extent->ram_size, 796 ins.objectid, 797 ins.offset, async_extent->pages, 798 async_extent->nr_pages); 799 alloc_hint = ins.objectid + ins.offset; 800 kfree(async_extent); 801 if (ret) 802 goto out; 803 cond_resched(); 804 } 805 ret = 0; 806 out: 807 return ret; 808 out_free_reserve: 809 btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1); 810 out_free: 811 extent_clear_unlock_delalloc(inode, async_extent->start, 812 async_extent->start + 813 async_extent->ram_size - 1, 814 NULL, EXTENT_LOCKED | EXTENT_DELALLOC | 815 EXTENT_DEFRAG | EXTENT_DO_ACCOUNTING, 816 PAGE_UNLOCK | PAGE_CLEAR_DIRTY | 817 PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK); 818 kfree(async_extent); 819 goto again; 820 } 821 822 static u64 get_extent_allocation_hint(struct inode *inode, u64 start, 823 u64 num_bytes) 824 { 825 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 826 struct extent_map *em; 827 u64 alloc_hint = 0; 828 829 read_lock(&em_tree->lock); 830 em = search_extent_mapping(em_tree, start, num_bytes); 831 if (em) { 832 /* 833 * if block start isn't an actual block number then find the 834 * first block in this inode and use that as a hint. If that 835 * block is also bogus then just don't worry about it. 836 */ 837 if (em->block_start >= EXTENT_MAP_LAST_BYTE) { 838 free_extent_map(em); 839 em = search_extent_mapping(em_tree, 0, 0); 840 if (em && em->block_start < EXTENT_MAP_LAST_BYTE) 841 alloc_hint = em->block_start; 842 if (em) 843 free_extent_map(em); 844 } else { 845 alloc_hint = em->block_start; 846 free_extent_map(em); 847 } 848 } 849 read_unlock(&em_tree->lock); 850 851 return alloc_hint; 852 } 853 854 /* 855 * when extent_io.c finds a delayed allocation range in the file, 856 * the call backs end up in this code. The basic idea is to 857 * allocate extents on disk for the range, and create ordered data structs 858 * in ram to track those extents. 859 * 860 * locked_page is the page that writepage had locked already. We use 861 * it to make sure we don't do extra locks or unlocks. 862 * 863 * *page_started is set to one if we unlock locked_page and do everything 864 * required to start IO on it. It may be clean and already done with 865 * IO when we return. 866 */ 867 static noinline int cow_file_range(struct inode *inode, 868 struct page *locked_page, 869 u64 start, u64 end, int *page_started, 870 unsigned long *nr_written, 871 int unlock) 872 { 873 struct btrfs_root *root = BTRFS_I(inode)->root; 874 u64 alloc_hint = 0; 875 u64 num_bytes; 876 unsigned long ram_size; 877 u64 disk_num_bytes; 878 u64 cur_alloc_size; 879 u64 blocksize = root->sectorsize; 880 struct btrfs_key ins; 881 struct extent_map *em; 882 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 883 int ret = 0; 884 885 if (btrfs_is_free_space_inode(inode)) { 886 WARN_ON_ONCE(1); 887 ret = -EINVAL; 888 goto out_unlock; 889 } 890 891 num_bytes = ALIGN(end - start + 1, blocksize); 892 num_bytes = max(blocksize, num_bytes); 893 disk_num_bytes = num_bytes; 894 895 /* if this is a small write inside eof, kick off defrag */ 896 if (num_bytes < 64 * 1024 && 897 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) 898 btrfs_add_inode_defrag(NULL, inode); 899 900 if (start == 0) { 901 /* lets try to make an inline extent */ 902 ret = cow_file_range_inline(root, inode, start, end, 0, 0, 903 NULL); 904 if (ret == 0) { 905 extent_clear_unlock_delalloc(inode, start, end, NULL, 906 EXTENT_LOCKED | EXTENT_DELALLOC | 907 EXTENT_DEFRAG, PAGE_UNLOCK | 908 PAGE_CLEAR_DIRTY | PAGE_SET_WRITEBACK | 909 PAGE_END_WRITEBACK); 910 911 *nr_written = *nr_written + 912 (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE; 913 *page_started = 1; 914 goto out; 915 } else if (ret < 0) { 916 goto out_unlock; 917 } 918 } 919 920 BUG_ON(disk_num_bytes > 921 btrfs_super_total_bytes(root->fs_info->super_copy)); 922 923 alloc_hint = get_extent_allocation_hint(inode, start, num_bytes); 924 btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0); 925 926 while (disk_num_bytes > 0) { 927 unsigned long op; 928 929 cur_alloc_size = disk_num_bytes; 930 ret = btrfs_reserve_extent(root, cur_alloc_size, 931 root->sectorsize, 0, alloc_hint, 932 &ins, 1, 1); 933 if (ret < 0) 934 goto out_unlock; 935 936 em = alloc_extent_map(); 937 if (!em) { 938 ret = -ENOMEM; 939 goto out_reserve; 940 } 941 em->start = start; 942 em->orig_start = em->start; 943 ram_size = ins.offset; 944 em->len = ins.offset; 945 em->mod_start = em->start; 946 em->mod_len = em->len; 947 948 em->block_start = ins.objectid; 949 em->block_len = ins.offset; 950 em->orig_block_len = ins.offset; 951 em->ram_bytes = ram_size; 952 em->bdev = root->fs_info->fs_devices->latest_bdev; 953 set_bit(EXTENT_FLAG_PINNED, &em->flags); 954 em->generation = -1; 955 956 while (1) { 957 write_lock(&em_tree->lock); 958 ret = add_extent_mapping(em_tree, em, 1); 959 write_unlock(&em_tree->lock); 960 if (ret != -EEXIST) { 961 free_extent_map(em); 962 break; 963 } 964 btrfs_drop_extent_cache(inode, start, 965 start + ram_size - 1, 0); 966 } 967 if (ret) 968 goto out_reserve; 969 970 cur_alloc_size = ins.offset; 971 ret = btrfs_add_ordered_extent(inode, start, ins.objectid, 972 ram_size, cur_alloc_size, 0); 973 if (ret) 974 goto out_reserve; 975 976 if (root->root_key.objectid == 977 BTRFS_DATA_RELOC_TREE_OBJECTID) { 978 ret = btrfs_reloc_clone_csums(inode, start, 979 cur_alloc_size); 980 if (ret) 981 goto out_reserve; 982 } 983 984 if (disk_num_bytes < cur_alloc_size) 985 break; 986 987 /* we're not doing compressed IO, don't unlock the first 988 * page (which the caller expects to stay locked), don't 989 * clear any dirty bits and don't set any writeback bits 990 * 991 * Do set the Private2 bit so we know this page was properly 992 * setup for writepage 993 */ 994 op = unlock ? PAGE_UNLOCK : 0; 995 op |= PAGE_SET_PRIVATE2; 996 997 extent_clear_unlock_delalloc(inode, start, 998 start + ram_size - 1, locked_page, 999 EXTENT_LOCKED | EXTENT_DELALLOC, 1000 op); 1001 disk_num_bytes -= cur_alloc_size; 1002 num_bytes -= cur_alloc_size; 1003 alloc_hint = ins.objectid + ins.offset; 1004 start += cur_alloc_size; 1005 } 1006 out: 1007 return ret; 1008 1009 out_reserve: 1010 btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1); 1011 out_unlock: 1012 extent_clear_unlock_delalloc(inode, start, end, locked_page, 1013 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING | 1014 EXTENT_DELALLOC | EXTENT_DEFRAG, 1015 PAGE_UNLOCK | PAGE_CLEAR_DIRTY | 1016 PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK); 1017 goto out; 1018 } 1019 1020 /* 1021 * work queue call back to started compression on a file and pages 1022 */ 1023 static noinline void async_cow_start(struct btrfs_work *work) 1024 { 1025 struct async_cow *async_cow; 1026 int num_added = 0; 1027 async_cow = container_of(work, struct async_cow, work); 1028 1029 compress_file_range(async_cow->inode, async_cow->locked_page, 1030 async_cow->start, async_cow->end, async_cow, 1031 &num_added); 1032 if (num_added == 0) { 1033 btrfs_add_delayed_iput(async_cow->inode); 1034 async_cow->inode = NULL; 1035 } 1036 } 1037 1038 /* 1039 * work queue call back to submit previously compressed pages 1040 */ 1041 static noinline void async_cow_submit(struct btrfs_work *work) 1042 { 1043 struct async_cow *async_cow; 1044 struct btrfs_root *root; 1045 unsigned long nr_pages; 1046 1047 async_cow = container_of(work, struct async_cow, work); 1048 1049 root = async_cow->root; 1050 nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >> 1051 PAGE_CACHE_SHIFT; 1052 1053 if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) < 1054 5 * 1024 * 1024 && 1055 waitqueue_active(&root->fs_info->async_submit_wait)) 1056 wake_up(&root->fs_info->async_submit_wait); 1057 1058 if (async_cow->inode) 1059 submit_compressed_extents(async_cow->inode, async_cow); 1060 } 1061 1062 static noinline void async_cow_free(struct btrfs_work *work) 1063 { 1064 struct async_cow *async_cow; 1065 async_cow = container_of(work, struct async_cow, work); 1066 if (async_cow->inode) 1067 btrfs_add_delayed_iput(async_cow->inode); 1068 kfree(async_cow); 1069 } 1070 1071 static int cow_file_range_async(struct inode *inode, struct page *locked_page, 1072 u64 start, u64 end, int *page_started, 1073 unsigned long *nr_written) 1074 { 1075 struct async_cow *async_cow; 1076 struct btrfs_root *root = BTRFS_I(inode)->root; 1077 unsigned long nr_pages; 1078 u64 cur_end; 1079 int limit = 10 * 1024 * 1024; 1080 1081 clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED, 1082 1, 0, NULL, GFP_NOFS); 1083 while (start < end) { 1084 async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS); 1085 BUG_ON(!async_cow); /* -ENOMEM */ 1086 async_cow->inode = igrab(inode); 1087 async_cow->root = root; 1088 async_cow->locked_page = locked_page; 1089 async_cow->start = start; 1090 1091 if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) 1092 cur_end = end; 1093 else 1094 cur_end = min(end, start + 512 * 1024 - 1); 1095 1096 async_cow->end = cur_end; 1097 INIT_LIST_HEAD(&async_cow->extents); 1098 1099 btrfs_init_work(&async_cow->work, async_cow_start, 1100 async_cow_submit, async_cow_free); 1101 1102 nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >> 1103 PAGE_CACHE_SHIFT; 1104 atomic_add(nr_pages, &root->fs_info->async_delalloc_pages); 1105 1106 btrfs_queue_work(root->fs_info->delalloc_workers, 1107 &async_cow->work); 1108 1109 if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) { 1110 wait_event(root->fs_info->async_submit_wait, 1111 (atomic_read(&root->fs_info->async_delalloc_pages) < 1112 limit)); 1113 } 1114 1115 while (atomic_read(&root->fs_info->async_submit_draining) && 1116 atomic_read(&root->fs_info->async_delalloc_pages)) { 1117 wait_event(root->fs_info->async_submit_wait, 1118 (atomic_read(&root->fs_info->async_delalloc_pages) == 1119 0)); 1120 } 1121 1122 *nr_written += nr_pages; 1123 start = cur_end + 1; 1124 } 1125 *page_started = 1; 1126 return 0; 1127 } 1128 1129 static noinline int csum_exist_in_range(struct btrfs_root *root, 1130 u64 bytenr, u64 num_bytes) 1131 { 1132 int ret; 1133 struct btrfs_ordered_sum *sums; 1134 LIST_HEAD(list); 1135 1136 ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr, 1137 bytenr + num_bytes - 1, &list, 0); 1138 if (ret == 0 && list_empty(&list)) 1139 return 0; 1140 1141 while (!list_empty(&list)) { 1142 sums = list_entry(list.next, struct btrfs_ordered_sum, list); 1143 list_del(&sums->list); 1144 kfree(sums); 1145 } 1146 return 1; 1147 } 1148 1149 /* 1150 * when nowcow writeback call back. This checks for snapshots or COW copies 1151 * of the extents that exist in the file, and COWs the file as required. 1152 * 1153 * If no cow copies or snapshots exist, we write directly to the existing 1154 * blocks on disk 1155 */ 1156 static noinline int run_delalloc_nocow(struct inode *inode, 1157 struct page *locked_page, 1158 u64 start, u64 end, int *page_started, int force, 1159 unsigned long *nr_written) 1160 { 1161 struct btrfs_root *root = BTRFS_I(inode)->root; 1162 struct btrfs_trans_handle *trans; 1163 struct extent_buffer *leaf; 1164 struct btrfs_path *path; 1165 struct btrfs_file_extent_item *fi; 1166 struct btrfs_key found_key; 1167 u64 cow_start; 1168 u64 cur_offset; 1169 u64 extent_end; 1170 u64 extent_offset; 1171 u64 disk_bytenr; 1172 u64 num_bytes; 1173 u64 disk_num_bytes; 1174 u64 ram_bytes; 1175 int extent_type; 1176 int ret, err; 1177 int type; 1178 int nocow; 1179 int check_prev = 1; 1180 bool nolock; 1181 u64 ino = btrfs_ino(inode); 1182 1183 path = btrfs_alloc_path(); 1184 if (!path) { 1185 extent_clear_unlock_delalloc(inode, start, end, locked_page, 1186 EXTENT_LOCKED | EXTENT_DELALLOC | 1187 EXTENT_DO_ACCOUNTING | 1188 EXTENT_DEFRAG, PAGE_UNLOCK | 1189 PAGE_CLEAR_DIRTY | 1190 PAGE_SET_WRITEBACK | 1191 PAGE_END_WRITEBACK); 1192 return -ENOMEM; 1193 } 1194 1195 nolock = btrfs_is_free_space_inode(inode); 1196 1197 if (nolock) 1198 trans = btrfs_join_transaction_nolock(root); 1199 else 1200 trans = btrfs_join_transaction(root); 1201 1202 if (IS_ERR(trans)) { 1203 extent_clear_unlock_delalloc(inode, start, end, locked_page, 1204 EXTENT_LOCKED | EXTENT_DELALLOC | 1205 EXTENT_DO_ACCOUNTING | 1206 EXTENT_DEFRAG, PAGE_UNLOCK | 1207 PAGE_CLEAR_DIRTY | 1208 PAGE_SET_WRITEBACK | 1209 PAGE_END_WRITEBACK); 1210 btrfs_free_path(path); 1211 return PTR_ERR(trans); 1212 } 1213 1214 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 1215 1216 cow_start = (u64)-1; 1217 cur_offset = start; 1218 while (1) { 1219 ret = btrfs_lookup_file_extent(trans, root, path, ino, 1220 cur_offset, 0); 1221 if (ret < 0) 1222 goto error; 1223 if (ret > 0 && path->slots[0] > 0 && check_prev) { 1224 leaf = path->nodes[0]; 1225 btrfs_item_key_to_cpu(leaf, &found_key, 1226 path->slots[0] - 1); 1227 if (found_key.objectid == ino && 1228 found_key.type == BTRFS_EXTENT_DATA_KEY) 1229 path->slots[0]--; 1230 } 1231 check_prev = 0; 1232 next_slot: 1233 leaf = path->nodes[0]; 1234 if (path->slots[0] >= btrfs_header_nritems(leaf)) { 1235 ret = btrfs_next_leaf(root, path); 1236 if (ret < 0) 1237 goto error; 1238 if (ret > 0) 1239 break; 1240 leaf = path->nodes[0]; 1241 } 1242 1243 nocow = 0; 1244 disk_bytenr = 0; 1245 num_bytes = 0; 1246 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 1247 1248 if (found_key.objectid > ino || 1249 found_key.type > BTRFS_EXTENT_DATA_KEY || 1250 found_key.offset > end) 1251 break; 1252 1253 if (found_key.offset > cur_offset) { 1254 extent_end = found_key.offset; 1255 extent_type = 0; 1256 goto out_check; 1257 } 1258 1259 fi = btrfs_item_ptr(leaf, path->slots[0], 1260 struct btrfs_file_extent_item); 1261 extent_type = btrfs_file_extent_type(leaf, fi); 1262 1263 ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi); 1264 if (extent_type == BTRFS_FILE_EXTENT_REG || 1265 extent_type == BTRFS_FILE_EXTENT_PREALLOC) { 1266 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 1267 extent_offset = btrfs_file_extent_offset(leaf, fi); 1268 extent_end = found_key.offset + 1269 btrfs_file_extent_num_bytes(leaf, fi); 1270 disk_num_bytes = 1271 btrfs_file_extent_disk_num_bytes(leaf, fi); 1272 if (extent_end <= start) { 1273 path->slots[0]++; 1274 goto next_slot; 1275 } 1276 if (disk_bytenr == 0) 1277 goto out_check; 1278 if (btrfs_file_extent_compression(leaf, fi) || 1279 btrfs_file_extent_encryption(leaf, fi) || 1280 btrfs_file_extent_other_encoding(leaf, fi)) 1281 goto out_check; 1282 if (extent_type == BTRFS_FILE_EXTENT_REG && !force) 1283 goto out_check; 1284 if (btrfs_extent_readonly(root, disk_bytenr)) 1285 goto out_check; 1286 if (btrfs_cross_ref_exist(trans, root, ino, 1287 found_key.offset - 1288 extent_offset, disk_bytenr)) 1289 goto out_check; 1290 disk_bytenr += extent_offset; 1291 disk_bytenr += cur_offset - found_key.offset; 1292 num_bytes = min(end + 1, extent_end) - cur_offset; 1293 /* 1294 * if there are pending snapshots for this root, 1295 * we fall into common COW way. 1296 */ 1297 if (!nolock) { 1298 err = btrfs_start_nocow_write(root); 1299 if (!err) 1300 goto out_check; 1301 } 1302 /* 1303 * force cow if csum exists in the range. 1304 * this ensure that csum for a given extent are 1305 * either valid or do not exist. 1306 */ 1307 if (csum_exist_in_range(root, disk_bytenr, num_bytes)) 1308 goto out_check; 1309 nocow = 1; 1310 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 1311 extent_end = found_key.offset + 1312 btrfs_file_extent_inline_len(leaf, 1313 path->slots[0], fi); 1314 extent_end = ALIGN(extent_end, root->sectorsize); 1315 } else { 1316 BUG_ON(1); 1317 } 1318 out_check: 1319 if (extent_end <= start) { 1320 path->slots[0]++; 1321 if (!nolock && nocow) 1322 btrfs_end_nocow_write(root); 1323 goto next_slot; 1324 } 1325 if (!nocow) { 1326 if (cow_start == (u64)-1) 1327 cow_start = cur_offset; 1328 cur_offset = extent_end; 1329 if (cur_offset > end) 1330 break; 1331 path->slots[0]++; 1332 goto next_slot; 1333 } 1334 1335 btrfs_release_path(path); 1336 if (cow_start != (u64)-1) { 1337 ret = cow_file_range(inode, locked_page, 1338 cow_start, found_key.offset - 1, 1339 page_started, nr_written, 1); 1340 if (ret) { 1341 if (!nolock && nocow) 1342 btrfs_end_nocow_write(root); 1343 goto error; 1344 } 1345 cow_start = (u64)-1; 1346 } 1347 1348 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) { 1349 struct extent_map *em; 1350 struct extent_map_tree *em_tree; 1351 em_tree = &BTRFS_I(inode)->extent_tree; 1352 em = alloc_extent_map(); 1353 BUG_ON(!em); /* -ENOMEM */ 1354 em->start = cur_offset; 1355 em->orig_start = found_key.offset - extent_offset; 1356 em->len = num_bytes; 1357 em->block_len = num_bytes; 1358 em->block_start = disk_bytenr; 1359 em->orig_block_len = disk_num_bytes; 1360 em->ram_bytes = ram_bytes; 1361 em->bdev = root->fs_info->fs_devices->latest_bdev; 1362 em->mod_start = em->start; 1363 em->mod_len = em->len; 1364 set_bit(EXTENT_FLAG_PINNED, &em->flags); 1365 set_bit(EXTENT_FLAG_FILLING, &em->flags); 1366 em->generation = -1; 1367 while (1) { 1368 write_lock(&em_tree->lock); 1369 ret = add_extent_mapping(em_tree, em, 1); 1370 write_unlock(&em_tree->lock); 1371 if (ret != -EEXIST) { 1372 free_extent_map(em); 1373 break; 1374 } 1375 btrfs_drop_extent_cache(inode, em->start, 1376 em->start + em->len - 1, 0); 1377 } 1378 type = BTRFS_ORDERED_PREALLOC; 1379 } else { 1380 type = BTRFS_ORDERED_NOCOW; 1381 } 1382 1383 ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr, 1384 num_bytes, num_bytes, type); 1385 BUG_ON(ret); /* -ENOMEM */ 1386 1387 if (root->root_key.objectid == 1388 BTRFS_DATA_RELOC_TREE_OBJECTID) { 1389 ret = btrfs_reloc_clone_csums(inode, cur_offset, 1390 num_bytes); 1391 if (ret) { 1392 if (!nolock && nocow) 1393 btrfs_end_nocow_write(root); 1394 goto error; 1395 } 1396 } 1397 1398 extent_clear_unlock_delalloc(inode, cur_offset, 1399 cur_offset + num_bytes - 1, 1400 locked_page, EXTENT_LOCKED | 1401 EXTENT_DELALLOC, PAGE_UNLOCK | 1402 PAGE_SET_PRIVATE2); 1403 if (!nolock && nocow) 1404 btrfs_end_nocow_write(root); 1405 cur_offset = extent_end; 1406 if (cur_offset > end) 1407 break; 1408 } 1409 btrfs_release_path(path); 1410 1411 if (cur_offset <= end && cow_start == (u64)-1) { 1412 cow_start = cur_offset; 1413 cur_offset = end; 1414 } 1415 1416 if (cow_start != (u64)-1) { 1417 ret = cow_file_range(inode, locked_page, cow_start, end, 1418 page_started, nr_written, 1); 1419 if (ret) 1420 goto error; 1421 } 1422 1423 error: 1424 err = btrfs_end_transaction(trans, root); 1425 if (!ret) 1426 ret = err; 1427 1428 if (ret && cur_offset < end) 1429 extent_clear_unlock_delalloc(inode, cur_offset, end, 1430 locked_page, EXTENT_LOCKED | 1431 EXTENT_DELALLOC | EXTENT_DEFRAG | 1432 EXTENT_DO_ACCOUNTING, PAGE_UNLOCK | 1433 PAGE_CLEAR_DIRTY | 1434 PAGE_SET_WRITEBACK | 1435 PAGE_END_WRITEBACK); 1436 btrfs_free_path(path); 1437 return ret; 1438 } 1439 1440 /* 1441 * extent_io.c call back to do delayed allocation processing 1442 */ 1443 static int run_delalloc_range(struct inode *inode, struct page *locked_page, 1444 u64 start, u64 end, int *page_started, 1445 unsigned long *nr_written) 1446 { 1447 int ret; 1448 struct btrfs_root *root = BTRFS_I(inode)->root; 1449 1450 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) { 1451 ret = run_delalloc_nocow(inode, locked_page, start, end, 1452 page_started, 1, nr_written); 1453 } else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) { 1454 ret = run_delalloc_nocow(inode, locked_page, start, end, 1455 page_started, 0, nr_written); 1456 } else if (!btrfs_test_opt(root, COMPRESS) && 1457 !(BTRFS_I(inode)->force_compress) && 1458 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) { 1459 ret = cow_file_range(inode, locked_page, start, end, 1460 page_started, nr_written, 1); 1461 } else { 1462 set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, 1463 &BTRFS_I(inode)->runtime_flags); 1464 ret = cow_file_range_async(inode, locked_page, start, end, 1465 page_started, nr_written); 1466 } 1467 return ret; 1468 } 1469 1470 static void btrfs_split_extent_hook(struct inode *inode, 1471 struct extent_state *orig, u64 split) 1472 { 1473 /* not delalloc, ignore it */ 1474 if (!(orig->state & EXTENT_DELALLOC)) 1475 return; 1476 1477 spin_lock(&BTRFS_I(inode)->lock); 1478 BTRFS_I(inode)->outstanding_extents++; 1479 spin_unlock(&BTRFS_I(inode)->lock); 1480 } 1481 1482 /* 1483 * extent_io.c merge_extent_hook, used to track merged delayed allocation 1484 * extents so we can keep track of new extents that are just merged onto old 1485 * extents, such as when we are doing sequential writes, so we can properly 1486 * account for the metadata space we'll need. 1487 */ 1488 static void btrfs_merge_extent_hook(struct inode *inode, 1489 struct extent_state *new, 1490 struct extent_state *other) 1491 { 1492 /* not delalloc, ignore it */ 1493 if (!(other->state & EXTENT_DELALLOC)) 1494 return; 1495 1496 spin_lock(&BTRFS_I(inode)->lock); 1497 BTRFS_I(inode)->outstanding_extents--; 1498 spin_unlock(&BTRFS_I(inode)->lock); 1499 } 1500 1501 static void btrfs_add_delalloc_inodes(struct btrfs_root *root, 1502 struct inode *inode) 1503 { 1504 spin_lock(&root->delalloc_lock); 1505 if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) { 1506 list_add_tail(&BTRFS_I(inode)->delalloc_inodes, 1507 &root->delalloc_inodes); 1508 set_bit(BTRFS_INODE_IN_DELALLOC_LIST, 1509 &BTRFS_I(inode)->runtime_flags); 1510 root->nr_delalloc_inodes++; 1511 if (root->nr_delalloc_inodes == 1) { 1512 spin_lock(&root->fs_info->delalloc_root_lock); 1513 BUG_ON(!list_empty(&root->delalloc_root)); 1514 list_add_tail(&root->delalloc_root, 1515 &root->fs_info->delalloc_roots); 1516 spin_unlock(&root->fs_info->delalloc_root_lock); 1517 } 1518 } 1519 spin_unlock(&root->delalloc_lock); 1520 } 1521 1522 static void btrfs_del_delalloc_inode(struct btrfs_root *root, 1523 struct inode *inode) 1524 { 1525 spin_lock(&root->delalloc_lock); 1526 if (!list_empty(&BTRFS_I(inode)->delalloc_inodes)) { 1527 list_del_init(&BTRFS_I(inode)->delalloc_inodes); 1528 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST, 1529 &BTRFS_I(inode)->runtime_flags); 1530 root->nr_delalloc_inodes--; 1531 if (!root->nr_delalloc_inodes) { 1532 spin_lock(&root->fs_info->delalloc_root_lock); 1533 BUG_ON(list_empty(&root->delalloc_root)); 1534 list_del_init(&root->delalloc_root); 1535 spin_unlock(&root->fs_info->delalloc_root_lock); 1536 } 1537 } 1538 spin_unlock(&root->delalloc_lock); 1539 } 1540 1541 /* 1542 * extent_io.c set_bit_hook, used to track delayed allocation 1543 * bytes in this file, and to maintain the list of inodes that 1544 * have pending delalloc work to be done. 1545 */ 1546 static void btrfs_set_bit_hook(struct inode *inode, 1547 struct extent_state *state, unsigned long *bits) 1548 { 1549 1550 /* 1551 * set_bit and clear bit hooks normally require _irqsave/restore 1552 * but in this case, we are only testing for the DELALLOC 1553 * bit, which is only set or cleared with irqs on 1554 */ 1555 if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) { 1556 struct btrfs_root *root = BTRFS_I(inode)->root; 1557 u64 len = state->end + 1 - state->start; 1558 bool do_list = !btrfs_is_free_space_inode(inode); 1559 1560 if (*bits & EXTENT_FIRST_DELALLOC) { 1561 *bits &= ~EXTENT_FIRST_DELALLOC; 1562 } else { 1563 spin_lock(&BTRFS_I(inode)->lock); 1564 BTRFS_I(inode)->outstanding_extents++; 1565 spin_unlock(&BTRFS_I(inode)->lock); 1566 } 1567 1568 __percpu_counter_add(&root->fs_info->delalloc_bytes, len, 1569 root->fs_info->delalloc_batch); 1570 spin_lock(&BTRFS_I(inode)->lock); 1571 BTRFS_I(inode)->delalloc_bytes += len; 1572 if (do_list && !test_bit(BTRFS_INODE_IN_DELALLOC_LIST, 1573 &BTRFS_I(inode)->runtime_flags)) 1574 btrfs_add_delalloc_inodes(root, inode); 1575 spin_unlock(&BTRFS_I(inode)->lock); 1576 } 1577 } 1578 1579 /* 1580 * extent_io.c clear_bit_hook, see set_bit_hook for why 1581 */ 1582 static void btrfs_clear_bit_hook(struct inode *inode, 1583 struct extent_state *state, 1584 unsigned long *bits) 1585 { 1586 /* 1587 * set_bit and clear bit hooks normally require _irqsave/restore 1588 * but in this case, we are only testing for the DELALLOC 1589 * bit, which is only set or cleared with irqs on 1590 */ 1591 if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) { 1592 struct btrfs_root *root = BTRFS_I(inode)->root; 1593 u64 len = state->end + 1 - state->start; 1594 bool do_list = !btrfs_is_free_space_inode(inode); 1595 1596 if (*bits & EXTENT_FIRST_DELALLOC) { 1597 *bits &= ~EXTENT_FIRST_DELALLOC; 1598 } else if (!(*bits & EXTENT_DO_ACCOUNTING)) { 1599 spin_lock(&BTRFS_I(inode)->lock); 1600 BTRFS_I(inode)->outstanding_extents--; 1601 spin_unlock(&BTRFS_I(inode)->lock); 1602 } 1603 1604 /* 1605 * We don't reserve metadata space for space cache inodes so we 1606 * don't need to call dellalloc_release_metadata if there is an 1607 * error. 1608 */ 1609 if (*bits & EXTENT_DO_ACCOUNTING && 1610 root != root->fs_info->tree_root) 1611 btrfs_delalloc_release_metadata(inode, len); 1612 1613 if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID 1614 && do_list && !(state->state & EXTENT_NORESERVE)) 1615 btrfs_free_reserved_data_space(inode, len); 1616 1617 __percpu_counter_add(&root->fs_info->delalloc_bytes, -len, 1618 root->fs_info->delalloc_batch); 1619 spin_lock(&BTRFS_I(inode)->lock); 1620 BTRFS_I(inode)->delalloc_bytes -= len; 1621 if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 && 1622 test_bit(BTRFS_INODE_IN_DELALLOC_LIST, 1623 &BTRFS_I(inode)->runtime_flags)) 1624 btrfs_del_delalloc_inode(root, inode); 1625 spin_unlock(&BTRFS_I(inode)->lock); 1626 } 1627 } 1628 1629 /* 1630 * extent_io.c merge_bio_hook, this must check the chunk tree to make sure 1631 * we don't create bios that span stripes or chunks 1632 */ 1633 int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset, 1634 size_t size, struct bio *bio, 1635 unsigned long bio_flags) 1636 { 1637 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root; 1638 u64 logical = (u64)bio->bi_iter.bi_sector << 9; 1639 u64 length = 0; 1640 u64 map_length; 1641 int ret; 1642 1643 if (bio_flags & EXTENT_BIO_COMPRESSED) 1644 return 0; 1645 1646 length = bio->bi_iter.bi_size; 1647 map_length = length; 1648 ret = btrfs_map_block(root->fs_info, rw, logical, 1649 &map_length, NULL, 0); 1650 /* Will always return 0 with map_multi == NULL */ 1651 BUG_ON(ret < 0); 1652 if (map_length < length + size) 1653 return 1; 1654 return 0; 1655 } 1656 1657 /* 1658 * in order to insert checksums into the metadata in large chunks, 1659 * we wait until bio submission time. All the pages in the bio are 1660 * checksummed and sums are attached onto the ordered extent record. 1661 * 1662 * At IO completion time the cums attached on the ordered extent record 1663 * are inserted into the btree 1664 */ 1665 static int __btrfs_submit_bio_start(struct inode *inode, int rw, 1666 struct bio *bio, int mirror_num, 1667 unsigned long bio_flags, 1668 u64 bio_offset) 1669 { 1670 struct btrfs_root *root = BTRFS_I(inode)->root; 1671 int ret = 0; 1672 1673 ret = btrfs_csum_one_bio(root, inode, bio, 0, 0); 1674 BUG_ON(ret); /* -ENOMEM */ 1675 return 0; 1676 } 1677 1678 /* 1679 * in order to insert checksums into the metadata in large chunks, 1680 * we wait until bio submission time. All the pages in the bio are 1681 * checksummed and sums are attached onto the ordered extent record. 1682 * 1683 * At IO completion time the cums attached on the ordered extent record 1684 * are inserted into the btree 1685 */ 1686 static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio, 1687 int mirror_num, unsigned long bio_flags, 1688 u64 bio_offset) 1689 { 1690 struct btrfs_root *root = BTRFS_I(inode)->root; 1691 int ret; 1692 1693 ret = btrfs_map_bio(root, rw, bio, mirror_num, 1); 1694 if (ret) 1695 bio_endio(bio, ret); 1696 return ret; 1697 } 1698 1699 /* 1700 * extent_io.c submission hook. This does the right thing for csum calculation 1701 * on write, or reading the csums from the tree before a read 1702 */ 1703 static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio, 1704 int mirror_num, unsigned long bio_flags, 1705 u64 bio_offset) 1706 { 1707 struct btrfs_root *root = BTRFS_I(inode)->root; 1708 int ret = 0; 1709 int skip_sum; 1710 int metadata = 0; 1711 int async = !atomic_read(&BTRFS_I(inode)->sync_writers); 1712 1713 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; 1714 1715 if (btrfs_is_free_space_inode(inode)) 1716 metadata = 2; 1717 1718 if (!(rw & REQ_WRITE)) { 1719 ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata); 1720 if (ret) 1721 goto out; 1722 1723 if (bio_flags & EXTENT_BIO_COMPRESSED) { 1724 ret = btrfs_submit_compressed_read(inode, bio, 1725 mirror_num, 1726 bio_flags); 1727 goto out; 1728 } else if (!skip_sum) { 1729 ret = btrfs_lookup_bio_sums(root, inode, bio, NULL); 1730 if (ret) 1731 goto out; 1732 } 1733 goto mapit; 1734 } else if (async && !skip_sum) { 1735 /* csum items have already been cloned */ 1736 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID) 1737 goto mapit; 1738 /* we're doing a write, do the async checksumming */ 1739 ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info, 1740 inode, rw, bio, mirror_num, 1741 bio_flags, bio_offset, 1742 __btrfs_submit_bio_start, 1743 __btrfs_submit_bio_done); 1744 goto out; 1745 } else if (!skip_sum) { 1746 ret = btrfs_csum_one_bio(root, inode, bio, 0, 0); 1747 if (ret) 1748 goto out; 1749 } 1750 1751 mapit: 1752 ret = btrfs_map_bio(root, rw, bio, mirror_num, 0); 1753 1754 out: 1755 if (ret < 0) 1756 bio_endio(bio, ret); 1757 return ret; 1758 } 1759 1760 /* 1761 * given a list of ordered sums record them in the inode. This happens 1762 * at IO completion time based on sums calculated at bio submission time. 1763 */ 1764 static noinline int add_pending_csums(struct btrfs_trans_handle *trans, 1765 struct inode *inode, u64 file_offset, 1766 struct list_head *list) 1767 { 1768 struct btrfs_ordered_sum *sum; 1769 1770 list_for_each_entry(sum, list, list) { 1771 trans->adding_csums = 1; 1772 btrfs_csum_file_blocks(trans, 1773 BTRFS_I(inode)->root->fs_info->csum_root, sum); 1774 trans->adding_csums = 0; 1775 } 1776 return 0; 1777 } 1778 1779 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end, 1780 struct extent_state **cached_state) 1781 { 1782 WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0); 1783 return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end, 1784 cached_state, GFP_NOFS); 1785 } 1786 1787 /* see btrfs_writepage_start_hook for details on why this is required */ 1788 struct btrfs_writepage_fixup { 1789 struct page *page; 1790 struct btrfs_work work; 1791 }; 1792 1793 static void btrfs_writepage_fixup_worker(struct btrfs_work *work) 1794 { 1795 struct btrfs_writepage_fixup *fixup; 1796 struct btrfs_ordered_extent *ordered; 1797 struct extent_state *cached_state = NULL; 1798 struct page *page; 1799 struct inode *inode; 1800 u64 page_start; 1801 u64 page_end; 1802 int ret; 1803 1804 fixup = container_of(work, struct btrfs_writepage_fixup, work); 1805 page = fixup->page; 1806 again: 1807 lock_page(page); 1808 if (!page->mapping || !PageDirty(page) || !PageChecked(page)) { 1809 ClearPageChecked(page); 1810 goto out_page; 1811 } 1812 1813 inode = page->mapping->host; 1814 page_start = page_offset(page); 1815 page_end = page_offset(page) + PAGE_CACHE_SIZE - 1; 1816 1817 lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0, 1818 &cached_state); 1819 1820 /* already ordered? We're done */ 1821 if (PagePrivate2(page)) 1822 goto out; 1823 1824 ordered = btrfs_lookup_ordered_extent(inode, page_start); 1825 if (ordered) { 1826 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, 1827 page_end, &cached_state, GFP_NOFS); 1828 unlock_page(page); 1829 btrfs_start_ordered_extent(inode, ordered, 1); 1830 btrfs_put_ordered_extent(ordered); 1831 goto again; 1832 } 1833 1834 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE); 1835 if (ret) { 1836 mapping_set_error(page->mapping, ret); 1837 end_extent_writepage(page, ret, page_start, page_end); 1838 ClearPageChecked(page); 1839 goto out; 1840 } 1841 1842 btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state); 1843 ClearPageChecked(page); 1844 set_page_dirty(page); 1845 out: 1846 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end, 1847 &cached_state, GFP_NOFS); 1848 out_page: 1849 unlock_page(page); 1850 page_cache_release(page); 1851 kfree(fixup); 1852 } 1853 1854 /* 1855 * There are a few paths in the higher layers of the kernel that directly 1856 * set the page dirty bit without asking the filesystem if it is a 1857 * good idea. This causes problems because we want to make sure COW 1858 * properly happens and the data=ordered rules are followed. 1859 * 1860 * In our case any range that doesn't have the ORDERED bit set 1861 * hasn't been properly setup for IO. We kick off an async process 1862 * to fix it up. The async helper will wait for ordered extents, set 1863 * the delalloc bit and make it safe to write the page. 1864 */ 1865 static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end) 1866 { 1867 struct inode *inode = page->mapping->host; 1868 struct btrfs_writepage_fixup *fixup; 1869 struct btrfs_root *root = BTRFS_I(inode)->root; 1870 1871 /* this page is properly in the ordered list */ 1872 if (TestClearPagePrivate2(page)) 1873 return 0; 1874 1875 if (PageChecked(page)) 1876 return -EAGAIN; 1877 1878 fixup = kzalloc(sizeof(*fixup), GFP_NOFS); 1879 if (!fixup) 1880 return -EAGAIN; 1881 1882 SetPageChecked(page); 1883 page_cache_get(page); 1884 btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL, NULL); 1885 fixup->page = page; 1886 btrfs_queue_work(root->fs_info->fixup_workers, &fixup->work); 1887 return -EBUSY; 1888 } 1889 1890 static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, 1891 struct inode *inode, u64 file_pos, 1892 u64 disk_bytenr, u64 disk_num_bytes, 1893 u64 num_bytes, u64 ram_bytes, 1894 u8 compression, u8 encryption, 1895 u16 other_encoding, int extent_type) 1896 { 1897 struct btrfs_root *root = BTRFS_I(inode)->root; 1898 struct btrfs_file_extent_item *fi; 1899 struct btrfs_path *path; 1900 struct extent_buffer *leaf; 1901 struct btrfs_key ins; 1902 int extent_inserted = 0; 1903 int ret; 1904 1905 path = btrfs_alloc_path(); 1906 if (!path) 1907 return -ENOMEM; 1908 1909 /* 1910 * we may be replacing one extent in the tree with another. 1911 * The new extent is pinned in the extent map, and we don't want 1912 * to drop it from the cache until it is completely in the btree. 1913 * 1914 * So, tell btrfs_drop_extents to leave this extent in the cache. 1915 * the caller is expected to unpin it and allow it to be merged 1916 * with the others. 1917 */ 1918 ret = __btrfs_drop_extents(trans, root, inode, path, file_pos, 1919 file_pos + num_bytes, NULL, 0, 1920 1, sizeof(*fi), &extent_inserted); 1921 if (ret) 1922 goto out; 1923 1924 if (!extent_inserted) { 1925 ins.objectid = btrfs_ino(inode); 1926 ins.offset = file_pos; 1927 ins.type = BTRFS_EXTENT_DATA_KEY; 1928 1929 path->leave_spinning = 1; 1930 ret = btrfs_insert_empty_item(trans, root, path, &ins, 1931 sizeof(*fi)); 1932 if (ret) 1933 goto out; 1934 } 1935 leaf = path->nodes[0]; 1936 fi = btrfs_item_ptr(leaf, path->slots[0], 1937 struct btrfs_file_extent_item); 1938 btrfs_set_file_extent_generation(leaf, fi, trans->transid); 1939 btrfs_set_file_extent_type(leaf, fi, extent_type); 1940 btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr); 1941 btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes); 1942 btrfs_set_file_extent_offset(leaf, fi, 0); 1943 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes); 1944 btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes); 1945 btrfs_set_file_extent_compression(leaf, fi, compression); 1946 btrfs_set_file_extent_encryption(leaf, fi, encryption); 1947 btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding); 1948 1949 btrfs_mark_buffer_dirty(leaf); 1950 btrfs_release_path(path); 1951 1952 inode_add_bytes(inode, num_bytes); 1953 1954 ins.objectid = disk_bytenr; 1955 ins.offset = disk_num_bytes; 1956 ins.type = BTRFS_EXTENT_ITEM_KEY; 1957 ret = btrfs_alloc_reserved_file_extent(trans, root, 1958 root->root_key.objectid, 1959 btrfs_ino(inode), file_pos, &ins); 1960 out: 1961 btrfs_free_path(path); 1962 1963 return ret; 1964 } 1965 1966 /* snapshot-aware defrag */ 1967 struct sa_defrag_extent_backref { 1968 struct rb_node node; 1969 struct old_sa_defrag_extent *old; 1970 u64 root_id; 1971 u64 inum; 1972 u64 file_pos; 1973 u64 extent_offset; 1974 u64 num_bytes; 1975 u64 generation; 1976 }; 1977 1978 struct old_sa_defrag_extent { 1979 struct list_head list; 1980 struct new_sa_defrag_extent *new; 1981 1982 u64 extent_offset; 1983 u64 bytenr; 1984 u64 offset; 1985 u64 len; 1986 int count; 1987 }; 1988 1989 struct new_sa_defrag_extent { 1990 struct rb_root root; 1991 struct list_head head; 1992 struct btrfs_path *path; 1993 struct inode *inode; 1994 u64 file_pos; 1995 u64 len; 1996 u64 bytenr; 1997 u64 disk_len; 1998 u8 compress_type; 1999 }; 2000 2001 static int backref_comp(struct sa_defrag_extent_backref *b1, 2002 struct sa_defrag_extent_backref *b2) 2003 { 2004 if (b1->root_id < b2->root_id) 2005 return -1; 2006 else if (b1->root_id > b2->root_id) 2007 return 1; 2008 2009 if (b1->inum < b2->inum) 2010 return -1; 2011 else if (b1->inum > b2->inum) 2012 return 1; 2013 2014 if (b1->file_pos < b2->file_pos) 2015 return -1; 2016 else if (b1->file_pos > b2->file_pos) 2017 return 1; 2018 2019 /* 2020 * [------------------------------] ===> (a range of space) 2021 * |<--->| |<---->| =============> (fs/file tree A) 2022 * |<---------------------------->| ===> (fs/file tree B) 2023 * 2024 * A range of space can refer to two file extents in one tree while 2025 * refer to only one file extent in another tree. 2026 * 2027 * So we may process a disk offset more than one time(two extents in A) 2028 * and locate at the same extent(one extent in B), then insert two same 2029 * backrefs(both refer to the extent in B). 2030 */ 2031 return 0; 2032 } 2033 2034 static void backref_insert(struct rb_root *root, 2035 struct sa_defrag_extent_backref *backref) 2036 { 2037 struct rb_node **p = &root->rb_node; 2038 struct rb_node *parent = NULL; 2039 struct sa_defrag_extent_backref *entry; 2040 int ret; 2041 2042 while (*p) { 2043 parent = *p; 2044 entry = rb_entry(parent, struct sa_defrag_extent_backref, node); 2045 2046 ret = backref_comp(backref, entry); 2047 if (ret < 0) 2048 p = &(*p)->rb_left; 2049 else 2050 p = &(*p)->rb_right; 2051 } 2052 2053 rb_link_node(&backref->node, parent, p); 2054 rb_insert_color(&backref->node, root); 2055 } 2056 2057 /* 2058 * Note the backref might has changed, and in this case we just return 0. 2059 */ 2060 static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id, 2061 void *ctx) 2062 { 2063 struct btrfs_file_extent_item *extent; 2064 struct btrfs_fs_info *fs_info; 2065 struct old_sa_defrag_extent *old = ctx; 2066 struct new_sa_defrag_extent *new = old->new; 2067 struct btrfs_path *path = new->path; 2068 struct btrfs_key key; 2069 struct btrfs_root *root; 2070 struct sa_defrag_extent_backref *backref; 2071 struct extent_buffer *leaf; 2072 struct inode *inode = new->inode; 2073 int slot; 2074 int ret; 2075 u64 extent_offset; 2076 u64 num_bytes; 2077 2078 if (BTRFS_I(inode)->root->root_key.objectid == root_id && 2079 inum == btrfs_ino(inode)) 2080 return 0; 2081 2082 key.objectid = root_id; 2083 key.type = BTRFS_ROOT_ITEM_KEY; 2084 key.offset = (u64)-1; 2085 2086 fs_info = BTRFS_I(inode)->root->fs_info; 2087 root = btrfs_read_fs_root_no_name(fs_info, &key); 2088 if (IS_ERR(root)) { 2089 if (PTR_ERR(root) == -ENOENT) 2090 return 0; 2091 WARN_ON(1); 2092 pr_debug("inum=%llu, offset=%llu, root_id=%llu\n", 2093 inum, offset, root_id); 2094 return PTR_ERR(root); 2095 } 2096 2097 key.objectid = inum; 2098 key.type = BTRFS_EXTENT_DATA_KEY; 2099 if (offset > (u64)-1 << 32) 2100 key.offset = 0; 2101 else 2102 key.offset = offset; 2103 2104 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 2105 if (WARN_ON(ret < 0)) 2106 return ret; 2107 ret = 0; 2108 2109 while (1) { 2110 cond_resched(); 2111 2112 leaf = path->nodes[0]; 2113 slot = path->slots[0]; 2114 2115 if (slot >= btrfs_header_nritems(leaf)) { 2116 ret = btrfs_next_leaf(root, path); 2117 if (ret < 0) { 2118 goto out; 2119 } else if (ret > 0) { 2120 ret = 0; 2121 goto out; 2122 } 2123 continue; 2124 } 2125 2126 path->slots[0]++; 2127 2128 btrfs_item_key_to_cpu(leaf, &key, slot); 2129 2130 if (key.objectid > inum) 2131 goto out; 2132 2133 if (key.objectid < inum || key.type != BTRFS_EXTENT_DATA_KEY) 2134 continue; 2135 2136 extent = btrfs_item_ptr(leaf, slot, 2137 struct btrfs_file_extent_item); 2138 2139 if (btrfs_file_extent_disk_bytenr(leaf, extent) != old->bytenr) 2140 continue; 2141 2142 /* 2143 * 'offset' refers to the exact key.offset, 2144 * NOT the 'offset' field in btrfs_extent_data_ref, ie. 2145 * (key.offset - extent_offset). 2146 */ 2147 if (key.offset != offset) 2148 continue; 2149 2150 extent_offset = btrfs_file_extent_offset(leaf, extent); 2151 num_bytes = btrfs_file_extent_num_bytes(leaf, extent); 2152 2153 if (extent_offset >= old->extent_offset + old->offset + 2154 old->len || extent_offset + num_bytes <= 2155 old->extent_offset + old->offset) 2156 continue; 2157 break; 2158 } 2159 2160 backref = kmalloc(sizeof(*backref), GFP_NOFS); 2161 if (!backref) { 2162 ret = -ENOENT; 2163 goto out; 2164 } 2165 2166 backref->root_id = root_id; 2167 backref->inum = inum; 2168 backref->file_pos = offset; 2169 backref->num_bytes = num_bytes; 2170 backref->extent_offset = extent_offset; 2171 backref->generation = btrfs_file_extent_generation(leaf, extent); 2172 backref->old = old; 2173 backref_insert(&new->root, backref); 2174 old->count++; 2175 out: 2176 btrfs_release_path(path); 2177 WARN_ON(ret); 2178 return ret; 2179 } 2180 2181 static noinline bool record_extent_backrefs(struct btrfs_path *path, 2182 struct new_sa_defrag_extent *new) 2183 { 2184 struct btrfs_fs_info *fs_info = BTRFS_I(new->inode)->root->fs_info; 2185 struct old_sa_defrag_extent *old, *tmp; 2186 int ret; 2187 2188 new->path = path; 2189 2190 list_for_each_entry_safe(old, tmp, &new->head, list) { 2191 ret = iterate_inodes_from_logical(old->bytenr + 2192 old->extent_offset, fs_info, 2193 path, record_one_backref, 2194 old); 2195 if (ret < 0 && ret != -ENOENT) 2196 return false; 2197 2198 /* no backref to be processed for this extent */ 2199 if (!old->count) { 2200 list_del(&old->list); 2201 kfree(old); 2202 } 2203 } 2204 2205 if (list_empty(&new->head)) 2206 return false; 2207 2208 return true; 2209 } 2210 2211 static int relink_is_mergable(struct extent_buffer *leaf, 2212 struct btrfs_file_extent_item *fi, 2213 struct new_sa_defrag_extent *new) 2214 { 2215 if (btrfs_file_extent_disk_bytenr(leaf, fi) != new->bytenr) 2216 return 0; 2217 2218 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG) 2219 return 0; 2220 2221 if (btrfs_file_extent_compression(leaf, fi) != new->compress_type) 2222 return 0; 2223 2224 if (btrfs_file_extent_encryption(leaf, fi) || 2225 btrfs_file_extent_other_encoding(leaf, fi)) 2226 return 0; 2227 2228 return 1; 2229 } 2230 2231 /* 2232 * Note the backref might has changed, and in this case we just return 0. 2233 */ 2234 static noinline int relink_extent_backref(struct btrfs_path *path, 2235 struct sa_defrag_extent_backref *prev, 2236 struct sa_defrag_extent_backref *backref) 2237 { 2238 struct btrfs_file_extent_item *extent; 2239 struct btrfs_file_extent_item *item; 2240 struct btrfs_ordered_extent *ordered; 2241 struct btrfs_trans_handle *trans; 2242 struct btrfs_fs_info *fs_info; 2243 struct btrfs_root *root; 2244 struct btrfs_key key; 2245 struct extent_buffer *leaf; 2246 struct old_sa_defrag_extent *old = backref->old; 2247 struct new_sa_defrag_extent *new = old->new; 2248 struct inode *src_inode = new->inode; 2249 struct inode *inode; 2250 struct extent_state *cached = NULL; 2251 int ret = 0; 2252 u64 start; 2253 u64 len; 2254 u64 lock_start; 2255 u64 lock_end; 2256 bool merge = false; 2257 int index; 2258 2259 if (prev && prev->root_id == backref->root_id && 2260 prev->inum == backref->inum && 2261 prev->file_pos + prev->num_bytes == backref->file_pos) 2262 merge = true; 2263 2264 /* step 1: get root */ 2265 key.objectid = backref->root_id; 2266 key.type = BTRFS_ROOT_ITEM_KEY; 2267 key.offset = (u64)-1; 2268 2269 fs_info = BTRFS_I(src_inode)->root->fs_info; 2270 index = srcu_read_lock(&fs_info->subvol_srcu); 2271 2272 root = btrfs_read_fs_root_no_name(fs_info, &key); 2273 if (IS_ERR(root)) { 2274 srcu_read_unlock(&fs_info->subvol_srcu, index); 2275 if (PTR_ERR(root) == -ENOENT) 2276 return 0; 2277 return PTR_ERR(root); 2278 } 2279 2280 if (btrfs_root_readonly(root)) { 2281 srcu_read_unlock(&fs_info->subvol_srcu, index); 2282 return 0; 2283 } 2284 2285 /* step 2: get inode */ 2286 key.objectid = backref->inum; 2287 key.type = BTRFS_INODE_ITEM_KEY; 2288 key.offset = 0; 2289 2290 inode = btrfs_iget(fs_info->sb, &key, root, NULL); 2291 if (IS_ERR(inode)) { 2292 srcu_read_unlock(&fs_info->subvol_srcu, index); 2293 return 0; 2294 } 2295 2296 srcu_read_unlock(&fs_info->subvol_srcu, index); 2297 2298 /* step 3: relink backref */ 2299 lock_start = backref->file_pos; 2300 lock_end = backref->file_pos + backref->num_bytes - 1; 2301 lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, lock_end, 2302 0, &cached); 2303 2304 ordered = btrfs_lookup_first_ordered_extent(inode, lock_end); 2305 if (ordered) { 2306 btrfs_put_ordered_extent(ordered); 2307 goto out_unlock; 2308 } 2309 2310 trans = btrfs_join_transaction(root); 2311 if (IS_ERR(trans)) { 2312 ret = PTR_ERR(trans); 2313 goto out_unlock; 2314 } 2315 2316 key.objectid = backref->inum; 2317 key.type = BTRFS_EXTENT_DATA_KEY; 2318 key.offset = backref->file_pos; 2319 2320 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 2321 if (ret < 0) { 2322 goto out_free_path; 2323 } else if (ret > 0) { 2324 ret = 0; 2325 goto out_free_path; 2326 } 2327 2328 extent = btrfs_item_ptr(path->nodes[0], path->slots[0], 2329 struct btrfs_file_extent_item); 2330 2331 if (btrfs_file_extent_generation(path->nodes[0], extent) != 2332 backref->generation) 2333 goto out_free_path; 2334 2335 btrfs_release_path(path); 2336 2337 start = backref->file_pos; 2338 if (backref->extent_offset < old->extent_offset + old->offset) 2339 start += old->extent_offset + old->offset - 2340 backref->extent_offset; 2341 2342 len = min(backref->extent_offset + backref->num_bytes, 2343 old->extent_offset + old->offset + old->len); 2344 len -= max(backref->extent_offset, old->extent_offset + old->offset); 2345 2346 ret = btrfs_drop_extents(trans, root, inode, start, 2347 start + len, 1); 2348 if (ret) 2349 goto out_free_path; 2350 again: 2351 key.objectid = btrfs_ino(inode); 2352 key.type = BTRFS_EXTENT_DATA_KEY; 2353 key.offset = start; 2354 2355 path->leave_spinning = 1; 2356 if (merge) { 2357 struct btrfs_file_extent_item *fi; 2358 u64 extent_len; 2359 struct btrfs_key found_key; 2360 2361 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 2362 if (ret < 0) 2363 goto out_free_path; 2364 2365 path->slots[0]--; 2366 leaf = path->nodes[0]; 2367 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 2368 2369 fi = btrfs_item_ptr(leaf, path->slots[0], 2370 struct btrfs_file_extent_item); 2371 extent_len = btrfs_file_extent_num_bytes(leaf, fi); 2372 2373 if (extent_len + found_key.offset == start && 2374 relink_is_mergable(leaf, fi, new)) { 2375 btrfs_set_file_extent_num_bytes(leaf, fi, 2376 extent_len + len); 2377 btrfs_mark_buffer_dirty(leaf); 2378 inode_add_bytes(inode, len); 2379 2380 ret = 1; 2381 goto out_free_path; 2382 } else { 2383 merge = false; 2384 btrfs_release_path(path); 2385 goto again; 2386 } 2387 } 2388 2389 ret = btrfs_insert_empty_item(trans, root, path, &key, 2390 sizeof(*extent)); 2391 if (ret) { 2392 btrfs_abort_transaction(trans, root, ret); 2393 goto out_free_path; 2394 } 2395 2396 leaf = path->nodes[0]; 2397 item = btrfs_item_ptr(leaf, path->slots[0], 2398 struct btrfs_file_extent_item); 2399 btrfs_set_file_extent_disk_bytenr(leaf, item, new->bytenr); 2400 btrfs_set_file_extent_disk_num_bytes(leaf, item, new->disk_len); 2401 btrfs_set_file_extent_offset(leaf, item, start - new->file_pos); 2402 btrfs_set_file_extent_num_bytes(leaf, item, len); 2403 btrfs_set_file_extent_ram_bytes(leaf, item, new->len); 2404 btrfs_set_file_extent_generation(leaf, item, trans->transid); 2405 btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG); 2406 btrfs_set_file_extent_compression(leaf, item, new->compress_type); 2407 btrfs_set_file_extent_encryption(leaf, item, 0); 2408 btrfs_set_file_extent_other_encoding(leaf, item, 0); 2409 2410 btrfs_mark_buffer_dirty(leaf); 2411 inode_add_bytes(inode, len); 2412 btrfs_release_path(path); 2413 2414 ret = btrfs_inc_extent_ref(trans, root, new->bytenr, 2415 new->disk_len, 0, 2416 backref->root_id, backref->inum, 2417 new->file_pos, 0); /* start - extent_offset */ 2418 if (ret) { 2419 btrfs_abort_transaction(trans, root, ret); 2420 goto out_free_path; 2421 } 2422 2423 ret = 1; 2424 out_free_path: 2425 btrfs_release_path(path); 2426 path->leave_spinning = 0; 2427 btrfs_end_transaction(trans, root); 2428 out_unlock: 2429 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start, lock_end, 2430 &cached, GFP_NOFS); 2431 iput(inode); 2432 return ret; 2433 } 2434 2435 static void free_sa_defrag_extent(struct new_sa_defrag_extent *new) 2436 { 2437 struct old_sa_defrag_extent *old, *tmp; 2438 2439 if (!new) 2440 return; 2441 2442 list_for_each_entry_safe(old, tmp, &new->head, list) { 2443 list_del(&old->list); 2444 kfree(old); 2445 } 2446 kfree(new); 2447 } 2448 2449 static void relink_file_extents(struct new_sa_defrag_extent *new) 2450 { 2451 struct btrfs_path *path; 2452 struct sa_defrag_extent_backref *backref; 2453 struct sa_defrag_extent_backref *prev = NULL; 2454 struct inode *inode; 2455 struct btrfs_root *root; 2456 struct rb_node *node; 2457 int ret; 2458 2459 inode = new->inode; 2460 root = BTRFS_I(inode)->root; 2461 2462 path = btrfs_alloc_path(); 2463 if (!path) 2464 return; 2465 2466 if (!record_extent_backrefs(path, new)) { 2467 btrfs_free_path(path); 2468 goto out; 2469 } 2470 btrfs_release_path(path); 2471 2472 while (1) { 2473 node = rb_first(&new->root); 2474 if (!node) 2475 break; 2476 rb_erase(node, &new->root); 2477 2478 backref = rb_entry(node, struct sa_defrag_extent_backref, node); 2479 2480 ret = relink_extent_backref(path, prev, backref); 2481 WARN_ON(ret < 0); 2482 2483 kfree(prev); 2484 2485 if (ret == 1) 2486 prev = backref; 2487 else 2488 prev = NULL; 2489 cond_resched(); 2490 } 2491 kfree(prev); 2492 2493 btrfs_free_path(path); 2494 out: 2495 free_sa_defrag_extent(new); 2496 2497 atomic_dec(&root->fs_info->defrag_running); 2498 wake_up(&root->fs_info->transaction_wait); 2499 } 2500 2501 static struct new_sa_defrag_extent * 2502 record_old_file_extents(struct inode *inode, 2503 struct btrfs_ordered_extent *ordered) 2504 { 2505 struct btrfs_root *root = BTRFS_I(inode)->root; 2506 struct btrfs_path *path; 2507 struct btrfs_key key; 2508 struct old_sa_defrag_extent *old; 2509 struct new_sa_defrag_extent *new; 2510 int ret; 2511 2512 new = kmalloc(sizeof(*new), GFP_NOFS); 2513 if (!new) 2514 return NULL; 2515 2516 new->inode = inode; 2517 new->file_pos = ordered->file_offset; 2518 new->len = ordered->len; 2519 new->bytenr = ordered->start; 2520 new->disk_len = ordered->disk_len; 2521 new->compress_type = ordered->compress_type; 2522 new->root = RB_ROOT; 2523 INIT_LIST_HEAD(&new->head); 2524 2525 path = btrfs_alloc_path(); 2526 if (!path) 2527 goto out_kfree; 2528 2529 key.objectid = btrfs_ino(inode); 2530 key.type = BTRFS_EXTENT_DATA_KEY; 2531 key.offset = new->file_pos; 2532 2533 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 2534 if (ret < 0) 2535 goto out_free_path; 2536 if (ret > 0 && path->slots[0] > 0) 2537 path->slots[0]--; 2538 2539 /* find out all the old extents for the file range */ 2540 while (1) { 2541 struct btrfs_file_extent_item *extent; 2542 struct extent_buffer *l; 2543 int slot; 2544 u64 num_bytes; 2545 u64 offset; 2546 u64 end; 2547 u64 disk_bytenr; 2548 u64 extent_offset; 2549 2550 l = path->nodes[0]; 2551 slot = path->slots[0]; 2552 2553 if (slot >= btrfs_header_nritems(l)) { 2554 ret = btrfs_next_leaf(root, path); 2555 if (ret < 0) 2556 goto out_free_path; 2557 else if (ret > 0) 2558 break; 2559 continue; 2560 } 2561 2562 btrfs_item_key_to_cpu(l, &key, slot); 2563 2564 if (key.objectid != btrfs_ino(inode)) 2565 break; 2566 if (key.type != BTRFS_EXTENT_DATA_KEY) 2567 break; 2568 if (key.offset >= new->file_pos + new->len) 2569 break; 2570 2571 extent = btrfs_item_ptr(l, slot, struct btrfs_file_extent_item); 2572 2573 num_bytes = btrfs_file_extent_num_bytes(l, extent); 2574 if (key.offset + num_bytes < new->file_pos) 2575 goto next; 2576 2577 disk_bytenr = btrfs_file_extent_disk_bytenr(l, extent); 2578 if (!disk_bytenr) 2579 goto next; 2580 2581 extent_offset = btrfs_file_extent_offset(l, extent); 2582 2583 old = kmalloc(sizeof(*old), GFP_NOFS); 2584 if (!old) 2585 goto out_free_path; 2586 2587 offset = max(new->file_pos, key.offset); 2588 end = min(new->file_pos + new->len, key.offset + num_bytes); 2589 2590 old->bytenr = disk_bytenr; 2591 old->extent_offset = extent_offset; 2592 old->offset = offset - key.offset; 2593 old->len = end - offset; 2594 old->new = new; 2595 old->count = 0; 2596 list_add_tail(&old->list, &new->head); 2597 next: 2598 path->slots[0]++; 2599 cond_resched(); 2600 } 2601 2602 btrfs_free_path(path); 2603 atomic_inc(&root->fs_info->defrag_running); 2604 2605 return new; 2606 2607 out_free_path: 2608 btrfs_free_path(path); 2609 out_kfree: 2610 free_sa_defrag_extent(new); 2611 return NULL; 2612 } 2613 2614 static void btrfs_release_delalloc_bytes(struct btrfs_root *root, 2615 u64 start, u64 len) 2616 { 2617 struct btrfs_block_group_cache *cache; 2618 2619 cache = btrfs_lookup_block_group(root->fs_info, start); 2620 ASSERT(cache); 2621 2622 spin_lock(&cache->lock); 2623 cache->delalloc_bytes -= len; 2624 spin_unlock(&cache->lock); 2625 2626 btrfs_put_block_group(cache); 2627 } 2628 2629 /* as ordered data IO finishes, this gets called so we can finish 2630 * an ordered extent if the range of bytes in the file it covers are 2631 * fully written. 2632 */ 2633 static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) 2634 { 2635 struct inode *inode = ordered_extent->inode; 2636 struct btrfs_root *root = BTRFS_I(inode)->root; 2637 struct btrfs_trans_handle *trans = NULL; 2638 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 2639 struct extent_state *cached_state = NULL; 2640 struct new_sa_defrag_extent *new = NULL; 2641 int compress_type = 0; 2642 int ret = 0; 2643 u64 logical_len = ordered_extent->len; 2644 bool nolock; 2645 bool truncated = false; 2646 2647 nolock = btrfs_is_free_space_inode(inode); 2648 2649 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) { 2650 ret = -EIO; 2651 goto out; 2652 } 2653 2654 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) { 2655 truncated = true; 2656 logical_len = ordered_extent->truncated_len; 2657 /* Truncated the entire extent, don't bother adding */ 2658 if (!logical_len) 2659 goto out; 2660 } 2661 2662 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { 2663 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */ 2664 btrfs_ordered_update_i_size(inode, 0, ordered_extent); 2665 if (nolock) 2666 trans = btrfs_join_transaction_nolock(root); 2667 else 2668 trans = btrfs_join_transaction(root); 2669 if (IS_ERR(trans)) { 2670 ret = PTR_ERR(trans); 2671 trans = NULL; 2672 goto out; 2673 } 2674 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 2675 ret = btrfs_update_inode_fallback(trans, root, inode); 2676 if (ret) /* -ENOMEM or corruption */ 2677 btrfs_abort_transaction(trans, root, ret); 2678 goto out; 2679 } 2680 2681 lock_extent_bits(io_tree, ordered_extent->file_offset, 2682 ordered_extent->file_offset + ordered_extent->len - 1, 2683 0, &cached_state); 2684 2685 ret = test_range_bit(io_tree, ordered_extent->file_offset, 2686 ordered_extent->file_offset + ordered_extent->len - 1, 2687 EXTENT_DEFRAG, 1, cached_state); 2688 if (ret) { 2689 u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item); 2690 if (0 && last_snapshot >= BTRFS_I(inode)->generation) 2691 /* the inode is shared */ 2692 new = record_old_file_extents(inode, ordered_extent); 2693 2694 clear_extent_bit(io_tree, ordered_extent->file_offset, 2695 ordered_extent->file_offset + ordered_extent->len - 1, 2696 EXTENT_DEFRAG, 0, 0, &cached_state, GFP_NOFS); 2697 } 2698 2699 if (nolock) 2700 trans = btrfs_join_transaction_nolock(root); 2701 else 2702 trans = btrfs_join_transaction(root); 2703 if (IS_ERR(trans)) { 2704 ret = PTR_ERR(trans); 2705 trans = NULL; 2706 goto out_unlock; 2707 } 2708 2709 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 2710 2711 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) 2712 compress_type = ordered_extent->compress_type; 2713 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { 2714 BUG_ON(compress_type); 2715 ret = btrfs_mark_extent_written(trans, inode, 2716 ordered_extent->file_offset, 2717 ordered_extent->file_offset + 2718 logical_len); 2719 } else { 2720 BUG_ON(root == root->fs_info->tree_root); 2721 ret = insert_reserved_file_extent(trans, inode, 2722 ordered_extent->file_offset, 2723 ordered_extent->start, 2724 ordered_extent->disk_len, 2725 logical_len, logical_len, 2726 compress_type, 0, 0, 2727 BTRFS_FILE_EXTENT_REG); 2728 if (!ret) 2729 btrfs_release_delalloc_bytes(root, 2730 ordered_extent->start, 2731 ordered_extent->disk_len); 2732 } 2733 unpin_extent_cache(&BTRFS_I(inode)->extent_tree, 2734 ordered_extent->file_offset, ordered_extent->len, 2735 trans->transid); 2736 if (ret < 0) { 2737 btrfs_abort_transaction(trans, root, ret); 2738 goto out_unlock; 2739 } 2740 2741 add_pending_csums(trans, inode, ordered_extent->file_offset, 2742 &ordered_extent->list); 2743 2744 btrfs_ordered_update_i_size(inode, 0, ordered_extent); 2745 ret = btrfs_update_inode_fallback(trans, root, inode); 2746 if (ret) { /* -ENOMEM or corruption */ 2747 btrfs_abort_transaction(trans, root, ret); 2748 goto out_unlock; 2749 } 2750 ret = 0; 2751 out_unlock: 2752 unlock_extent_cached(io_tree, ordered_extent->file_offset, 2753 ordered_extent->file_offset + 2754 ordered_extent->len - 1, &cached_state, GFP_NOFS); 2755 out: 2756 if (root != root->fs_info->tree_root) 2757 btrfs_delalloc_release_metadata(inode, ordered_extent->len); 2758 if (trans) 2759 btrfs_end_transaction(trans, root); 2760 2761 if (ret || truncated) { 2762 u64 start, end; 2763 2764 if (truncated) 2765 start = ordered_extent->file_offset + logical_len; 2766 else 2767 start = ordered_extent->file_offset; 2768 end = ordered_extent->file_offset + ordered_extent->len - 1; 2769 clear_extent_uptodate(io_tree, start, end, NULL, GFP_NOFS); 2770 2771 /* Drop the cache for the part of the extent we didn't write. */ 2772 btrfs_drop_extent_cache(inode, start, end, 0); 2773 2774 /* 2775 * If the ordered extent had an IOERR or something else went 2776 * wrong we need to return the space for this ordered extent 2777 * back to the allocator. We only free the extent in the 2778 * truncated case if we didn't write out the extent at all. 2779 */ 2780 if ((ret || !logical_len) && 2781 !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && 2782 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) 2783 btrfs_free_reserved_extent(root, ordered_extent->start, 2784 ordered_extent->disk_len, 1); 2785 } 2786 2787 2788 /* 2789 * This needs to be done to make sure anybody waiting knows we are done 2790 * updating everything for this ordered extent. 2791 */ 2792 btrfs_remove_ordered_extent(inode, ordered_extent); 2793 2794 /* for snapshot-aware defrag */ 2795 if (new) { 2796 if (ret) { 2797 free_sa_defrag_extent(new); 2798 atomic_dec(&root->fs_info->defrag_running); 2799 } else { 2800 relink_file_extents(new); 2801 } 2802 } 2803 2804 /* once for us */ 2805 btrfs_put_ordered_extent(ordered_extent); 2806 /* once for the tree */ 2807 btrfs_put_ordered_extent(ordered_extent); 2808 2809 return ret; 2810 } 2811 2812 static void finish_ordered_fn(struct btrfs_work *work) 2813 { 2814 struct btrfs_ordered_extent *ordered_extent; 2815 ordered_extent = container_of(work, struct btrfs_ordered_extent, work); 2816 btrfs_finish_ordered_io(ordered_extent); 2817 } 2818 2819 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end, 2820 struct extent_state *state, int uptodate) 2821 { 2822 struct inode *inode = page->mapping->host; 2823 struct btrfs_root *root = BTRFS_I(inode)->root; 2824 struct btrfs_ordered_extent *ordered_extent = NULL; 2825 struct btrfs_workqueue *workers; 2826 2827 trace_btrfs_writepage_end_io_hook(page, start, end, uptodate); 2828 2829 ClearPagePrivate2(page); 2830 if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start, 2831 end - start + 1, uptodate)) 2832 return 0; 2833 2834 btrfs_init_work(&ordered_extent->work, finish_ordered_fn, NULL, NULL); 2835 2836 if (btrfs_is_free_space_inode(inode)) 2837 workers = root->fs_info->endio_freespace_worker; 2838 else 2839 workers = root->fs_info->endio_write_workers; 2840 btrfs_queue_work(workers, &ordered_extent->work); 2841 2842 return 0; 2843 } 2844 2845 /* 2846 * when reads are done, we need to check csums to verify the data is correct 2847 * if there's a match, we allow the bio to finish. If not, the code in 2848 * extent_io.c will try to find good copies for us. 2849 */ 2850 static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio, 2851 u64 phy_offset, struct page *page, 2852 u64 start, u64 end, int mirror) 2853 { 2854 size_t offset = start - page_offset(page); 2855 struct inode *inode = page->mapping->host; 2856 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 2857 char *kaddr; 2858 struct btrfs_root *root = BTRFS_I(inode)->root; 2859 u32 csum_expected; 2860 u32 csum = ~(u32)0; 2861 static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL, 2862 DEFAULT_RATELIMIT_BURST); 2863 2864 if (PageChecked(page)) { 2865 ClearPageChecked(page); 2866 goto good; 2867 } 2868 2869 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) 2870 goto good; 2871 2872 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID && 2873 test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) { 2874 clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM, 2875 GFP_NOFS); 2876 return 0; 2877 } 2878 2879 phy_offset >>= inode->i_sb->s_blocksize_bits; 2880 csum_expected = *(((u32 *)io_bio->csum) + phy_offset); 2881 2882 kaddr = kmap_atomic(page); 2883 csum = btrfs_csum_data(kaddr + offset, csum, end - start + 1); 2884 btrfs_csum_final(csum, (char *)&csum); 2885 if (csum != csum_expected) 2886 goto zeroit; 2887 2888 kunmap_atomic(kaddr); 2889 good: 2890 return 0; 2891 2892 zeroit: 2893 if (__ratelimit(&_rs)) 2894 btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u", 2895 btrfs_ino(page->mapping->host), start, csum, csum_expected); 2896 memset(kaddr + offset, 1, end - start + 1); 2897 flush_dcache_page(page); 2898 kunmap_atomic(kaddr); 2899 if (csum_expected == 0) 2900 return 0; 2901 return -EIO; 2902 } 2903 2904 struct delayed_iput { 2905 struct list_head list; 2906 struct inode *inode; 2907 }; 2908 2909 /* JDM: If this is fs-wide, why can't we add a pointer to 2910 * btrfs_inode instead and avoid the allocation? */ 2911 void btrfs_add_delayed_iput(struct inode *inode) 2912 { 2913 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; 2914 struct delayed_iput *delayed; 2915 2916 if (atomic_add_unless(&inode->i_count, -1, 1)) 2917 return; 2918 2919 delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL); 2920 delayed->inode = inode; 2921 2922 spin_lock(&fs_info->delayed_iput_lock); 2923 list_add_tail(&delayed->list, &fs_info->delayed_iputs); 2924 spin_unlock(&fs_info->delayed_iput_lock); 2925 } 2926 2927 void btrfs_run_delayed_iputs(struct btrfs_root *root) 2928 { 2929 LIST_HEAD(list); 2930 struct btrfs_fs_info *fs_info = root->fs_info; 2931 struct delayed_iput *delayed; 2932 int empty; 2933 2934 spin_lock(&fs_info->delayed_iput_lock); 2935 empty = list_empty(&fs_info->delayed_iputs); 2936 spin_unlock(&fs_info->delayed_iput_lock); 2937 if (empty) 2938 return; 2939 2940 spin_lock(&fs_info->delayed_iput_lock); 2941 list_splice_init(&fs_info->delayed_iputs, &list); 2942 spin_unlock(&fs_info->delayed_iput_lock); 2943 2944 while (!list_empty(&list)) { 2945 delayed = list_entry(list.next, struct delayed_iput, list); 2946 list_del(&delayed->list); 2947 iput(delayed->inode); 2948 kfree(delayed); 2949 } 2950 } 2951 2952 /* 2953 * This is called in transaction commit time. If there are no orphan 2954 * files in the subvolume, it removes orphan item and frees block_rsv 2955 * structure. 2956 */ 2957 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans, 2958 struct btrfs_root *root) 2959 { 2960 struct btrfs_block_rsv *block_rsv; 2961 int ret; 2962 2963 if (atomic_read(&root->orphan_inodes) || 2964 root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE) 2965 return; 2966 2967 spin_lock(&root->orphan_lock); 2968 if (atomic_read(&root->orphan_inodes)) { 2969 spin_unlock(&root->orphan_lock); 2970 return; 2971 } 2972 2973 if (root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE) { 2974 spin_unlock(&root->orphan_lock); 2975 return; 2976 } 2977 2978 block_rsv = root->orphan_block_rsv; 2979 root->orphan_block_rsv = NULL; 2980 spin_unlock(&root->orphan_lock); 2981 2982 if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state) && 2983 btrfs_root_refs(&root->root_item) > 0) { 2984 ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root, 2985 root->root_key.objectid); 2986 if (ret) 2987 btrfs_abort_transaction(trans, root, ret); 2988 else 2989 clear_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, 2990 &root->state); 2991 } 2992 2993 if (block_rsv) { 2994 WARN_ON(block_rsv->size > 0); 2995 btrfs_free_block_rsv(root, block_rsv); 2996 } 2997 } 2998 2999 /* 3000 * This creates an orphan entry for the given inode in case something goes 3001 * wrong in the middle of an unlink/truncate. 3002 * 3003 * NOTE: caller of this function should reserve 5 units of metadata for 3004 * this function. 3005 */ 3006 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode) 3007 { 3008 struct btrfs_root *root = BTRFS_I(inode)->root; 3009 struct btrfs_block_rsv *block_rsv = NULL; 3010 int reserve = 0; 3011 int insert = 0; 3012 int ret; 3013 3014 if (!root->orphan_block_rsv) { 3015 block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP); 3016 if (!block_rsv) 3017 return -ENOMEM; 3018 } 3019 3020 spin_lock(&root->orphan_lock); 3021 if (!root->orphan_block_rsv) { 3022 root->orphan_block_rsv = block_rsv; 3023 } else if (block_rsv) { 3024 btrfs_free_block_rsv(root, block_rsv); 3025 block_rsv = NULL; 3026 } 3027 3028 if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3029 &BTRFS_I(inode)->runtime_flags)) { 3030 #if 0 3031 /* 3032 * For proper ENOSPC handling, we should do orphan 3033 * cleanup when mounting. But this introduces backward 3034 * compatibility issue. 3035 */ 3036 if (!xchg(&root->orphan_item_inserted, 1)) 3037 insert = 2; 3038 else 3039 insert = 1; 3040 #endif 3041 insert = 1; 3042 atomic_inc(&root->orphan_inodes); 3043 } 3044 3045 if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3046 &BTRFS_I(inode)->runtime_flags)) 3047 reserve = 1; 3048 spin_unlock(&root->orphan_lock); 3049 3050 /* grab metadata reservation from transaction handle */ 3051 if (reserve) { 3052 ret = btrfs_orphan_reserve_metadata(trans, inode); 3053 BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */ 3054 } 3055 3056 /* insert an orphan item to track this unlinked/truncated file */ 3057 if (insert >= 1) { 3058 ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode)); 3059 if (ret) { 3060 atomic_dec(&root->orphan_inodes); 3061 if (reserve) { 3062 clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3063 &BTRFS_I(inode)->runtime_flags); 3064 btrfs_orphan_release_metadata(inode); 3065 } 3066 if (ret != -EEXIST) { 3067 clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3068 &BTRFS_I(inode)->runtime_flags); 3069 btrfs_abort_transaction(trans, root, ret); 3070 return ret; 3071 } 3072 } 3073 ret = 0; 3074 } 3075 3076 /* insert an orphan item to track subvolume contains orphan files */ 3077 if (insert >= 2) { 3078 ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root, 3079 root->root_key.objectid); 3080 if (ret && ret != -EEXIST) { 3081 btrfs_abort_transaction(trans, root, ret); 3082 return ret; 3083 } 3084 } 3085 return 0; 3086 } 3087 3088 /* 3089 * We have done the truncate/delete so we can go ahead and remove the orphan 3090 * item for this particular inode. 3091 */ 3092 static int btrfs_orphan_del(struct btrfs_trans_handle *trans, 3093 struct inode *inode) 3094 { 3095 struct btrfs_root *root = BTRFS_I(inode)->root; 3096 int delete_item = 0; 3097 int release_rsv = 0; 3098 int ret = 0; 3099 3100 spin_lock(&root->orphan_lock); 3101 if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3102 &BTRFS_I(inode)->runtime_flags)) 3103 delete_item = 1; 3104 3105 if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3106 &BTRFS_I(inode)->runtime_flags)) 3107 release_rsv = 1; 3108 spin_unlock(&root->orphan_lock); 3109 3110 if (delete_item) { 3111 atomic_dec(&root->orphan_inodes); 3112 if (trans) 3113 ret = btrfs_del_orphan_item(trans, root, 3114 btrfs_ino(inode)); 3115 } 3116 3117 if (release_rsv) 3118 btrfs_orphan_release_metadata(inode); 3119 3120 return ret; 3121 } 3122 3123 /* 3124 * this cleans up any orphans that may be left on the list from the last use 3125 * of this root. 3126 */ 3127 int btrfs_orphan_cleanup(struct btrfs_root *root) 3128 { 3129 struct btrfs_path *path; 3130 struct extent_buffer *leaf; 3131 struct btrfs_key key, found_key; 3132 struct btrfs_trans_handle *trans; 3133 struct inode *inode; 3134 u64 last_objectid = 0; 3135 int ret = 0, nr_unlink = 0, nr_truncate = 0; 3136 3137 if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED)) 3138 return 0; 3139 3140 path = btrfs_alloc_path(); 3141 if (!path) { 3142 ret = -ENOMEM; 3143 goto out; 3144 } 3145 path->reada = -1; 3146 3147 key.objectid = BTRFS_ORPHAN_OBJECTID; 3148 btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY); 3149 key.offset = (u64)-1; 3150 3151 while (1) { 3152 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 3153 if (ret < 0) 3154 goto out; 3155 3156 /* 3157 * if ret == 0 means we found what we were searching for, which 3158 * is weird, but possible, so only screw with path if we didn't 3159 * find the key and see if we have stuff that matches 3160 */ 3161 if (ret > 0) { 3162 ret = 0; 3163 if (path->slots[0] == 0) 3164 break; 3165 path->slots[0]--; 3166 } 3167 3168 /* pull out the item */ 3169 leaf = path->nodes[0]; 3170 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 3171 3172 /* make sure the item matches what we want */ 3173 if (found_key.objectid != BTRFS_ORPHAN_OBJECTID) 3174 break; 3175 if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY) 3176 break; 3177 3178 /* release the path since we're done with it */ 3179 btrfs_release_path(path); 3180 3181 /* 3182 * this is where we are basically btrfs_lookup, without the 3183 * crossing root thing. we store the inode number in the 3184 * offset of the orphan item. 3185 */ 3186 3187 if (found_key.offset == last_objectid) { 3188 btrfs_err(root->fs_info, 3189 "Error removing orphan entry, stopping orphan cleanup"); 3190 ret = -EINVAL; 3191 goto out; 3192 } 3193 3194 last_objectid = found_key.offset; 3195 3196 found_key.objectid = found_key.offset; 3197 found_key.type = BTRFS_INODE_ITEM_KEY; 3198 found_key.offset = 0; 3199 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL); 3200 ret = PTR_ERR_OR_ZERO(inode); 3201 if (ret && ret != -ESTALE) 3202 goto out; 3203 3204 if (ret == -ESTALE && root == root->fs_info->tree_root) { 3205 struct btrfs_root *dead_root; 3206 struct btrfs_fs_info *fs_info = root->fs_info; 3207 int is_dead_root = 0; 3208 3209 /* 3210 * this is an orphan in the tree root. Currently these 3211 * could come from 2 sources: 3212 * a) a snapshot deletion in progress 3213 * b) a free space cache inode 3214 * We need to distinguish those two, as the snapshot 3215 * orphan must not get deleted. 3216 * find_dead_roots already ran before us, so if this 3217 * is a snapshot deletion, we should find the root 3218 * in the dead_roots list 3219 */ 3220 spin_lock(&fs_info->trans_lock); 3221 list_for_each_entry(dead_root, &fs_info->dead_roots, 3222 root_list) { 3223 if (dead_root->root_key.objectid == 3224 found_key.objectid) { 3225 is_dead_root = 1; 3226 break; 3227 } 3228 } 3229 spin_unlock(&fs_info->trans_lock); 3230 if (is_dead_root) { 3231 /* prevent this orphan from being found again */ 3232 key.offset = found_key.objectid - 1; 3233 continue; 3234 } 3235 } 3236 /* 3237 * Inode is already gone but the orphan item is still there, 3238 * kill the orphan item. 3239 */ 3240 if (ret == -ESTALE) { 3241 trans = btrfs_start_transaction(root, 1); 3242 if (IS_ERR(trans)) { 3243 ret = PTR_ERR(trans); 3244 goto out; 3245 } 3246 btrfs_debug(root->fs_info, "auto deleting %Lu", 3247 found_key.objectid); 3248 ret = btrfs_del_orphan_item(trans, root, 3249 found_key.objectid); 3250 btrfs_end_transaction(trans, root); 3251 if (ret) 3252 goto out; 3253 continue; 3254 } 3255 3256 /* 3257 * add this inode to the orphan list so btrfs_orphan_del does 3258 * the proper thing when we hit it 3259 */ 3260 set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3261 &BTRFS_I(inode)->runtime_flags); 3262 atomic_inc(&root->orphan_inodes); 3263 3264 /* if we have links, this was a truncate, lets do that */ 3265 if (inode->i_nlink) { 3266 if (WARN_ON(!S_ISREG(inode->i_mode))) { 3267 iput(inode); 3268 continue; 3269 } 3270 nr_truncate++; 3271 3272 /* 1 for the orphan item deletion. */ 3273 trans = btrfs_start_transaction(root, 1); 3274 if (IS_ERR(trans)) { 3275 iput(inode); 3276 ret = PTR_ERR(trans); 3277 goto out; 3278 } 3279 ret = btrfs_orphan_add(trans, inode); 3280 btrfs_end_transaction(trans, root); 3281 if (ret) { 3282 iput(inode); 3283 goto out; 3284 } 3285 3286 ret = btrfs_truncate(inode); 3287 if (ret) 3288 btrfs_orphan_del(NULL, inode); 3289 } else { 3290 nr_unlink++; 3291 } 3292 3293 /* this will do delete_inode and everything for us */ 3294 iput(inode); 3295 if (ret) 3296 goto out; 3297 } 3298 /* release the path since we're done with it */ 3299 btrfs_release_path(path); 3300 3301 root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE; 3302 3303 if (root->orphan_block_rsv) 3304 btrfs_block_rsv_release(root, root->orphan_block_rsv, 3305 (u64)-1); 3306 3307 if (root->orphan_block_rsv || 3308 test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) { 3309 trans = btrfs_join_transaction(root); 3310 if (!IS_ERR(trans)) 3311 btrfs_end_transaction(trans, root); 3312 } 3313 3314 if (nr_unlink) 3315 btrfs_debug(root->fs_info, "unlinked %d orphans", nr_unlink); 3316 if (nr_truncate) 3317 btrfs_debug(root->fs_info, "truncated %d orphans", nr_truncate); 3318 3319 out: 3320 if (ret) 3321 btrfs_crit(root->fs_info, 3322 "could not do orphan cleanup %d", ret); 3323 btrfs_free_path(path); 3324 return ret; 3325 } 3326 3327 /* 3328 * very simple check to peek ahead in the leaf looking for xattrs. If we 3329 * don't find any xattrs, we know there can't be any acls. 3330 * 3331 * slot is the slot the inode is in, objectid is the objectid of the inode 3332 */ 3333 static noinline int acls_after_inode_item(struct extent_buffer *leaf, 3334 int slot, u64 objectid, 3335 int *first_xattr_slot) 3336 { 3337 u32 nritems = btrfs_header_nritems(leaf); 3338 struct btrfs_key found_key; 3339 static u64 xattr_access = 0; 3340 static u64 xattr_default = 0; 3341 int scanned = 0; 3342 3343 if (!xattr_access) { 3344 xattr_access = btrfs_name_hash(POSIX_ACL_XATTR_ACCESS, 3345 strlen(POSIX_ACL_XATTR_ACCESS)); 3346 xattr_default = btrfs_name_hash(POSIX_ACL_XATTR_DEFAULT, 3347 strlen(POSIX_ACL_XATTR_DEFAULT)); 3348 } 3349 3350 slot++; 3351 *first_xattr_slot = -1; 3352 while (slot < nritems) { 3353 btrfs_item_key_to_cpu(leaf, &found_key, slot); 3354 3355 /* we found a different objectid, there must not be acls */ 3356 if (found_key.objectid != objectid) 3357 return 0; 3358 3359 /* we found an xattr, assume we've got an acl */ 3360 if (found_key.type == BTRFS_XATTR_ITEM_KEY) { 3361 if (*first_xattr_slot == -1) 3362 *first_xattr_slot = slot; 3363 if (found_key.offset == xattr_access || 3364 found_key.offset == xattr_default) 3365 return 1; 3366 } 3367 3368 /* 3369 * we found a key greater than an xattr key, there can't 3370 * be any acls later on 3371 */ 3372 if (found_key.type > BTRFS_XATTR_ITEM_KEY) 3373 return 0; 3374 3375 slot++; 3376 scanned++; 3377 3378 /* 3379 * it goes inode, inode backrefs, xattrs, extents, 3380 * so if there are a ton of hard links to an inode there can 3381 * be a lot of backrefs. Don't waste time searching too hard, 3382 * this is just an optimization 3383 */ 3384 if (scanned >= 8) 3385 break; 3386 } 3387 /* we hit the end of the leaf before we found an xattr or 3388 * something larger than an xattr. We have to assume the inode 3389 * has acls 3390 */ 3391 if (*first_xattr_slot == -1) 3392 *first_xattr_slot = slot; 3393 return 1; 3394 } 3395 3396 /* 3397 * read an inode from the btree into the in-memory inode 3398 */ 3399 static void btrfs_read_locked_inode(struct inode *inode) 3400 { 3401 struct btrfs_path *path; 3402 struct extent_buffer *leaf; 3403 struct btrfs_inode_item *inode_item; 3404 struct btrfs_timespec *tspec; 3405 struct btrfs_root *root = BTRFS_I(inode)->root; 3406 struct btrfs_key location; 3407 unsigned long ptr; 3408 int maybe_acls; 3409 u32 rdev; 3410 int ret; 3411 bool filled = false; 3412 int first_xattr_slot; 3413 3414 ret = btrfs_fill_inode(inode, &rdev); 3415 if (!ret) 3416 filled = true; 3417 3418 path = btrfs_alloc_path(); 3419 if (!path) 3420 goto make_bad; 3421 3422 memcpy(&location, &BTRFS_I(inode)->location, sizeof(location)); 3423 3424 ret = btrfs_lookup_inode(NULL, root, path, &location, 0); 3425 if (ret) 3426 goto make_bad; 3427 3428 leaf = path->nodes[0]; 3429 3430 if (filled) 3431 goto cache_index; 3432 3433 inode_item = btrfs_item_ptr(leaf, path->slots[0], 3434 struct btrfs_inode_item); 3435 inode->i_mode = btrfs_inode_mode(leaf, inode_item); 3436 set_nlink(inode, btrfs_inode_nlink(leaf, inode_item)); 3437 i_uid_write(inode, btrfs_inode_uid(leaf, inode_item)); 3438 i_gid_write(inode, btrfs_inode_gid(leaf, inode_item)); 3439 btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item)); 3440 3441 tspec = btrfs_inode_atime(inode_item); 3442 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec); 3443 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec); 3444 3445 tspec = btrfs_inode_mtime(inode_item); 3446 inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec); 3447 inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec); 3448 3449 tspec = btrfs_inode_ctime(inode_item); 3450 inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec); 3451 inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec); 3452 3453 inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item)); 3454 BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item); 3455 BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item); 3456 3457 /* 3458 * If we were modified in the current generation and evicted from memory 3459 * and then re-read we need to do a full sync since we don't have any 3460 * idea about which extents were modified before we were evicted from 3461 * cache. 3462 */ 3463 if (BTRFS_I(inode)->last_trans == root->fs_info->generation) 3464 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3465 &BTRFS_I(inode)->runtime_flags); 3466 3467 inode->i_version = btrfs_inode_sequence(leaf, inode_item); 3468 inode->i_generation = BTRFS_I(inode)->generation; 3469 inode->i_rdev = 0; 3470 rdev = btrfs_inode_rdev(leaf, inode_item); 3471 3472 BTRFS_I(inode)->index_cnt = (u64)-1; 3473 BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item); 3474 3475 cache_index: 3476 path->slots[0]++; 3477 if (inode->i_nlink != 1 || 3478 path->slots[0] >= btrfs_header_nritems(leaf)) 3479 goto cache_acl; 3480 3481 btrfs_item_key_to_cpu(leaf, &location, path->slots[0]); 3482 if (location.objectid != btrfs_ino(inode)) 3483 goto cache_acl; 3484 3485 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); 3486 if (location.type == BTRFS_INODE_REF_KEY) { 3487 struct btrfs_inode_ref *ref; 3488 3489 ref = (struct btrfs_inode_ref *)ptr; 3490 BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref); 3491 } else if (location.type == BTRFS_INODE_EXTREF_KEY) { 3492 struct btrfs_inode_extref *extref; 3493 3494 extref = (struct btrfs_inode_extref *)ptr; 3495 BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf, 3496 extref); 3497 } 3498 cache_acl: 3499 /* 3500 * try to precache a NULL acl entry for files that don't have 3501 * any xattrs or acls 3502 */ 3503 maybe_acls = acls_after_inode_item(leaf, path->slots[0], 3504 btrfs_ino(inode), &first_xattr_slot); 3505 if (first_xattr_slot != -1) { 3506 path->slots[0] = first_xattr_slot; 3507 ret = btrfs_load_inode_props(inode, path); 3508 if (ret) 3509 btrfs_err(root->fs_info, 3510 "error loading props for ino %llu (root %llu): %d", 3511 btrfs_ino(inode), 3512 root->root_key.objectid, ret); 3513 } 3514 btrfs_free_path(path); 3515 3516 if (!maybe_acls) 3517 cache_no_acl(inode); 3518 3519 switch (inode->i_mode & S_IFMT) { 3520 case S_IFREG: 3521 inode->i_mapping->a_ops = &btrfs_aops; 3522 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 3523 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops; 3524 inode->i_fop = &btrfs_file_operations; 3525 inode->i_op = &btrfs_file_inode_operations; 3526 break; 3527 case S_IFDIR: 3528 inode->i_fop = &btrfs_dir_file_operations; 3529 if (root == root->fs_info->tree_root) 3530 inode->i_op = &btrfs_dir_ro_inode_operations; 3531 else 3532 inode->i_op = &btrfs_dir_inode_operations; 3533 break; 3534 case S_IFLNK: 3535 inode->i_op = &btrfs_symlink_inode_operations; 3536 inode->i_mapping->a_ops = &btrfs_symlink_aops; 3537 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 3538 break; 3539 default: 3540 inode->i_op = &btrfs_special_inode_operations; 3541 init_special_inode(inode, inode->i_mode, rdev); 3542 break; 3543 } 3544 3545 btrfs_update_iflags(inode); 3546 return; 3547 3548 make_bad: 3549 btrfs_free_path(path); 3550 make_bad_inode(inode); 3551 } 3552 3553 /* 3554 * given a leaf and an inode, copy the inode fields into the leaf 3555 */ 3556 static void fill_inode_item(struct btrfs_trans_handle *trans, 3557 struct extent_buffer *leaf, 3558 struct btrfs_inode_item *item, 3559 struct inode *inode) 3560 { 3561 struct btrfs_map_token token; 3562 3563 btrfs_init_map_token(&token); 3564 3565 btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token); 3566 btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token); 3567 btrfs_set_token_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size, 3568 &token); 3569 btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token); 3570 btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token); 3571 3572 btrfs_set_token_timespec_sec(leaf, btrfs_inode_atime(item), 3573 inode->i_atime.tv_sec, &token); 3574 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_atime(item), 3575 inode->i_atime.tv_nsec, &token); 3576 3577 btrfs_set_token_timespec_sec(leaf, btrfs_inode_mtime(item), 3578 inode->i_mtime.tv_sec, &token); 3579 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_mtime(item), 3580 inode->i_mtime.tv_nsec, &token); 3581 3582 btrfs_set_token_timespec_sec(leaf, btrfs_inode_ctime(item), 3583 inode->i_ctime.tv_sec, &token); 3584 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_ctime(item), 3585 inode->i_ctime.tv_nsec, &token); 3586 3587 btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode), 3588 &token); 3589 btrfs_set_token_inode_generation(leaf, item, BTRFS_I(inode)->generation, 3590 &token); 3591 btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token); 3592 btrfs_set_token_inode_transid(leaf, item, trans->transid, &token); 3593 btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token); 3594 btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token); 3595 btrfs_set_token_inode_block_group(leaf, item, 0, &token); 3596 } 3597 3598 /* 3599 * copy everything in the in-memory inode into the btree. 3600 */ 3601 static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans, 3602 struct btrfs_root *root, struct inode *inode) 3603 { 3604 struct btrfs_inode_item *inode_item; 3605 struct btrfs_path *path; 3606 struct extent_buffer *leaf; 3607 int ret; 3608 3609 path = btrfs_alloc_path(); 3610 if (!path) 3611 return -ENOMEM; 3612 3613 path->leave_spinning = 1; 3614 ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location, 3615 1); 3616 if (ret) { 3617 if (ret > 0) 3618 ret = -ENOENT; 3619 goto failed; 3620 } 3621 3622 leaf = path->nodes[0]; 3623 inode_item = btrfs_item_ptr(leaf, path->slots[0], 3624 struct btrfs_inode_item); 3625 3626 fill_inode_item(trans, leaf, inode_item, inode); 3627 btrfs_mark_buffer_dirty(leaf); 3628 btrfs_set_inode_last_trans(trans, inode); 3629 ret = 0; 3630 failed: 3631 btrfs_free_path(path); 3632 return ret; 3633 } 3634 3635 /* 3636 * copy everything in the in-memory inode into the btree. 3637 */ 3638 noinline int btrfs_update_inode(struct btrfs_trans_handle *trans, 3639 struct btrfs_root *root, struct inode *inode) 3640 { 3641 int ret; 3642 3643 /* 3644 * If the inode is a free space inode, we can deadlock during commit 3645 * if we put it into the delayed code. 3646 * 3647 * The data relocation inode should also be directly updated 3648 * without delay 3649 */ 3650 if (!btrfs_is_free_space_inode(inode) 3651 && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) { 3652 btrfs_update_root_times(trans, root); 3653 3654 ret = btrfs_delayed_update_inode(trans, root, inode); 3655 if (!ret) 3656 btrfs_set_inode_last_trans(trans, inode); 3657 return ret; 3658 } 3659 3660 return btrfs_update_inode_item(trans, root, inode); 3661 } 3662 3663 noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans, 3664 struct btrfs_root *root, 3665 struct inode *inode) 3666 { 3667 int ret; 3668 3669 ret = btrfs_update_inode(trans, root, inode); 3670 if (ret == -ENOSPC) 3671 return btrfs_update_inode_item(trans, root, inode); 3672 return ret; 3673 } 3674 3675 /* 3676 * unlink helper that gets used here in inode.c and in the tree logging 3677 * recovery code. It remove a link in a directory with a given name, and 3678 * also drops the back refs in the inode to the directory 3679 */ 3680 static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans, 3681 struct btrfs_root *root, 3682 struct inode *dir, struct inode *inode, 3683 const char *name, int name_len) 3684 { 3685 struct btrfs_path *path; 3686 int ret = 0; 3687 struct extent_buffer *leaf; 3688 struct btrfs_dir_item *di; 3689 struct btrfs_key key; 3690 u64 index; 3691 u64 ino = btrfs_ino(inode); 3692 u64 dir_ino = btrfs_ino(dir); 3693 3694 path = btrfs_alloc_path(); 3695 if (!path) { 3696 ret = -ENOMEM; 3697 goto out; 3698 } 3699 3700 path->leave_spinning = 1; 3701 di = btrfs_lookup_dir_item(trans, root, path, dir_ino, 3702 name, name_len, -1); 3703 if (IS_ERR(di)) { 3704 ret = PTR_ERR(di); 3705 goto err; 3706 } 3707 if (!di) { 3708 ret = -ENOENT; 3709 goto err; 3710 } 3711 leaf = path->nodes[0]; 3712 btrfs_dir_item_key_to_cpu(leaf, di, &key); 3713 ret = btrfs_delete_one_dir_name(trans, root, path, di); 3714 if (ret) 3715 goto err; 3716 btrfs_release_path(path); 3717 3718 /* 3719 * If we don't have dir index, we have to get it by looking up 3720 * the inode ref, since we get the inode ref, remove it directly, 3721 * it is unnecessary to do delayed deletion. 3722 * 3723 * But if we have dir index, needn't search inode ref to get it. 3724 * Since the inode ref is close to the inode item, it is better 3725 * that we delay to delete it, and just do this deletion when 3726 * we update the inode item. 3727 */ 3728 if (BTRFS_I(inode)->dir_index) { 3729 ret = btrfs_delayed_delete_inode_ref(inode); 3730 if (!ret) { 3731 index = BTRFS_I(inode)->dir_index; 3732 goto skip_backref; 3733 } 3734 } 3735 3736 ret = btrfs_del_inode_ref(trans, root, name, name_len, ino, 3737 dir_ino, &index); 3738 if (ret) { 3739 btrfs_info(root->fs_info, 3740 "failed to delete reference to %.*s, inode %llu parent %llu", 3741 name_len, name, ino, dir_ino); 3742 btrfs_abort_transaction(trans, root, ret); 3743 goto err; 3744 } 3745 skip_backref: 3746 ret = btrfs_delete_delayed_dir_index(trans, root, dir, index); 3747 if (ret) { 3748 btrfs_abort_transaction(trans, root, ret); 3749 goto err; 3750 } 3751 3752 ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len, 3753 inode, dir_ino); 3754 if (ret != 0 && ret != -ENOENT) { 3755 btrfs_abort_transaction(trans, root, ret); 3756 goto err; 3757 } 3758 3759 ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len, 3760 dir, index); 3761 if (ret == -ENOENT) 3762 ret = 0; 3763 else if (ret) 3764 btrfs_abort_transaction(trans, root, ret); 3765 err: 3766 btrfs_free_path(path); 3767 if (ret) 3768 goto out; 3769 3770 btrfs_i_size_write(dir, dir->i_size - name_len * 2); 3771 inode_inc_iversion(inode); 3772 inode_inc_iversion(dir); 3773 inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME; 3774 ret = btrfs_update_inode(trans, root, dir); 3775 out: 3776 return ret; 3777 } 3778 3779 int btrfs_unlink_inode(struct btrfs_trans_handle *trans, 3780 struct btrfs_root *root, 3781 struct inode *dir, struct inode *inode, 3782 const char *name, int name_len) 3783 { 3784 int ret; 3785 ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len); 3786 if (!ret) { 3787 drop_nlink(inode); 3788 ret = btrfs_update_inode(trans, root, inode); 3789 } 3790 return ret; 3791 } 3792 3793 /* 3794 * helper to start transaction for unlink and rmdir. 3795 * 3796 * unlink and rmdir are special in btrfs, they do not always free space, so 3797 * if we cannot make our reservations the normal way try and see if there is 3798 * plenty of slack room in the global reserve to migrate, otherwise we cannot 3799 * allow the unlink to occur. 3800 */ 3801 static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir) 3802 { 3803 struct btrfs_trans_handle *trans; 3804 struct btrfs_root *root = BTRFS_I(dir)->root; 3805 int ret; 3806 3807 /* 3808 * 1 for the possible orphan item 3809 * 1 for the dir item 3810 * 1 for the dir index 3811 * 1 for the inode ref 3812 * 1 for the inode 3813 */ 3814 trans = btrfs_start_transaction(root, 5); 3815 if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC) 3816 return trans; 3817 3818 if (PTR_ERR(trans) == -ENOSPC) { 3819 u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5); 3820 3821 trans = btrfs_start_transaction(root, 0); 3822 if (IS_ERR(trans)) 3823 return trans; 3824 ret = btrfs_cond_migrate_bytes(root->fs_info, 3825 &root->fs_info->trans_block_rsv, 3826 num_bytes, 5); 3827 if (ret) { 3828 btrfs_end_transaction(trans, root); 3829 return ERR_PTR(ret); 3830 } 3831 trans->block_rsv = &root->fs_info->trans_block_rsv; 3832 trans->bytes_reserved = num_bytes; 3833 } 3834 return trans; 3835 } 3836 3837 static int btrfs_unlink(struct inode *dir, struct dentry *dentry) 3838 { 3839 struct btrfs_root *root = BTRFS_I(dir)->root; 3840 struct btrfs_trans_handle *trans; 3841 struct inode *inode = dentry->d_inode; 3842 int ret; 3843 3844 trans = __unlink_start_trans(dir); 3845 if (IS_ERR(trans)) 3846 return PTR_ERR(trans); 3847 3848 btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0); 3849 3850 ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode, 3851 dentry->d_name.name, dentry->d_name.len); 3852 if (ret) 3853 goto out; 3854 3855 if (inode->i_nlink == 0) { 3856 ret = btrfs_orphan_add(trans, inode); 3857 if (ret) 3858 goto out; 3859 } 3860 3861 out: 3862 btrfs_end_transaction(trans, root); 3863 btrfs_btree_balance_dirty(root); 3864 return ret; 3865 } 3866 3867 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans, 3868 struct btrfs_root *root, 3869 struct inode *dir, u64 objectid, 3870 const char *name, int name_len) 3871 { 3872 struct btrfs_path *path; 3873 struct extent_buffer *leaf; 3874 struct btrfs_dir_item *di; 3875 struct btrfs_key key; 3876 u64 index; 3877 int ret; 3878 u64 dir_ino = btrfs_ino(dir); 3879 3880 path = btrfs_alloc_path(); 3881 if (!path) 3882 return -ENOMEM; 3883 3884 di = btrfs_lookup_dir_item(trans, root, path, dir_ino, 3885 name, name_len, -1); 3886 if (IS_ERR_OR_NULL(di)) { 3887 if (!di) 3888 ret = -ENOENT; 3889 else 3890 ret = PTR_ERR(di); 3891 goto out; 3892 } 3893 3894 leaf = path->nodes[0]; 3895 btrfs_dir_item_key_to_cpu(leaf, di, &key); 3896 WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid); 3897 ret = btrfs_delete_one_dir_name(trans, root, path, di); 3898 if (ret) { 3899 btrfs_abort_transaction(trans, root, ret); 3900 goto out; 3901 } 3902 btrfs_release_path(path); 3903 3904 ret = btrfs_del_root_ref(trans, root->fs_info->tree_root, 3905 objectid, root->root_key.objectid, 3906 dir_ino, &index, name, name_len); 3907 if (ret < 0) { 3908 if (ret != -ENOENT) { 3909 btrfs_abort_transaction(trans, root, ret); 3910 goto out; 3911 } 3912 di = btrfs_search_dir_index_item(root, path, dir_ino, 3913 name, name_len); 3914 if (IS_ERR_OR_NULL(di)) { 3915 if (!di) 3916 ret = -ENOENT; 3917 else 3918 ret = PTR_ERR(di); 3919 btrfs_abort_transaction(trans, root, ret); 3920 goto out; 3921 } 3922 3923 leaf = path->nodes[0]; 3924 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 3925 btrfs_release_path(path); 3926 index = key.offset; 3927 } 3928 btrfs_release_path(path); 3929 3930 ret = btrfs_delete_delayed_dir_index(trans, root, dir, index); 3931 if (ret) { 3932 btrfs_abort_transaction(trans, root, ret); 3933 goto out; 3934 } 3935 3936 btrfs_i_size_write(dir, dir->i_size - name_len * 2); 3937 inode_inc_iversion(dir); 3938 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 3939 ret = btrfs_update_inode_fallback(trans, root, dir); 3940 if (ret) 3941 btrfs_abort_transaction(trans, root, ret); 3942 out: 3943 btrfs_free_path(path); 3944 return ret; 3945 } 3946 3947 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) 3948 { 3949 struct inode *inode = dentry->d_inode; 3950 int err = 0; 3951 struct btrfs_root *root = BTRFS_I(dir)->root; 3952 struct btrfs_trans_handle *trans; 3953 3954 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE) 3955 return -ENOTEMPTY; 3956 if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID) 3957 return -EPERM; 3958 3959 trans = __unlink_start_trans(dir); 3960 if (IS_ERR(trans)) 3961 return PTR_ERR(trans); 3962 3963 if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) { 3964 err = btrfs_unlink_subvol(trans, root, dir, 3965 BTRFS_I(inode)->location.objectid, 3966 dentry->d_name.name, 3967 dentry->d_name.len); 3968 goto out; 3969 } 3970 3971 err = btrfs_orphan_add(trans, inode); 3972 if (err) 3973 goto out; 3974 3975 /* now the directory is empty */ 3976 err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode, 3977 dentry->d_name.name, dentry->d_name.len); 3978 if (!err) 3979 btrfs_i_size_write(inode, 0); 3980 out: 3981 btrfs_end_transaction(trans, root); 3982 btrfs_btree_balance_dirty(root); 3983 3984 return err; 3985 } 3986 3987 /* 3988 * this can truncate away extent items, csum items and directory items. 3989 * It starts at a high offset and removes keys until it can't find 3990 * any higher than new_size 3991 * 3992 * csum items that cross the new i_size are truncated to the new size 3993 * as well. 3994 * 3995 * min_type is the minimum key type to truncate down to. If set to 0, this 3996 * will kill all the items on this inode, including the INODE_ITEM_KEY. 3997 */ 3998 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, 3999 struct btrfs_root *root, 4000 struct inode *inode, 4001 u64 new_size, u32 min_type) 4002 { 4003 struct btrfs_path *path; 4004 struct extent_buffer *leaf; 4005 struct btrfs_file_extent_item *fi; 4006 struct btrfs_key key; 4007 struct btrfs_key found_key; 4008 u64 extent_start = 0; 4009 u64 extent_num_bytes = 0; 4010 u64 extent_offset = 0; 4011 u64 item_end = 0; 4012 u64 last_size = (u64)-1; 4013 u32 found_type = (u8)-1; 4014 int found_extent; 4015 int del_item; 4016 int pending_del_nr = 0; 4017 int pending_del_slot = 0; 4018 int extent_type = -1; 4019 int ret; 4020 int err = 0; 4021 u64 ino = btrfs_ino(inode); 4022 4023 BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY); 4024 4025 path = btrfs_alloc_path(); 4026 if (!path) 4027 return -ENOMEM; 4028 path->reada = -1; 4029 4030 /* 4031 * We want to drop from the next block forward in case this new size is 4032 * not block aligned since we will be keeping the last block of the 4033 * extent just the way it is. 4034 */ 4035 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 4036 root == root->fs_info->tree_root) 4037 btrfs_drop_extent_cache(inode, ALIGN(new_size, 4038 root->sectorsize), (u64)-1, 0); 4039 4040 /* 4041 * This function is also used to drop the items in the log tree before 4042 * we relog the inode, so if root != BTRFS_I(inode)->root, it means 4043 * it is used to drop the loged items. So we shouldn't kill the delayed 4044 * items. 4045 */ 4046 if (min_type == 0 && root == BTRFS_I(inode)->root) 4047 btrfs_kill_delayed_inode_items(inode); 4048 4049 key.objectid = ino; 4050 key.offset = (u64)-1; 4051 key.type = (u8)-1; 4052 4053 search_again: 4054 path->leave_spinning = 1; 4055 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 4056 if (ret < 0) { 4057 err = ret; 4058 goto out; 4059 } 4060 4061 if (ret > 0) { 4062 /* there are no items in the tree for us to truncate, we're 4063 * done 4064 */ 4065 if (path->slots[0] == 0) 4066 goto out; 4067 path->slots[0]--; 4068 } 4069 4070 while (1) { 4071 fi = NULL; 4072 leaf = path->nodes[0]; 4073 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 4074 found_type = btrfs_key_type(&found_key); 4075 4076 if (found_key.objectid != ino) 4077 break; 4078 4079 if (found_type < min_type) 4080 break; 4081 4082 item_end = found_key.offset; 4083 if (found_type == BTRFS_EXTENT_DATA_KEY) { 4084 fi = btrfs_item_ptr(leaf, path->slots[0], 4085 struct btrfs_file_extent_item); 4086 extent_type = btrfs_file_extent_type(leaf, fi); 4087 if (extent_type != BTRFS_FILE_EXTENT_INLINE) { 4088 item_end += 4089 btrfs_file_extent_num_bytes(leaf, fi); 4090 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 4091 item_end += btrfs_file_extent_inline_len(leaf, 4092 path->slots[0], fi); 4093 } 4094 item_end--; 4095 } 4096 if (found_type > min_type) { 4097 del_item = 1; 4098 } else { 4099 if (item_end < new_size) 4100 break; 4101 if (found_key.offset >= new_size) 4102 del_item = 1; 4103 else 4104 del_item = 0; 4105 } 4106 found_extent = 0; 4107 /* FIXME, shrink the extent if the ref count is only 1 */ 4108 if (found_type != BTRFS_EXTENT_DATA_KEY) 4109 goto delete; 4110 4111 if (del_item) 4112 last_size = found_key.offset; 4113 else 4114 last_size = new_size; 4115 4116 if (extent_type != BTRFS_FILE_EXTENT_INLINE) { 4117 u64 num_dec; 4118 extent_start = btrfs_file_extent_disk_bytenr(leaf, fi); 4119 if (!del_item) { 4120 u64 orig_num_bytes = 4121 btrfs_file_extent_num_bytes(leaf, fi); 4122 extent_num_bytes = ALIGN(new_size - 4123 found_key.offset, 4124 root->sectorsize); 4125 btrfs_set_file_extent_num_bytes(leaf, fi, 4126 extent_num_bytes); 4127 num_dec = (orig_num_bytes - 4128 extent_num_bytes); 4129 if (test_bit(BTRFS_ROOT_REF_COWS, 4130 &root->state) && 4131 extent_start != 0) 4132 inode_sub_bytes(inode, num_dec); 4133 btrfs_mark_buffer_dirty(leaf); 4134 } else { 4135 extent_num_bytes = 4136 btrfs_file_extent_disk_num_bytes(leaf, 4137 fi); 4138 extent_offset = found_key.offset - 4139 btrfs_file_extent_offset(leaf, fi); 4140 4141 /* FIXME blocksize != 4096 */ 4142 num_dec = btrfs_file_extent_num_bytes(leaf, fi); 4143 if (extent_start != 0) { 4144 found_extent = 1; 4145 if (test_bit(BTRFS_ROOT_REF_COWS, 4146 &root->state)) 4147 inode_sub_bytes(inode, num_dec); 4148 } 4149 } 4150 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 4151 /* 4152 * we can't truncate inline items that have had 4153 * special encodings 4154 */ 4155 if (!del_item && 4156 btrfs_file_extent_compression(leaf, fi) == 0 && 4157 btrfs_file_extent_encryption(leaf, fi) == 0 && 4158 btrfs_file_extent_other_encoding(leaf, fi) == 0) { 4159 u32 size = new_size - found_key.offset; 4160 4161 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state)) 4162 inode_sub_bytes(inode, item_end + 1 - 4163 new_size); 4164 4165 /* 4166 * update the ram bytes to properly reflect 4167 * the new size of our item 4168 */ 4169 btrfs_set_file_extent_ram_bytes(leaf, fi, size); 4170 size = 4171 btrfs_file_extent_calc_inline_size(size); 4172 btrfs_truncate_item(root, path, size, 1); 4173 } else if (test_bit(BTRFS_ROOT_REF_COWS, 4174 &root->state)) { 4175 inode_sub_bytes(inode, item_end + 1 - 4176 found_key.offset); 4177 } 4178 } 4179 delete: 4180 if (del_item) { 4181 if (!pending_del_nr) { 4182 /* no pending yet, add ourselves */ 4183 pending_del_slot = path->slots[0]; 4184 pending_del_nr = 1; 4185 } else if (pending_del_nr && 4186 path->slots[0] + 1 == pending_del_slot) { 4187 /* hop on the pending chunk */ 4188 pending_del_nr++; 4189 pending_del_slot = path->slots[0]; 4190 } else { 4191 BUG(); 4192 } 4193 } else { 4194 break; 4195 } 4196 if (found_extent && 4197 (test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 4198 root == root->fs_info->tree_root)) { 4199 btrfs_set_path_blocking(path); 4200 ret = btrfs_free_extent(trans, root, extent_start, 4201 extent_num_bytes, 0, 4202 btrfs_header_owner(leaf), 4203 ino, extent_offset, 0); 4204 BUG_ON(ret); 4205 } 4206 4207 if (found_type == BTRFS_INODE_ITEM_KEY) 4208 break; 4209 4210 if (path->slots[0] == 0 || 4211 path->slots[0] != pending_del_slot) { 4212 if (pending_del_nr) { 4213 ret = btrfs_del_items(trans, root, path, 4214 pending_del_slot, 4215 pending_del_nr); 4216 if (ret) { 4217 btrfs_abort_transaction(trans, 4218 root, ret); 4219 goto error; 4220 } 4221 pending_del_nr = 0; 4222 } 4223 btrfs_release_path(path); 4224 goto search_again; 4225 } else { 4226 path->slots[0]--; 4227 } 4228 } 4229 out: 4230 if (pending_del_nr) { 4231 ret = btrfs_del_items(trans, root, path, pending_del_slot, 4232 pending_del_nr); 4233 if (ret) 4234 btrfs_abort_transaction(trans, root, ret); 4235 } 4236 error: 4237 if (last_size != (u64)-1) 4238 btrfs_ordered_update_i_size(inode, last_size, NULL); 4239 btrfs_free_path(path); 4240 return err; 4241 } 4242 4243 /* 4244 * btrfs_truncate_page - read, zero a chunk and write a page 4245 * @inode - inode that we're zeroing 4246 * @from - the offset to start zeroing 4247 * @len - the length to zero, 0 to zero the entire range respective to the 4248 * offset 4249 * @front - zero up to the offset instead of from the offset on 4250 * 4251 * This will find the page for the "from" offset and cow the page and zero the 4252 * part we want to zero. This is used with truncate and hole punching. 4253 */ 4254 int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len, 4255 int front) 4256 { 4257 struct address_space *mapping = inode->i_mapping; 4258 struct btrfs_root *root = BTRFS_I(inode)->root; 4259 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 4260 struct btrfs_ordered_extent *ordered; 4261 struct extent_state *cached_state = NULL; 4262 char *kaddr; 4263 u32 blocksize = root->sectorsize; 4264 pgoff_t index = from >> PAGE_CACHE_SHIFT; 4265 unsigned offset = from & (PAGE_CACHE_SIZE-1); 4266 struct page *page; 4267 gfp_t mask = btrfs_alloc_write_mask(mapping); 4268 int ret = 0; 4269 u64 page_start; 4270 u64 page_end; 4271 4272 if ((offset & (blocksize - 1)) == 0 && 4273 (!len || ((len & (blocksize - 1)) == 0))) 4274 goto out; 4275 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE); 4276 if (ret) 4277 goto out; 4278 4279 again: 4280 page = find_or_create_page(mapping, index, mask); 4281 if (!page) { 4282 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE); 4283 ret = -ENOMEM; 4284 goto out; 4285 } 4286 4287 page_start = page_offset(page); 4288 page_end = page_start + PAGE_CACHE_SIZE - 1; 4289 4290 if (!PageUptodate(page)) { 4291 ret = btrfs_readpage(NULL, page); 4292 lock_page(page); 4293 if (page->mapping != mapping) { 4294 unlock_page(page); 4295 page_cache_release(page); 4296 goto again; 4297 } 4298 if (!PageUptodate(page)) { 4299 ret = -EIO; 4300 goto out_unlock; 4301 } 4302 } 4303 wait_on_page_writeback(page); 4304 4305 lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state); 4306 set_page_extent_mapped(page); 4307 4308 ordered = btrfs_lookup_ordered_extent(inode, page_start); 4309 if (ordered) { 4310 unlock_extent_cached(io_tree, page_start, page_end, 4311 &cached_state, GFP_NOFS); 4312 unlock_page(page); 4313 page_cache_release(page); 4314 btrfs_start_ordered_extent(inode, ordered, 1); 4315 btrfs_put_ordered_extent(ordered); 4316 goto again; 4317 } 4318 4319 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end, 4320 EXTENT_DIRTY | EXTENT_DELALLOC | 4321 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 4322 0, 0, &cached_state, GFP_NOFS); 4323 4324 ret = btrfs_set_extent_delalloc(inode, page_start, page_end, 4325 &cached_state); 4326 if (ret) { 4327 unlock_extent_cached(io_tree, page_start, page_end, 4328 &cached_state, GFP_NOFS); 4329 goto out_unlock; 4330 } 4331 4332 if (offset != PAGE_CACHE_SIZE) { 4333 if (!len) 4334 len = PAGE_CACHE_SIZE - offset; 4335 kaddr = kmap(page); 4336 if (front) 4337 memset(kaddr, 0, offset); 4338 else 4339 memset(kaddr + offset, 0, len); 4340 flush_dcache_page(page); 4341 kunmap(page); 4342 } 4343 ClearPageChecked(page); 4344 set_page_dirty(page); 4345 unlock_extent_cached(io_tree, page_start, page_end, &cached_state, 4346 GFP_NOFS); 4347 4348 out_unlock: 4349 if (ret) 4350 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE); 4351 unlock_page(page); 4352 page_cache_release(page); 4353 out: 4354 return ret; 4355 } 4356 4357 static int maybe_insert_hole(struct btrfs_root *root, struct inode *inode, 4358 u64 offset, u64 len) 4359 { 4360 struct btrfs_trans_handle *trans; 4361 int ret; 4362 4363 /* 4364 * Still need to make sure the inode looks like it's been updated so 4365 * that any holes get logged if we fsync. 4366 */ 4367 if (btrfs_fs_incompat(root->fs_info, NO_HOLES)) { 4368 BTRFS_I(inode)->last_trans = root->fs_info->generation; 4369 BTRFS_I(inode)->last_sub_trans = root->log_transid; 4370 BTRFS_I(inode)->last_log_commit = root->last_log_commit; 4371 return 0; 4372 } 4373 4374 /* 4375 * 1 - for the one we're dropping 4376 * 1 - for the one we're adding 4377 * 1 - for updating the inode. 4378 */ 4379 trans = btrfs_start_transaction(root, 3); 4380 if (IS_ERR(trans)) 4381 return PTR_ERR(trans); 4382 4383 ret = btrfs_drop_extents(trans, root, inode, offset, offset + len, 1); 4384 if (ret) { 4385 btrfs_abort_transaction(trans, root, ret); 4386 btrfs_end_transaction(trans, root); 4387 return ret; 4388 } 4389 4390 ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode), offset, 4391 0, 0, len, 0, len, 0, 0, 0); 4392 if (ret) 4393 btrfs_abort_transaction(trans, root, ret); 4394 else 4395 btrfs_update_inode(trans, root, inode); 4396 btrfs_end_transaction(trans, root); 4397 return ret; 4398 } 4399 4400 /* 4401 * This function puts in dummy file extents for the area we're creating a hole 4402 * for. So if we are truncating this file to a larger size we need to insert 4403 * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for 4404 * the range between oldsize and size 4405 */ 4406 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size) 4407 { 4408 struct btrfs_root *root = BTRFS_I(inode)->root; 4409 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 4410 struct extent_map *em = NULL; 4411 struct extent_state *cached_state = NULL; 4412 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 4413 u64 hole_start = ALIGN(oldsize, root->sectorsize); 4414 u64 block_end = ALIGN(size, root->sectorsize); 4415 u64 last_byte; 4416 u64 cur_offset; 4417 u64 hole_size; 4418 int err = 0; 4419 4420 /* 4421 * If our size started in the middle of a page we need to zero out the 4422 * rest of the page before we expand the i_size, otherwise we could 4423 * expose stale data. 4424 */ 4425 err = btrfs_truncate_page(inode, oldsize, 0, 0); 4426 if (err) 4427 return err; 4428 4429 if (size <= hole_start) 4430 return 0; 4431 4432 while (1) { 4433 struct btrfs_ordered_extent *ordered; 4434 4435 lock_extent_bits(io_tree, hole_start, block_end - 1, 0, 4436 &cached_state); 4437 ordered = btrfs_lookup_ordered_range(inode, hole_start, 4438 block_end - hole_start); 4439 if (!ordered) 4440 break; 4441 unlock_extent_cached(io_tree, hole_start, block_end - 1, 4442 &cached_state, GFP_NOFS); 4443 btrfs_start_ordered_extent(inode, ordered, 1); 4444 btrfs_put_ordered_extent(ordered); 4445 } 4446 4447 cur_offset = hole_start; 4448 while (1) { 4449 em = btrfs_get_extent(inode, NULL, 0, cur_offset, 4450 block_end - cur_offset, 0); 4451 if (IS_ERR(em)) { 4452 err = PTR_ERR(em); 4453 em = NULL; 4454 break; 4455 } 4456 last_byte = min(extent_map_end(em), block_end); 4457 last_byte = ALIGN(last_byte , root->sectorsize); 4458 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) { 4459 struct extent_map *hole_em; 4460 hole_size = last_byte - cur_offset; 4461 4462 err = maybe_insert_hole(root, inode, cur_offset, 4463 hole_size); 4464 if (err) 4465 break; 4466 btrfs_drop_extent_cache(inode, cur_offset, 4467 cur_offset + hole_size - 1, 0); 4468 hole_em = alloc_extent_map(); 4469 if (!hole_em) { 4470 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 4471 &BTRFS_I(inode)->runtime_flags); 4472 goto next; 4473 } 4474 hole_em->start = cur_offset; 4475 hole_em->len = hole_size; 4476 hole_em->orig_start = cur_offset; 4477 4478 hole_em->block_start = EXTENT_MAP_HOLE; 4479 hole_em->block_len = 0; 4480 hole_em->orig_block_len = 0; 4481 hole_em->ram_bytes = hole_size; 4482 hole_em->bdev = root->fs_info->fs_devices->latest_bdev; 4483 hole_em->compress_type = BTRFS_COMPRESS_NONE; 4484 hole_em->generation = root->fs_info->generation; 4485 4486 while (1) { 4487 write_lock(&em_tree->lock); 4488 err = add_extent_mapping(em_tree, hole_em, 1); 4489 write_unlock(&em_tree->lock); 4490 if (err != -EEXIST) 4491 break; 4492 btrfs_drop_extent_cache(inode, cur_offset, 4493 cur_offset + 4494 hole_size - 1, 0); 4495 } 4496 free_extent_map(hole_em); 4497 } 4498 next: 4499 free_extent_map(em); 4500 em = NULL; 4501 cur_offset = last_byte; 4502 if (cur_offset >= block_end) 4503 break; 4504 } 4505 free_extent_map(em); 4506 unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state, 4507 GFP_NOFS); 4508 return err; 4509 } 4510 4511 static int btrfs_setsize(struct inode *inode, struct iattr *attr) 4512 { 4513 struct btrfs_root *root = BTRFS_I(inode)->root; 4514 struct btrfs_trans_handle *trans; 4515 loff_t oldsize = i_size_read(inode); 4516 loff_t newsize = attr->ia_size; 4517 int mask = attr->ia_valid; 4518 int ret; 4519 4520 /* 4521 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a 4522 * special case where we need to update the times despite not having 4523 * these flags set. For all other operations the VFS set these flags 4524 * explicitly if it wants a timestamp update. 4525 */ 4526 if (newsize != oldsize) { 4527 inode_inc_iversion(inode); 4528 if (!(mask & (ATTR_CTIME | ATTR_MTIME))) 4529 inode->i_ctime = inode->i_mtime = 4530 current_fs_time(inode->i_sb); 4531 } 4532 4533 if (newsize > oldsize) { 4534 truncate_pagecache(inode, newsize); 4535 ret = btrfs_cont_expand(inode, oldsize, newsize); 4536 if (ret) 4537 return ret; 4538 4539 trans = btrfs_start_transaction(root, 1); 4540 if (IS_ERR(trans)) 4541 return PTR_ERR(trans); 4542 4543 i_size_write(inode, newsize); 4544 btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL); 4545 ret = btrfs_update_inode(trans, root, inode); 4546 btrfs_end_transaction(trans, root); 4547 } else { 4548 4549 /* 4550 * We're truncating a file that used to have good data down to 4551 * zero. Make sure it gets into the ordered flush list so that 4552 * any new writes get down to disk quickly. 4553 */ 4554 if (newsize == 0) 4555 set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE, 4556 &BTRFS_I(inode)->runtime_flags); 4557 4558 /* 4559 * 1 for the orphan item we're going to add 4560 * 1 for the orphan item deletion. 4561 */ 4562 trans = btrfs_start_transaction(root, 2); 4563 if (IS_ERR(trans)) 4564 return PTR_ERR(trans); 4565 4566 /* 4567 * We need to do this in case we fail at _any_ point during the 4568 * actual truncate. Once we do the truncate_setsize we could 4569 * invalidate pages which forces any outstanding ordered io to 4570 * be instantly completed which will give us extents that need 4571 * to be truncated. If we fail to get an orphan inode down we 4572 * could have left over extents that were never meant to live, 4573 * so we need to garuntee from this point on that everything 4574 * will be consistent. 4575 */ 4576 ret = btrfs_orphan_add(trans, inode); 4577 btrfs_end_transaction(trans, root); 4578 if (ret) 4579 return ret; 4580 4581 /* we don't support swapfiles, so vmtruncate shouldn't fail */ 4582 truncate_setsize(inode, newsize); 4583 4584 /* Disable nonlocked read DIO to avoid the end less truncate */ 4585 btrfs_inode_block_unlocked_dio(inode); 4586 inode_dio_wait(inode); 4587 btrfs_inode_resume_unlocked_dio(inode); 4588 4589 ret = btrfs_truncate(inode); 4590 if (ret && inode->i_nlink) { 4591 int err; 4592 4593 /* 4594 * failed to truncate, disk_i_size is only adjusted down 4595 * as we remove extents, so it should represent the true 4596 * size of the inode, so reset the in memory size and 4597 * delete our orphan entry. 4598 */ 4599 trans = btrfs_join_transaction(root); 4600 if (IS_ERR(trans)) { 4601 btrfs_orphan_del(NULL, inode); 4602 return ret; 4603 } 4604 i_size_write(inode, BTRFS_I(inode)->disk_i_size); 4605 err = btrfs_orphan_del(trans, inode); 4606 if (err) 4607 btrfs_abort_transaction(trans, root, err); 4608 btrfs_end_transaction(trans, root); 4609 } 4610 } 4611 4612 return ret; 4613 } 4614 4615 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr) 4616 { 4617 struct inode *inode = dentry->d_inode; 4618 struct btrfs_root *root = BTRFS_I(inode)->root; 4619 int err; 4620 4621 if (btrfs_root_readonly(root)) 4622 return -EROFS; 4623 4624 err = inode_change_ok(inode, attr); 4625 if (err) 4626 return err; 4627 4628 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) { 4629 err = btrfs_setsize(inode, attr); 4630 if (err) 4631 return err; 4632 } 4633 4634 if (attr->ia_valid) { 4635 setattr_copy(inode, attr); 4636 inode_inc_iversion(inode); 4637 err = btrfs_dirty_inode(inode); 4638 4639 if (!err && attr->ia_valid & ATTR_MODE) 4640 err = posix_acl_chmod(inode, inode->i_mode); 4641 } 4642 4643 return err; 4644 } 4645 4646 /* 4647 * While truncating the inode pages during eviction, we get the VFS calling 4648 * btrfs_invalidatepage() against each page of the inode. This is slow because 4649 * the calls to btrfs_invalidatepage() result in a huge amount of calls to 4650 * lock_extent_bits() and clear_extent_bit(), which keep merging and splitting 4651 * extent_state structures over and over, wasting lots of time. 4652 * 4653 * Therefore if the inode is being evicted, let btrfs_invalidatepage() skip all 4654 * those expensive operations on a per page basis and do only the ordered io 4655 * finishing, while we release here the extent_map and extent_state structures, 4656 * without the excessive merging and splitting. 4657 */ 4658 static void evict_inode_truncate_pages(struct inode *inode) 4659 { 4660 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 4661 struct extent_map_tree *map_tree = &BTRFS_I(inode)->extent_tree; 4662 struct rb_node *node; 4663 4664 ASSERT(inode->i_state & I_FREEING); 4665 truncate_inode_pages_final(&inode->i_data); 4666 4667 write_lock(&map_tree->lock); 4668 while (!RB_EMPTY_ROOT(&map_tree->map)) { 4669 struct extent_map *em; 4670 4671 node = rb_first(&map_tree->map); 4672 em = rb_entry(node, struct extent_map, rb_node); 4673 clear_bit(EXTENT_FLAG_PINNED, &em->flags); 4674 clear_bit(EXTENT_FLAG_LOGGING, &em->flags); 4675 remove_extent_mapping(map_tree, em); 4676 free_extent_map(em); 4677 } 4678 write_unlock(&map_tree->lock); 4679 4680 spin_lock(&io_tree->lock); 4681 while (!RB_EMPTY_ROOT(&io_tree->state)) { 4682 struct extent_state *state; 4683 struct extent_state *cached_state = NULL; 4684 4685 node = rb_first(&io_tree->state); 4686 state = rb_entry(node, struct extent_state, rb_node); 4687 atomic_inc(&state->refs); 4688 spin_unlock(&io_tree->lock); 4689 4690 lock_extent_bits(io_tree, state->start, state->end, 4691 0, &cached_state); 4692 clear_extent_bit(io_tree, state->start, state->end, 4693 EXTENT_LOCKED | EXTENT_DIRTY | 4694 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | 4695 EXTENT_DEFRAG, 1, 1, 4696 &cached_state, GFP_NOFS); 4697 free_extent_state(state); 4698 4699 spin_lock(&io_tree->lock); 4700 } 4701 spin_unlock(&io_tree->lock); 4702 } 4703 4704 void btrfs_evict_inode(struct inode *inode) 4705 { 4706 struct btrfs_trans_handle *trans; 4707 struct btrfs_root *root = BTRFS_I(inode)->root; 4708 struct btrfs_block_rsv *rsv, *global_rsv; 4709 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1); 4710 int ret; 4711 4712 trace_btrfs_inode_evict(inode); 4713 4714 evict_inode_truncate_pages(inode); 4715 4716 if (inode->i_nlink && 4717 ((btrfs_root_refs(&root->root_item) != 0 && 4718 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) || 4719 btrfs_is_free_space_inode(inode))) 4720 goto no_delete; 4721 4722 if (is_bad_inode(inode)) { 4723 btrfs_orphan_del(NULL, inode); 4724 goto no_delete; 4725 } 4726 /* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */ 4727 btrfs_wait_ordered_range(inode, 0, (u64)-1); 4728 4729 if (root->fs_info->log_root_recovering) { 4730 BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 4731 &BTRFS_I(inode)->runtime_flags)); 4732 goto no_delete; 4733 } 4734 4735 if (inode->i_nlink > 0) { 4736 BUG_ON(btrfs_root_refs(&root->root_item) != 0 && 4737 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID); 4738 goto no_delete; 4739 } 4740 4741 ret = btrfs_commit_inode_delayed_inode(inode); 4742 if (ret) { 4743 btrfs_orphan_del(NULL, inode); 4744 goto no_delete; 4745 } 4746 4747 rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP); 4748 if (!rsv) { 4749 btrfs_orphan_del(NULL, inode); 4750 goto no_delete; 4751 } 4752 rsv->size = min_size; 4753 rsv->failfast = 1; 4754 global_rsv = &root->fs_info->global_block_rsv; 4755 4756 btrfs_i_size_write(inode, 0); 4757 4758 /* 4759 * This is a bit simpler than btrfs_truncate since we've already 4760 * reserved our space for our orphan item in the unlink, so we just 4761 * need to reserve some slack space in case we add bytes and update 4762 * inode item when doing the truncate. 4763 */ 4764 while (1) { 4765 ret = btrfs_block_rsv_refill(root, rsv, min_size, 4766 BTRFS_RESERVE_FLUSH_LIMIT); 4767 4768 /* 4769 * Try and steal from the global reserve since we will 4770 * likely not use this space anyway, we want to try as 4771 * hard as possible to get this to work. 4772 */ 4773 if (ret) 4774 ret = btrfs_block_rsv_migrate(global_rsv, rsv, min_size); 4775 4776 if (ret) { 4777 btrfs_warn(root->fs_info, 4778 "Could not get space for a delete, will truncate on mount %d", 4779 ret); 4780 btrfs_orphan_del(NULL, inode); 4781 btrfs_free_block_rsv(root, rsv); 4782 goto no_delete; 4783 } 4784 4785 trans = btrfs_join_transaction(root); 4786 if (IS_ERR(trans)) { 4787 btrfs_orphan_del(NULL, inode); 4788 btrfs_free_block_rsv(root, rsv); 4789 goto no_delete; 4790 } 4791 4792 trans->block_rsv = rsv; 4793 4794 ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0); 4795 if (ret != -ENOSPC) 4796 break; 4797 4798 trans->block_rsv = &root->fs_info->trans_block_rsv; 4799 btrfs_end_transaction(trans, root); 4800 trans = NULL; 4801 btrfs_btree_balance_dirty(root); 4802 } 4803 4804 btrfs_free_block_rsv(root, rsv); 4805 4806 /* 4807 * Errors here aren't a big deal, it just means we leave orphan items 4808 * in the tree. They will be cleaned up on the next mount. 4809 */ 4810 if (ret == 0) { 4811 trans->block_rsv = root->orphan_block_rsv; 4812 btrfs_orphan_del(trans, inode); 4813 } else { 4814 btrfs_orphan_del(NULL, inode); 4815 } 4816 4817 trans->block_rsv = &root->fs_info->trans_block_rsv; 4818 if (!(root == root->fs_info->tree_root || 4819 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)) 4820 btrfs_return_ino(root, btrfs_ino(inode)); 4821 4822 btrfs_end_transaction(trans, root); 4823 btrfs_btree_balance_dirty(root); 4824 no_delete: 4825 btrfs_remove_delayed_node(inode); 4826 clear_inode(inode); 4827 return; 4828 } 4829 4830 /* 4831 * this returns the key found in the dir entry in the location pointer. 4832 * If no dir entries were found, location->objectid is 0. 4833 */ 4834 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry, 4835 struct btrfs_key *location) 4836 { 4837 const char *name = dentry->d_name.name; 4838 int namelen = dentry->d_name.len; 4839 struct btrfs_dir_item *di; 4840 struct btrfs_path *path; 4841 struct btrfs_root *root = BTRFS_I(dir)->root; 4842 int ret = 0; 4843 4844 path = btrfs_alloc_path(); 4845 if (!path) 4846 return -ENOMEM; 4847 4848 di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name, 4849 namelen, 0); 4850 if (IS_ERR(di)) 4851 ret = PTR_ERR(di); 4852 4853 if (IS_ERR_OR_NULL(di)) 4854 goto out_err; 4855 4856 btrfs_dir_item_key_to_cpu(path->nodes[0], di, location); 4857 out: 4858 btrfs_free_path(path); 4859 return ret; 4860 out_err: 4861 location->objectid = 0; 4862 goto out; 4863 } 4864 4865 /* 4866 * when we hit a tree root in a directory, the btrfs part of the inode 4867 * needs to be changed to reflect the root directory of the tree root. This 4868 * is kind of like crossing a mount point. 4869 */ 4870 static int fixup_tree_root_location(struct btrfs_root *root, 4871 struct inode *dir, 4872 struct dentry *dentry, 4873 struct btrfs_key *location, 4874 struct btrfs_root **sub_root) 4875 { 4876 struct btrfs_path *path; 4877 struct btrfs_root *new_root; 4878 struct btrfs_root_ref *ref; 4879 struct extent_buffer *leaf; 4880 int ret; 4881 int err = 0; 4882 4883 path = btrfs_alloc_path(); 4884 if (!path) { 4885 err = -ENOMEM; 4886 goto out; 4887 } 4888 4889 err = -ENOENT; 4890 ret = btrfs_find_item(root->fs_info->tree_root, path, 4891 BTRFS_I(dir)->root->root_key.objectid, 4892 location->objectid, BTRFS_ROOT_REF_KEY, NULL); 4893 if (ret) { 4894 if (ret < 0) 4895 err = ret; 4896 goto out; 4897 } 4898 4899 leaf = path->nodes[0]; 4900 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); 4901 if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) || 4902 btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len) 4903 goto out; 4904 4905 ret = memcmp_extent_buffer(leaf, dentry->d_name.name, 4906 (unsigned long)(ref + 1), 4907 dentry->d_name.len); 4908 if (ret) 4909 goto out; 4910 4911 btrfs_release_path(path); 4912 4913 new_root = btrfs_read_fs_root_no_name(root->fs_info, location); 4914 if (IS_ERR(new_root)) { 4915 err = PTR_ERR(new_root); 4916 goto out; 4917 } 4918 4919 *sub_root = new_root; 4920 location->objectid = btrfs_root_dirid(&new_root->root_item); 4921 location->type = BTRFS_INODE_ITEM_KEY; 4922 location->offset = 0; 4923 err = 0; 4924 out: 4925 btrfs_free_path(path); 4926 return err; 4927 } 4928 4929 static void inode_tree_add(struct inode *inode) 4930 { 4931 struct btrfs_root *root = BTRFS_I(inode)->root; 4932 struct btrfs_inode *entry; 4933 struct rb_node **p; 4934 struct rb_node *parent; 4935 struct rb_node *new = &BTRFS_I(inode)->rb_node; 4936 u64 ino = btrfs_ino(inode); 4937 4938 if (inode_unhashed(inode)) 4939 return; 4940 parent = NULL; 4941 spin_lock(&root->inode_lock); 4942 p = &root->inode_tree.rb_node; 4943 while (*p) { 4944 parent = *p; 4945 entry = rb_entry(parent, struct btrfs_inode, rb_node); 4946 4947 if (ino < btrfs_ino(&entry->vfs_inode)) 4948 p = &parent->rb_left; 4949 else if (ino > btrfs_ino(&entry->vfs_inode)) 4950 p = &parent->rb_right; 4951 else { 4952 WARN_ON(!(entry->vfs_inode.i_state & 4953 (I_WILL_FREE | I_FREEING))); 4954 rb_replace_node(parent, new, &root->inode_tree); 4955 RB_CLEAR_NODE(parent); 4956 spin_unlock(&root->inode_lock); 4957 return; 4958 } 4959 } 4960 rb_link_node(new, parent, p); 4961 rb_insert_color(new, &root->inode_tree); 4962 spin_unlock(&root->inode_lock); 4963 } 4964 4965 static void inode_tree_del(struct inode *inode) 4966 { 4967 struct btrfs_root *root = BTRFS_I(inode)->root; 4968 int empty = 0; 4969 4970 spin_lock(&root->inode_lock); 4971 if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) { 4972 rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree); 4973 RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node); 4974 empty = RB_EMPTY_ROOT(&root->inode_tree); 4975 } 4976 spin_unlock(&root->inode_lock); 4977 4978 if (empty && btrfs_root_refs(&root->root_item) == 0) { 4979 synchronize_srcu(&root->fs_info->subvol_srcu); 4980 spin_lock(&root->inode_lock); 4981 empty = RB_EMPTY_ROOT(&root->inode_tree); 4982 spin_unlock(&root->inode_lock); 4983 if (empty) 4984 btrfs_add_dead_root(root); 4985 } 4986 } 4987 4988 void btrfs_invalidate_inodes(struct btrfs_root *root) 4989 { 4990 struct rb_node *node; 4991 struct rb_node *prev; 4992 struct btrfs_inode *entry; 4993 struct inode *inode; 4994 u64 objectid = 0; 4995 4996 if (!test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) 4997 WARN_ON(btrfs_root_refs(&root->root_item) != 0); 4998 4999 spin_lock(&root->inode_lock); 5000 again: 5001 node = root->inode_tree.rb_node; 5002 prev = NULL; 5003 while (node) { 5004 prev = node; 5005 entry = rb_entry(node, struct btrfs_inode, rb_node); 5006 5007 if (objectid < btrfs_ino(&entry->vfs_inode)) 5008 node = node->rb_left; 5009 else if (objectid > btrfs_ino(&entry->vfs_inode)) 5010 node = node->rb_right; 5011 else 5012 break; 5013 } 5014 if (!node) { 5015 while (prev) { 5016 entry = rb_entry(prev, struct btrfs_inode, rb_node); 5017 if (objectid <= btrfs_ino(&entry->vfs_inode)) { 5018 node = prev; 5019 break; 5020 } 5021 prev = rb_next(prev); 5022 } 5023 } 5024 while (node) { 5025 entry = rb_entry(node, struct btrfs_inode, rb_node); 5026 objectid = btrfs_ino(&entry->vfs_inode) + 1; 5027 inode = igrab(&entry->vfs_inode); 5028 if (inode) { 5029 spin_unlock(&root->inode_lock); 5030 if (atomic_read(&inode->i_count) > 1) 5031 d_prune_aliases(inode); 5032 /* 5033 * btrfs_drop_inode will have it removed from 5034 * the inode cache when its usage count 5035 * hits zero. 5036 */ 5037 iput(inode); 5038 cond_resched(); 5039 spin_lock(&root->inode_lock); 5040 goto again; 5041 } 5042 5043 if (cond_resched_lock(&root->inode_lock)) 5044 goto again; 5045 5046 node = rb_next(node); 5047 } 5048 spin_unlock(&root->inode_lock); 5049 } 5050 5051 static int btrfs_init_locked_inode(struct inode *inode, void *p) 5052 { 5053 struct btrfs_iget_args *args = p; 5054 inode->i_ino = args->location->objectid; 5055 memcpy(&BTRFS_I(inode)->location, args->location, 5056 sizeof(*args->location)); 5057 BTRFS_I(inode)->root = args->root; 5058 return 0; 5059 } 5060 5061 static int btrfs_find_actor(struct inode *inode, void *opaque) 5062 { 5063 struct btrfs_iget_args *args = opaque; 5064 return args->location->objectid == BTRFS_I(inode)->location.objectid && 5065 args->root == BTRFS_I(inode)->root; 5066 } 5067 5068 static struct inode *btrfs_iget_locked(struct super_block *s, 5069 struct btrfs_key *location, 5070 struct btrfs_root *root) 5071 { 5072 struct inode *inode; 5073 struct btrfs_iget_args args; 5074 unsigned long hashval = btrfs_inode_hash(location->objectid, root); 5075 5076 args.location = location; 5077 args.root = root; 5078 5079 inode = iget5_locked(s, hashval, btrfs_find_actor, 5080 btrfs_init_locked_inode, 5081 (void *)&args); 5082 return inode; 5083 } 5084 5085 /* Get an inode object given its location and corresponding root. 5086 * Returns in *is_new if the inode was read from disk 5087 */ 5088 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location, 5089 struct btrfs_root *root, int *new) 5090 { 5091 struct inode *inode; 5092 5093 inode = btrfs_iget_locked(s, location, root); 5094 if (!inode) 5095 return ERR_PTR(-ENOMEM); 5096 5097 if (inode->i_state & I_NEW) { 5098 btrfs_read_locked_inode(inode); 5099 if (!is_bad_inode(inode)) { 5100 inode_tree_add(inode); 5101 unlock_new_inode(inode); 5102 if (new) 5103 *new = 1; 5104 } else { 5105 unlock_new_inode(inode); 5106 iput(inode); 5107 inode = ERR_PTR(-ESTALE); 5108 } 5109 } 5110 5111 return inode; 5112 } 5113 5114 static struct inode *new_simple_dir(struct super_block *s, 5115 struct btrfs_key *key, 5116 struct btrfs_root *root) 5117 { 5118 struct inode *inode = new_inode(s); 5119 5120 if (!inode) 5121 return ERR_PTR(-ENOMEM); 5122 5123 BTRFS_I(inode)->root = root; 5124 memcpy(&BTRFS_I(inode)->location, key, sizeof(*key)); 5125 set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags); 5126 5127 inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID; 5128 inode->i_op = &btrfs_dir_ro_inode_operations; 5129 inode->i_fop = &simple_dir_operations; 5130 inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO; 5131 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 5132 5133 return inode; 5134 } 5135 5136 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry) 5137 { 5138 struct inode *inode; 5139 struct btrfs_root *root = BTRFS_I(dir)->root; 5140 struct btrfs_root *sub_root = root; 5141 struct btrfs_key location; 5142 int index; 5143 int ret = 0; 5144 5145 if (dentry->d_name.len > BTRFS_NAME_LEN) 5146 return ERR_PTR(-ENAMETOOLONG); 5147 5148 ret = btrfs_inode_by_name(dir, dentry, &location); 5149 if (ret < 0) 5150 return ERR_PTR(ret); 5151 5152 if (location.objectid == 0) 5153 return ERR_PTR(-ENOENT); 5154 5155 if (location.type == BTRFS_INODE_ITEM_KEY) { 5156 inode = btrfs_iget(dir->i_sb, &location, root, NULL); 5157 return inode; 5158 } 5159 5160 BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY); 5161 5162 index = srcu_read_lock(&root->fs_info->subvol_srcu); 5163 ret = fixup_tree_root_location(root, dir, dentry, 5164 &location, &sub_root); 5165 if (ret < 0) { 5166 if (ret != -ENOENT) 5167 inode = ERR_PTR(ret); 5168 else 5169 inode = new_simple_dir(dir->i_sb, &location, sub_root); 5170 } else { 5171 inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL); 5172 } 5173 srcu_read_unlock(&root->fs_info->subvol_srcu, index); 5174 5175 if (!IS_ERR(inode) && root != sub_root) { 5176 down_read(&root->fs_info->cleanup_work_sem); 5177 if (!(inode->i_sb->s_flags & MS_RDONLY)) 5178 ret = btrfs_orphan_cleanup(sub_root); 5179 up_read(&root->fs_info->cleanup_work_sem); 5180 if (ret) { 5181 iput(inode); 5182 inode = ERR_PTR(ret); 5183 } 5184 } 5185 5186 return inode; 5187 } 5188 5189 static int btrfs_dentry_delete(const struct dentry *dentry) 5190 { 5191 struct btrfs_root *root; 5192 struct inode *inode = dentry->d_inode; 5193 5194 if (!inode && !IS_ROOT(dentry)) 5195 inode = dentry->d_parent->d_inode; 5196 5197 if (inode) { 5198 root = BTRFS_I(inode)->root; 5199 if (btrfs_root_refs(&root->root_item) == 0) 5200 return 1; 5201 5202 if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID) 5203 return 1; 5204 } 5205 return 0; 5206 } 5207 5208 static void btrfs_dentry_release(struct dentry *dentry) 5209 { 5210 kfree(dentry->d_fsdata); 5211 } 5212 5213 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry, 5214 unsigned int flags) 5215 { 5216 struct inode *inode; 5217 5218 inode = btrfs_lookup_dentry(dir, dentry); 5219 if (IS_ERR(inode)) { 5220 if (PTR_ERR(inode) == -ENOENT) 5221 inode = NULL; 5222 else 5223 return ERR_CAST(inode); 5224 } 5225 5226 return d_materialise_unique(dentry, inode); 5227 } 5228 5229 unsigned char btrfs_filetype_table[] = { 5230 DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK 5231 }; 5232 5233 static int btrfs_real_readdir(struct file *file, struct dir_context *ctx) 5234 { 5235 struct inode *inode = file_inode(file); 5236 struct btrfs_root *root = BTRFS_I(inode)->root; 5237 struct btrfs_item *item; 5238 struct btrfs_dir_item *di; 5239 struct btrfs_key key; 5240 struct btrfs_key found_key; 5241 struct btrfs_path *path; 5242 struct list_head ins_list; 5243 struct list_head del_list; 5244 int ret; 5245 struct extent_buffer *leaf; 5246 int slot; 5247 unsigned char d_type; 5248 int over = 0; 5249 u32 di_cur; 5250 u32 di_total; 5251 u32 di_len; 5252 int key_type = BTRFS_DIR_INDEX_KEY; 5253 char tmp_name[32]; 5254 char *name_ptr; 5255 int name_len; 5256 int is_curr = 0; /* ctx->pos points to the current index? */ 5257 5258 /* FIXME, use a real flag for deciding about the key type */ 5259 if (root->fs_info->tree_root == root) 5260 key_type = BTRFS_DIR_ITEM_KEY; 5261 5262 if (!dir_emit_dots(file, ctx)) 5263 return 0; 5264 5265 path = btrfs_alloc_path(); 5266 if (!path) 5267 return -ENOMEM; 5268 5269 path->reada = 1; 5270 5271 if (key_type == BTRFS_DIR_INDEX_KEY) { 5272 INIT_LIST_HEAD(&ins_list); 5273 INIT_LIST_HEAD(&del_list); 5274 btrfs_get_delayed_items(inode, &ins_list, &del_list); 5275 } 5276 5277 btrfs_set_key_type(&key, key_type); 5278 key.offset = ctx->pos; 5279 key.objectid = btrfs_ino(inode); 5280 5281 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 5282 if (ret < 0) 5283 goto err; 5284 5285 while (1) { 5286 leaf = path->nodes[0]; 5287 slot = path->slots[0]; 5288 if (slot >= btrfs_header_nritems(leaf)) { 5289 ret = btrfs_next_leaf(root, path); 5290 if (ret < 0) 5291 goto err; 5292 else if (ret > 0) 5293 break; 5294 continue; 5295 } 5296 5297 item = btrfs_item_nr(slot); 5298 btrfs_item_key_to_cpu(leaf, &found_key, slot); 5299 5300 if (found_key.objectid != key.objectid) 5301 break; 5302 if (btrfs_key_type(&found_key) != key_type) 5303 break; 5304 if (found_key.offset < ctx->pos) 5305 goto next; 5306 if (key_type == BTRFS_DIR_INDEX_KEY && 5307 btrfs_should_delete_dir_index(&del_list, 5308 found_key.offset)) 5309 goto next; 5310 5311 ctx->pos = found_key.offset; 5312 is_curr = 1; 5313 5314 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); 5315 di_cur = 0; 5316 di_total = btrfs_item_size(leaf, item); 5317 5318 while (di_cur < di_total) { 5319 struct btrfs_key location; 5320 5321 if (verify_dir_item(root, leaf, di)) 5322 break; 5323 5324 name_len = btrfs_dir_name_len(leaf, di); 5325 if (name_len <= sizeof(tmp_name)) { 5326 name_ptr = tmp_name; 5327 } else { 5328 name_ptr = kmalloc(name_len, GFP_NOFS); 5329 if (!name_ptr) { 5330 ret = -ENOMEM; 5331 goto err; 5332 } 5333 } 5334 read_extent_buffer(leaf, name_ptr, 5335 (unsigned long)(di + 1), name_len); 5336 5337 d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)]; 5338 btrfs_dir_item_key_to_cpu(leaf, di, &location); 5339 5340 5341 /* is this a reference to our own snapshot? If so 5342 * skip it. 5343 * 5344 * In contrast to old kernels, we insert the snapshot's 5345 * dir item and dir index after it has been created, so 5346 * we won't find a reference to our own snapshot. We 5347 * still keep the following code for backward 5348 * compatibility. 5349 */ 5350 if (location.type == BTRFS_ROOT_ITEM_KEY && 5351 location.objectid == root->root_key.objectid) { 5352 over = 0; 5353 goto skip; 5354 } 5355 over = !dir_emit(ctx, name_ptr, name_len, 5356 location.objectid, d_type); 5357 5358 skip: 5359 if (name_ptr != tmp_name) 5360 kfree(name_ptr); 5361 5362 if (over) 5363 goto nopos; 5364 di_len = btrfs_dir_name_len(leaf, di) + 5365 btrfs_dir_data_len(leaf, di) + sizeof(*di); 5366 di_cur += di_len; 5367 di = (struct btrfs_dir_item *)((char *)di + di_len); 5368 } 5369 next: 5370 path->slots[0]++; 5371 } 5372 5373 if (key_type == BTRFS_DIR_INDEX_KEY) { 5374 if (is_curr) 5375 ctx->pos++; 5376 ret = btrfs_readdir_delayed_dir_index(ctx, &ins_list); 5377 if (ret) 5378 goto nopos; 5379 } 5380 5381 /* Reached end of directory/root. Bump pos past the last item. */ 5382 ctx->pos++; 5383 5384 /* 5385 * Stop new entries from being returned after we return the last 5386 * entry. 5387 * 5388 * New directory entries are assigned a strictly increasing 5389 * offset. This means that new entries created during readdir 5390 * are *guaranteed* to be seen in the future by that readdir. 5391 * This has broken buggy programs which operate on names as 5392 * they're returned by readdir. Until we re-use freed offsets 5393 * we have this hack to stop new entries from being returned 5394 * under the assumption that they'll never reach this huge 5395 * offset. 5396 * 5397 * This is being careful not to overflow 32bit loff_t unless the 5398 * last entry requires it because doing so has broken 32bit apps 5399 * in the past. 5400 */ 5401 if (key_type == BTRFS_DIR_INDEX_KEY) { 5402 if (ctx->pos >= INT_MAX) 5403 ctx->pos = LLONG_MAX; 5404 else 5405 ctx->pos = INT_MAX; 5406 } 5407 nopos: 5408 ret = 0; 5409 err: 5410 if (key_type == BTRFS_DIR_INDEX_KEY) 5411 btrfs_put_delayed_items(&ins_list, &del_list); 5412 btrfs_free_path(path); 5413 return ret; 5414 } 5415 5416 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc) 5417 { 5418 struct btrfs_root *root = BTRFS_I(inode)->root; 5419 struct btrfs_trans_handle *trans; 5420 int ret = 0; 5421 bool nolock = false; 5422 5423 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags)) 5424 return 0; 5425 5426 if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode)) 5427 nolock = true; 5428 5429 if (wbc->sync_mode == WB_SYNC_ALL) { 5430 if (nolock) 5431 trans = btrfs_join_transaction_nolock(root); 5432 else 5433 trans = btrfs_join_transaction(root); 5434 if (IS_ERR(trans)) 5435 return PTR_ERR(trans); 5436 ret = btrfs_commit_transaction(trans, root); 5437 } 5438 return ret; 5439 } 5440 5441 /* 5442 * This is somewhat expensive, updating the tree every time the 5443 * inode changes. But, it is most likely to find the inode in cache. 5444 * FIXME, needs more benchmarking...there are no reasons other than performance 5445 * to keep or drop this code. 5446 */ 5447 static int btrfs_dirty_inode(struct inode *inode) 5448 { 5449 struct btrfs_root *root = BTRFS_I(inode)->root; 5450 struct btrfs_trans_handle *trans; 5451 int ret; 5452 5453 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags)) 5454 return 0; 5455 5456 trans = btrfs_join_transaction(root); 5457 if (IS_ERR(trans)) 5458 return PTR_ERR(trans); 5459 5460 ret = btrfs_update_inode(trans, root, inode); 5461 if (ret && ret == -ENOSPC) { 5462 /* whoops, lets try again with the full transaction */ 5463 btrfs_end_transaction(trans, root); 5464 trans = btrfs_start_transaction(root, 1); 5465 if (IS_ERR(trans)) 5466 return PTR_ERR(trans); 5467 5468 ret = btrfs_update_inode(trans, root, inode); 5469 } 5470 btrfs_end_transaction(trans, root); 5471 if (BTRFS_I(inode)->delayed_node) 5472 btrfs_balance_delayed_items(root); 5473 5474 return ret; 5475 } 5476 5477 /* 5478 * This is a copy of file_update_time. We need this so we can return error on 5479 * ENOSPC for updating the inode in the case of file write and mmap writes. 5480 */ 5481 static int btrfs_update_time(struct inode *inode, struct timespec *now, 5482 int flags) 5483 { 5484 struct btrfs_root *root = BTRFS_I(inode)->root; 5485 5486 if (btrfs_root_readonly(root)) 5487 return -EROFS; 5488 5489 if (flags & S_VERSION) 5490 inode_inc_iversion(inode); 5491 if (flags & S_CTIME) 5492 inode->i_ctime = *now; 5493 if (flags & S_MTIME) 5494 inode->i_mtime = *now; 5495 if (flags & S_ATIME) 5496 inode->i_atime = *now; 5497 return btrfs_dirty_inode(inode); 5498 } 5499 5500 /* 5501 * find the highest existing sequence number in a directory 5502 * and then set the in-memory index_cnt variable to reflect 5503 * free sequence numbers 5504 */ 5505 static int btrfs_set_inode_index_count(struct inode *inode) 5506 { 5507 struct btrfs_root *root = BTRFS_I(inode)->root; 5508 struct btrfs_key key, found_key; 5509 struct btrfs_path *path; 5510 struct extent_buffer *leaf; 5511 int ret; 5512 5513 key.objectid = btrfs_ino(inode); 5514 btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY); 5515 key.offset = (u64)-1; 5516 5517 path = btrfs_alloc_path(); 5518 if (!path) 5519 return -ENOMEM; 5520 5521 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 5522 if (ret < 0) 5523 goto out; 5524 /* FIXME: we should be able to handle this */ 5525 if (ret == 0) 5526 goto out; 5527 ret = 0; 5528 5529 /* 5530 * MAGIC NUMBER EXPLANATION: 5531 * since we search a directory based on f_pos we have to start at 2 5532 * since '.' and '..' have f_pos of 0 and 1 respectively, so everybody 5533 * else has to start at 2 5534 */ 5535 if (path->slots[0] == 0) { 5536 BTRFS_I(inode)->index_cnt = 2; 5537 goto out; 5538 } 5539 5540 path->slots[0]--; 5541 5542 leaf = path->nodes[0]; 5543 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 5544 5545 if (found_key.objectid != btrfs_ino(inode) || 5546 btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) { 5547 BTRFS_I(inode)->index_cnt = 2; 5548 goto out; 5549 } 5550 5551 BTRFS_I(inode)->index_cnt = found_key.offset + 1; 5552 out: 5553 btrfs_free_path(path); 5554 return ret; 5555 } 5556 5557 /* 5558 * helper to find a free sequence number in a given directory. This current 5559 * code is very simple, later versions will do smarter things in the btree 5560 */ 5561 int btrfs_set_inode_index(struct inode *dir, u64 *index) 5562 { 5563 int ret = 0; 5564 5565 if (BTRFS_I(dir)->index_cnt == (u64)-1) { 5566 ret = btrfs_inode_delayed_dir_index_count(dir); 5567 if (ret) { 5568 ret = btrfs_set_inode_index_count(dir); 5569 if (ret) 5570 return ret; 5571 } 5572 } 5573 5574 *index = BTRFS_I(dir)->index_cnt; 5575 BTRFS_I(dir)->index_cnt++; 5576 5577 return ret; 5578 } 5579 5580 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans, 5581 struct btrfs_root *root, 5582 struct inode *dir, 5583 const char *name, int name_len, 5584 u64 ref_objectid, u64 objectid, 5585 umode_t mode, u64 *index) 5586 { 5587 struct inode *inode; 5588 struct btrfs_inode_item *inode_item; 5589 struct btrfs_key *location; 5590 struct btrfs_path *path; 5591 struct btrfs_inode_ref *ref; 5592 struct btrfs_key key[2]; 5593 u32 sizes[2]; 5594 int nitems = name ? 2 : 1; 5595 unsigned long ptr; 5596 int ret; 5597 5598 path = btrfs_alloc_path(); 5599 if (!path) 5600 return ERR_PTR(-ENOMEM); 5601 5602 inode = new_inode(root->fs_info->sb); 5603 if (!inode) { 5604 btrfs_free_path(path); 5605 return ERR_PTR(-ENOMEM); 5606 } 5607 5608 /* 5609 * we have to initialize this early, so we can reclaim the inode 5610 * number if we fail afterwards in this function. 5611 */ 5612 inode->i_ino = objectid; 5613 5614 if (dir && name) { 5615 trace_btrfs_inode_request(dir); 5616 5617 ret = btrfs_set_inode_index(dir, index); 5618 if (ret) { 5619 btrfs_free_path(path); 5620 iput(inode); 5621 return ERR_PTR(ret); 5622 } 5623 } else if (dir) { 5624 *index = 0; 5625 } 5626 /* 5627 * index_cnt is ignored for everything but a dir, 5628 * btrfs_get_inode_index_count has an explanation for the magic 5629 * number 5630 */ 5631 BTRFS_I(inode)->index_cnt = 2; 5632 BTRFS_I(inode)->dir_index = *index; 5633 BTRFS_I(inode)->root = root; 5634 BTRFS_I(inode)->generation = trans->transid; 5635 inode->i_generation = BTRFS_I(inode)->generation; 5636 5637 /* 5638 * We could have gotten an inode number from somebody who was fsynced 5639 * and then removed in this same transaction, so let's just set full 5640 * sync since it will be a full sync anyway and this will blow away the 5641 * old info in the log. 5642 */ 5643 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags); 5644 5645 key[0].objectid = objectid; 5646 btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY); 5647 key[0].offset = 0; 5648 5649 sizes[0] = sizeof(struct btrfs_inode_item); 5650 5651 if (name) { 5652 /* 5653 * Start new inodes with an inode_ref. This is slightly more 5654 * efficient for small numbers of hard links since they will 5655 * be packed into one item. Extended refs will kick in if we 5656 * add more hard links than can fit in the ref item. 5657 */ 5658 key[1].objectid = objectid; 5659 btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY); 5660 key[1].offset = ref_objectid; 5661 5662 sizes[1] = name_len + sizeof(*ref); 5663 } 5664 5665 path->leave_spinning = 1; 5666 ret = btrfs_insert_empty_items(trans, root, path, key, sizes, nitems); 5667 if (ret != 0) 5668 goto fail; 5669 5670 inode_init_owner(inode, dir, mode); 5671 inode_set_bytes(inode, 0); 5672 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 5673 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0], 5674 struct btrfs_inode_item); 5675 memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item, 5676 sizeof(*inode_item)); 5677 fill_inode_item(trans, path->nodes[0], inode_item, inode); 5678 5679 if (name) { 5680 ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1, 5681 struct btrfs_inode_ref); 5682 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len); 5683 btrfs_set_inode_ref_index(path->nodes[0], ref, *index); 5684 ptr = (unsigned long)(ref + 1); 5685 write_extent_buffer(path->nodes[0], name, ptr, name_len); 5686 } 5687 5688 btrfs_mark_buffer_dirty(path->nodes[0]); 5689 btrfs_free_path(path); 5690 5691 location = &BTRFS_I(inode)->location; 5692 location->objectid = objectid; 5693 location->offset = 0; 5694 btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY); 5695 5696 btrfs_inherit_iflags(inode, dir); 5697 5698 if (S_ISREG(mode)) { 5699 if (btrfs_test_opt(root, NODATASUM)) 5700 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; 5701 if (btrfs_test_opt(root, NODATACOW)) 5702 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW | 5703 BTRFS_INODE_NODATASUM; 5704 } 5705 5706 btrfs_insert_inode_hash(inode); 5707 inode_tree_add(inode); 5708 5709 trace_btrfs_inode_new(inode); 5710 btrfs_set_inode_last_trans(trans, inode); 5711 5712 btrfs_update_root_times(trans, root); 5713 5714 ret = btrfs_inode_inherit_props(trans, inode, dir); 5715 if (ret) 5716 btrfs_err(root->fs_info, 5717 "error inheriting props for ino %llu (root %llu): %d", 5718 btrfs_ino(inode), root->root_key.objectid, ret); 5719 5720 return inode; 5721 fail: 5722 if (dir && name) 5723 BTRFS_I(dir)->index_cnt--; 5724 btrfs_free_path(path); 5725 iput(inode); 5726 return ERR_PTR(ret); 5727 } 5728 5729 static inline u8 btrfs_inode_type(struct inode *inode) 5730 { 5731 return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT]; 5732 } 5733 5734 /* 5735 * utility function to add 'inode' into 'parent_inode' with 5736 * a give name and a given sequence number. 5737 * if 'add_backref' is true, also insert a backref from the 5738 * inode to the parent directory. 5739 */ 5740 int btrfs_add_link(struct btrfs_trans_handle *trans, 5741 struct inode *parent_inode, struct inode *inode, 5742 const char *name, int name_len, int add_backref, u64 index) 5743 { 5744 int ret = 0; 5745 struct btrfs_key key; 5746 struct btrfs_root *root = BTRFS_I(parent_inode)->root; 5747 u64 ino = btrfs_ino(inode); 5748 u64 parent_ino = btrfs_ino(parent_inode); 5749 5750 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) { 5751 memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key)); 5752 } else { 5753 key.objectid = ino; 5754 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY); 5755 key.offset = 0; 5756 } 5757 5758 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) { 5759 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root, 5760 key.objectid, root->root_key.objectid, 5761 parent_ino, index, name, name_len); 5762 } else if (add_backref) { 5763 ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino, 5764 parent_ino, index); 5765 } 5766 5767 /* Nothing to clean up yet */ 5768 if (ret) 5769 return ret; 5770 5771 ret = btrfs_insert_dir_item(trans, root, name, name_len, 5772 parent_inode, &key, 5773 btrfs_inode_type(inode), index); 5774 if (ret == -EEXIST || ret == -EOVERFLOW) 5775 goto fail_dir_item; 5776 else if (ret) { 5777 btrfs_abort_transaction(trans, root, ret); 5778 return ret; 5779 } 5780 5781 btrfs_i_size_write(parent_inode, parent_inode->i_size + 5782 name_len * 2); 5783 inode_inc_iversion(parent_inode); 5784 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; 5785 ret = btrfs_update_inode(trans, root, parent_inode); 5786 if (ret) 5787 btrfs_abort_transaction(trans, root, ret); 5788 return ret; 5789 5790 fail_dir_item: 5791 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) { 5792 u64 local_index; 5793 int err; 5794 err = btrfs_del_root_ref(trans, root->fs_info->tree_root, 5795 key.objectid, root->root_key.objectid, 5796 parent_ino, &local_index, name, name_len); 5797 5798 } else if (add_backref) { 5799 u64 local_index; 5800 int err; 5801 5802 err = btrfs_del_inode_ref(trans, root, name, name_len, 5803 ino, parent_ino, &local_index); 5804 } 5805 return ret; 5806 } 5807 5808 static int btrfs_add_nondir(struct btrfs_trans_handle *trans, 5809 struct inode *dir, struct dentry *dentry, 5810 struct inode *inode, int backref, u64 index) 5811 { 5812 int err = btrfs_add_link(trans, dir, inode, 5813 dentry->d_name.name, dentry->d_name.len, 5814 backref, index); 5815 if (err > 0) 5816 err = -EEXIST; 5817 return err; 5818 } 5819 5820 static int btrfs_mknod(struct inode *dir, struct dentry *dentry, 5821 umode_t mode, dev_t rdev) 5822 { 5823 struct btrfs_trans_handle *trans; 5824 struct btrfs_root *root = BTRFS_I(dir)->root; 5825 struct inode *inode = NULL; 5826 int err; 5827 int drop_inode = 0; 5828 u64 objectid; 5829 u64 index = 0; 5830 5831 if (!new_valid_dev(rdev)) 5832 return -EINVAL; 5833 5834 /* 5835 * 2 for inode item and ref 5836 * 2 for dir items 5837 * 1 for xattr if selinux is on 5838 */ 5839 trans = btrfs_start_transaction(root, 5); 5840 if (IS_ERR(trans)) 5841 return PTR_ERR(trans); 5842 5843 err = btrfs_find_free_ino(root, &objectid); 5844 if (err) 5845 goto out_unlock; 5846 5847 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name, 5848 dentry->d_name.len, btrfs_ino(dir), objectid, 5849 mode, &index); 5850 if (IS_ERR(inode)) { 5851 err = PTR_ERR(inode); 5852 goto out_unlock; 5853 } 5854 5855 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); 5856 if (err) { 5857 drop_inode = 1; 5858 goto out_unlock; 5859 } 5860 5861 /* 5862 * If the active LSM wants to access the inode during 5863 * d_instantiate it needs these. Smack checks to see 5864 * if the filesystem supports xattrs by looking at the 5865 * ops vector. 5866 */ 5867 5868 inode->i_op = &btrfs_special_inode_operations; 5869 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 5870 if (err) 5871 drop_inode = 1; 5872 else { 5873 init_special_inode(inode, inode->i_mode, rdev); 5874 btrfs_update_inode(trans, root, inode); 5875 d_instantiate(dentry, inode); 5876 } 5877 out_unlock: 5878 btrfs_end_transaction(trans, root); 5879 btrfs_balance_delayed_items(root); 5880 btrfs_btree_balance_dirty(root); 5881 if (drop_inode) { 5882 inode_dec_link_count(inode); 5883 iput(inode); 5884 } 5885 return err; 5886 } 5887 5888 static int btrfs_create(struct inode *dir, struct dentry *dentry, 5889 umode_t mode, bool excl) 5890 { 5891 struct btrfs_trans_handle *trans; 5892 struct btrfs_root *root = BTRFS_I(dir)->root; 5893 struct inode *inode = NULL; 5894 int drop_inode_on_err = 0; 5895 int err; 5896 u64 objectid; 5897 u64 index = 0; 5898 5899 /* 5900 * 2 for inode item and ref 5901 * 2 for dir items 5902 * 1 for xattr if selinux is on 5903 */ 5904 trans = btrfs_start_transaction(root, 5); 5905 if (IS_ERR(trans)) 5906 return PTR_ERR(trans); 5907 5908 err = btrfs_find_free_ino(root, &objectid); 5909 if (err) 5910 goto out_unlock; 5911 5912 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name, 5913 dentry->d_name.len, btrfs_ino(dir), objectid, 5914 mode, &index); 5915 if (IS_ERR(inode)) { 5916 err = PTR_ERR(inode); 5917 goto out_unlock; 5918 } 5919 drop_inode_on_err = 1; 5920 5921 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); 5922 if (err) 5923 goto out_unlock; 5924 5925 err = btrfs_update_inode(trans, root, inode); 5926 if (err) 5927 goto out_unlock; 5928 5929 /* 5930 * If the active LSM wants to access the inode during 5931 * d_instantiate it needs these. Smack checks to see 5932 * if the filesystem supports xattrs by looking at the 5933 * ops vector. 5934 */ 5935 inode->i_fop = &btrfs_file_operations; 5936 inode->i_op = &btrfs_file_inode_operations; 5937 5938 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 5939 if (err) 5940 goto out_unlock; 5941 5942 inode->i_mapping->a_ops = &btrfs_aops; 5943 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 5944 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops; 5945 d_instantiate(dentry, inode); 5946 5947 out_unlock: 5948 btrfs_end_transaction(trans, root); 5949 if (err && drop_inode_on_err) { 5950 inode_dec_link_count(inode); 5951 iput(inode); 5952 } 5953 btrfs_balance_delayed_items(root); 5954 btrfs_btree_balance_dirty(root); 5955 return err; 5956 } 5957 5958 static int btrfs_link(struct dentry *old_dentry, struct inode *dir, 5959 struct dentry *dentry) 5960 { 5961 struct btrfs_trans_handle *trans; 5962 struct btrfs_root *root = BTRFS_I(dir)->root; 5963 struct inode *inode = old_dentry->d_inode; 5964 u64 index; 5965 int err; 5966 int drop_inode = 0; 5967 5968 /* do not allow sys_link's with other subvols of the same device */ 5969 if (root->objectid != BTRFS_I(inode)->root->objectid) 5970 return -EXDEV; 5971 5972 if (inode->i_nlink >= BTRFS_LINK_MAX) 5973 return -EMLINK; 5974 5975 err = btrfs_set_inode_index(dir, &index); 5976 if (err) 5977 goto fail; 5978 5979 /* 5980 * 2 items for inode and inode ref 5981 * 2 items for dir items 5982 * 1 item for parent inode 5983 */ 5984 trans = btrfs_start_transaction(root, 5); 5985 if (IS_ERR(trans)) { 5986 err = PTR_ERR(trans); 5987 goto fail; 5988 } 5989 5990 /* There are several dir indexes for this inode, clear the cache. */ 5991 BTRFS_I(inode)->dir_index = 0ULL; 5992 inc_nlink(inode); 5993 inode_inc_iversion(inode); 5994 inode->i_ctime = CURRENT_TIME; 5995 ihold(inode); 5996 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags); 5997 5998 err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index); 5999 6000 if (err) { 6001 drop_inode = 1; 6002 } else { 6003 struct dentry *parent = dentry->d_parent; 6004 err = btrfs_update_inode(trans, root, inode); 6005 if (err) 6006 goto fail; 6007 if (inode->i_nlink == 1) { 6008 /* 6009 * If new hard link count is 1, it's a file created 6010 * with open(2) O_TMPFILE flag. 6011 */ 6012 err = btrfs_orphan_del(trans, inode); 6013 if (err) 6014 goto fail; 6015 } 6016 d_instantiate(dentry, inode); 6017 btrfs_log_new_name(trans, inode, NULL, parent); 6018 } 6019 6020 btrfs_end_transaction(trans, root); 6021 btrfs_balance_delayed_items(root); 6022 fail: 6023 if (drop_inode) { 6024 inode_dec_link_count(inode); 6025 iput(inode); 6026 } 6027 btrfs_btree_balance_dirty(root); 6028 return err; 6029 } 6030 6031 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 6032 { 6033 struct inode *inode = NULL; 6034 struct btrfs_trans_handle *trans; 6035 struct btrfs_root *root = BTRFS_I(dir)->root; 6036 int err = 0; 6037 int drop_on_err = 0; 6038 u64 objectid = 0; 6039 u64 index = 0; 6040 6041 /* 6042 * 2 items for inode and ref 6043 * 2 items for dir items 6044 * 1 for xattr if selinux is on 6045 */ 6046 trans = btrfs_start_transaction(root, 5); 6047 if (IS_ERR(trans)) 6048 return PTR_ERR(trans); 6049 6050 err = btrfs_find_free_ino(root, &objectid); 6051 if (err) 6052 goto out_fail; 6053 6054 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name, 6055 dentry->d_name.len, btrfs_ino(dir), objectid, 6056 S_IFDIR | mode, &index); 6057 if (IS_ERR(inode)) { 6058 err = PTR_ERR(inode); 6059 goto out_fail; 6060 } 6061 6062 drop_on_err = 1; 6063 6064 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); 6065 if (err) 6066 goto out_fail; 6067 6068 inode->i_op = &btrfs_dir_inode_operations; 6069 inode->i_fop = &btrfs_dir_file_operations; 6070 6071 btrfs_i_size_write(inode, 0); 6072 err = btrfs_update_inode(trans, root, inode); 6073 if (err) 6074 goto out_fail; 6075 6076 err = btrfs_add_link(trans, dir, inode, dentry->d_name.name, 6077 dentry->d_name.len, 0, index); 6078 if (err) 6079 goto out_fail; 6080 6081 d_instantiate(dentry, inode); 6082 drop_on_err = 0; 6083 6084 out_fail: 6085 btrfs_end_transaction(trans, root); 6086 if (drop_on_err) 6087 iput(inode); 6088 btrfs_balance_delayed_items(root); 6089 btrfs_btree_balance_dirty(root); 6090 return err; 6091 } 6092 6093 /* helper for btfs_get_extent. Given an existing extent in the tree, 6094 * and an extent that you want to insert, deal with overlap and insert 6095 * the new extent into the tree. 6096 */ 6097 static int merge_extent_mapping(struct extent_map_tree *em_tree, 6098 struct extent_map *existing, 6099 struct extent_map *em, 6100 u64 map_start, u64 map_len) 6101 { 6102 u64 start_diff; 6103 6104 BUG_ON(map_start < em->start || map_start >= extent_map_end(em)); 6105 start_diff = map_start - em->start; 6106 em->start = map_start; 6107 em->len = map_len; 6108 if (em->block_start < EXTENT_MAP_LAST_BYTE && 6109 !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { 6110 em->block_start += start_diff; 6111 em->block_len -= start_diff; 6112 } 6113 return add_extent_mapping(em_tree, em, 0); 6114 } 6115 6116 static noinline int uncompress_inline(struct btrfs_path *path, 6117 struct inode *inode, struct page *page, 6118 size_t pg_offset, u64 extent_offset, 6119 struct btrfs_file_extent_item *item) 6120 { 6121 int ret; 6122 struct extent_buffer *leaf = path->nodes[0]; 6123 char *tmp; 6124 size_t max_size; 6125 unsigned long inline_size; 6126 unsigned long ptr; 6127 int compress_type; 6128 6129 WARN_ON(pg_offset != 0); 6130 compress_type = btrfs_file_extent_compression(leaf, item); 6131 max_size = btrfs_file_extent_ram_bytes(leaf, item); 6132 inline_size = btrfs_file_extent_inline_item_len(leaf, 6133 btrfs_item_nr(path->slots[0])); 6134 tmp = kmalloc(inline_size, GFP_NOFS); 6135 if (!tmp) 6136 return -ENOMEM; 6137 ptr = btrfs_file_extent_inline_start(item); 6138 6139 read_extent_buffer(leaf, tmp, ptr, inline_size); 6140 6141 max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size); 6142 ret = btrfs_decompress(compress_type, tmp, page, 6143 extent_offset, inline_size, max_size); 6144 kfree(tmp); 6145 return ret; 6146 } 6147 6148 /* 6149 * a bit scary, this does extent mapping from logical file offset to the disk. 6150 * the ugly parts come from merging extents from the disk with the in-ram 6151 * representation. This gets more complex because of the data=ordered code, 6152 * where the in-ram extents might be locked pending data=ordered completion. 6153 * 6154 * This also copies inline extents directly into the page. 6155 */ 6156 6157 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 6158 size_t pg_offset, u64 start, u64 len, 6159 int create) 6160 { 6161 int ret; 6162 int err = 0; 6163 u64 extent_start = 0; 6164 u64 extent_end = 0; 6165 u64 objectid = btrfs_ino(inode); 6166 u32 found_type; 6167 struct btrfs_path *path = NULL; 6168 struct btrfs_root *root = BTRFS_I(inode)->root; 6169 struct btrfs_file_extent_item *item; 6170 struct extent_buffer *leaf; 6171 struct btrfs_key found_key; 6172 struct extent_map *em = NULL; 6173 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 6174 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 6175 struct btrfs_trans_handle *trans = NULL; 6176 const bool new_inline = !page || create; 6177 6178 again: 6179 read_lock(&em_tree->lock); 6180 em = lookup_extent_mapping(em_tree, start, len); 6181 if (em) 6182 em->bdev = root->fs_info->fs_devices->latest_bdev; 6183 read_unlock(&em_tree->lock); 6184 6185 if (em) { 6186 if (em->start > start || em->start + em->len <= start) 6187 free_extent_map(em); 6188 else if (em->block_start == EXTENT_MAP_INLINE && page) 6189 free_extent_map(em); 6190 else 6191 goto out; 6192 } 6193 em = alloc_extent_map(); 6194 if (!em) { 6195 err = -ENOMEM; 6196 goto out; 6197 } 6198 em->bdev = root->fs_info->fs_devices->latest_bdev; 6199 em->start = EXTENT_MAP_HOLE; 6200 em->orig_start = EXTENT_MAP_HOLE; 6201 em->len = (u64)-1; 6202 em->block_len = (u64)-1; 6203 6204 if (!path) { 6205 path = btrfs_alloc_path(); 6206 if (!path) { 6207 err = -ENOMEM; 6208 goto out; 6209 } 6210 /* 6211 * Chances are we'll be called again, so go ahead and do 6212 * readahead 6213 */ 6214 path->reada = 1; 6215 } 6216 6217 ret = btrfs_lookup_file_extent(trans, root, path, 6218 objectid, start, trans != NULL); 6219 if (ret < 0) { 6220 err = ret; 6221 goto out; 6222 } 6223 6224 if (ret != 0) { 6225 if (path->slots[0] == 0) 6226 goto not_found; 6227 path->slots[0]--; 6228 } 6229 6230 leaf = path->nodes[0]; 6231 item = btrfs_item_ptr(leaf, path->slots[0], 6232 struct btrfs_file_extent_item); 6233 /* are we inside the extent that was found? */ 6234 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 6235 found_type = btrfs_key_type(&found_key); 6236 if (found_key.objectid != objectid || 6237 found_type != BTRFS_EXTENT_DATA_KEY) { 6238 /* 6239 * If we backup past the first extent we want to move forward 6240 * and see if there is an extent in front of us, otherwise we'll 6241 * say there is a hole for our whole search range which can 6242 * cause problems. 6243 */ 6244 extent_end = start; 6245 goto next; 6246 } 6247 6248 found_type = btrfs_file_extent_type(leaf, item); 6249 extent_start = found_key.offset; 6250 if (found_type == BTRFS_FILE_EXTENT_REG || 6251 found_type == BTRFS_FILE_EXTENT_PREALLOC) { 6252 extent_end = extent_start + 6253 btrfs_file_extent_num_bytes(leaf, item); 6254 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) { 6255 size_t size; 6256 size = btrfs_file_extent_inline_len(leaf, path->slots[0], item); 6257 extent_end = ALIGN(extent_start + size, root->sectorsize); 6258 } 6259 next: 6260 if (start >= extent_end) { 6261 path->slots[0]++; 6262 if (path->slots[0] >= btrfs_header_nritems(leaf)) { 6263 ret = btrfs_next_leaf(root, path); 6264 if (ret < 0) { 6265 err = ret; 6266 goto out; 6267 } 6268 if (ret > 0) 6269 goto not_found; 6270 leaf = path->nodes[0]; 6271 } 6272 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 6273 if (found_key.objectid != objectid || 6274 found_key.type != BTRFS_EXTENT_DATA_KEY) 6275 goto not_found; 6276 if (start + len <= found_key.offset) 6277 goto not_found; 6278 em->start = start; 6279 em->orig_start = start; 6280 em->len = found_key.offset - start; 6281 goto not_found_em; 6282 } 6283 6284 btrfs_extent_item_to_extent_map(inode, path, item, new_inline, em); 6285 6286 if (found_type == BTRFS_FILE_EXTENT_REG || 6287 found_type == BTRFS_FILE_EXTENT_PREALLOC) { 6288 goto insert; 6289 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) { 6290 unsigned long ptr; 6291 char *map; 6292 size_t size; 6293 size_t extent_offset; 6294 size_t copy_size; 6295 6296 if (new_inline) 6297 goto out; 6298 6299 size = btrfs_file_extent_inline_len(leaf, path->slots[0], item); 6300 extent_offset = page_offset(page) + pg_offset - extent_start; 6301 copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset, 6302 size - extent_offset); 6303 em->start = extent_start + extent_offset; 6304 em->len = ALIGN(copy_size, root->sectorsize); 6305 em->orig_block_len = em->len; 6306 em->orig_start = em->start; 6307 ptr = btrfs_file_extent_inline_start(item) + extent_offset; 6308 if (create == 0 && !PageUptodate(page)) { 6309 if (btrfs_file_extent_compression(leaf, item) != 6310 BTRFS_COMPRESS_NONE) { 6311 ret = uncompress_inline(path, inode, page, 6312 pg_offset, 6313 extent_offset, item); 6314 if (ret) { 6315 err = ret; 6316 goto out; 6317 } 6318 } else { 6319 map = kmap(page); 6320 read_extent_buffer(leaf, map + pg_offset, ptr, 6321 copy_size); 6322 if (pg_offset + copy_size < PAGE_CACHE_SIZE) { 6323 memset(map + pg_offset + copy_size, 0, 6324 PAGE_CACHE_SIZE - pg_offset - 6325 copy_size); 6326 } 6327 kunmap(page); 6328 } 6329 flush_dcache_page(page); 6330 } else if (create && PageUptodate(page)) { 6331 BUG(); 6332 if (!trans) { 6333 kunmap(page); 6334 free_extent_map(em); 6335 em = NULL; 6336 6337 btrfs_release_path(path); 6338 trans = btrfs_join_transaction(root); 6339 6340 if (IS_ERR(trans)) 6341 return ERR_CAST(trans); 6342 goto again; 6343 } 6344 map = kmap(page); 6345 write_extent_buffer(leaf, map + pg_offset, ptr, 6346 copy_size); 6347 kunmap(page); 6348 btrfs_mark_buffer_dirty(leaf); 6349 } 6350 set_extent_uptodate(io_tree, em->start, 6351 extent_map_end(em) - 1, NULL, GFP_NOFS); 6352 goto insert; 6353 } 6354 not_found: 6355 em->start = start; 6356 em->orig_start = start; 6357 em->len = len; 6358 not_found_em: 6359 em->block_start = EXTENT_MAP_HOLE; 6360 set_bit(EXTENT_FLAG_VACANCY, &em->flags); 6361 insert: 6362 btrfs_release_path(path); 6363 if (em->start > start || extent_map_end(em) <= start) { 6364 btrfs_err(root->fs_info, "bad extent! em: [%llu %llu] passed [%llu %llu]", 6365 em->start, em->len, start, len); 6366 err = -EIO; 6367 goto out; 6368 } 6369 6370 err = 0; 6371 write_lock(&em_tree->lock); 6372 ret = add_extent_mapping(em_tree, em, 0); 6373 /* it is possible that someone inserted the extent into the tree 6374 * while we had the lock dropped. It is also possible that 6375 * an overlapping map exists in the tree 6376 */ 6377 if (ret == -EEXIST) { 6378 struct extent_map *existing; 6379 6380 ret = 0; 6381 6382 existing = lookup_extent_mapping(em_tree, start, len); 6383 if (existing && (existing->start > start || 6384 existing->start + existing->len <= start)) { 6385 free_extent_map(existing); 6386 existing = NULL; 6387 } 6388 if (!existing) { 6389 existing = lookup_extent_mapping(em_tree, em->start, 6390 em->len); 6391 if (existing) { 6392 err = merge_extent_mapping(em_tree, existing, 6393 em, start, 6394 root->sectorsize); 6395 free_extent_map(existing); 6396 if (err) { 6397 free_extent_map(em); 6398 em = NULL; 6399 } 6400 } else { 6401 err = -EIO; 6402 free_extent_map(em); 6403 em = NULL; 6404 } 6405 } else { 6406 free_extent_map(em); 6407 em = existing; 6408 err = 0; 6409 } 6410 } 6411 write_unlock(&em_tree->lock); 6412 out: 6413 6414 trace_btrfs_get_extent(root, em); 6415 6416 if (path) 6417 btrfs_free_path(path); 6418 if (trans) { 6419 ret = btrfs_end_transaction(trans, root); 6420 if (!err) 6421 err = ret; 6422 } 6423 if (err) { 6424 free_extent_map(em); 6425 return ERR_PTR(err); 6426 } 6427 BUG_ON(!em); /* Error is always set */ 6428 return em; 6429 } 6430 6431 struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page, 6432 size_t pg_offset, u64 start, u64 len, 6433 int create) 6434 { 6435 struct extent_map *em; 6436 struct extent_map *hole_em = NULL; 6437 u64 range_start = start; 6438 u64 end; 6439 u64 found; 6440 u64 found_end; 6441 int err = 0; 6442 6443 em = btrfs_get_extent(inode, page, pg_offset, start, len, create); 6444 if (IS_ERR(em)) 6445 return em; 6446 if (em) { 6447 /* 6448 * if our em maps to 6449 * - a hole or 6450 * - a pre-alloc extent, 6451 * there might actually be delalloc bytes behind it. 6452 */ 6453 if (em->block_start != EXTENT_MAP_HOLE && 6454 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) 6455 return em; 6456 else 6457 hole_em = em; 6458 } 6459 6460 /* check to see if we've wrapped (len == -1 or similar) */ 6461 end = start + len; 6462 if (end < start) 6463 end = (u64)-1; 6464 else 6465 end -= 1; 6466 6467 em = NULL; 6468 6469 /* ok, we didn't find anything, lets look for delalloc */ 6470 found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start, 6471 end, len, EXTENT_DELALLOC, 1); 6472 found_end = range_start + found; 6473 if (found_end < range_start) 6474 found_end = (u64)-1; 6475 6476 /* 6477 * we didn't find anything useful, return 6478 * the original results from get_extent() 6479 */ 6480 if (range_start > end || found_end <= start) { 6481 em = hole_em; 6482 hole_em = NULL; 6483 goto out; 6484 } 6485 6486 /* adjust the range_start to make sure it doesn't 6487 * go backwards from the start they passed in 6488 */ 6489 range_start = max(start, range_start); 6490 found = found_end - range_start; 6491 6492 if (found > 0) { 6493 u64 hole_start = start; 6494 u64 hole_len = len; 6495 6496 em = alloc_extent_map(); 6497 if (!em) { 6498 err = -ENOMEM; 6499 goto out; 6500 } 6501 /* 6502 * when btrfs_get_extent can't find anything it 6503 * returns one huge hole 6504 * 6505 * make sure what it found really fits our range, and 6506 * adjust to make sure it is based on the start from 6507 * the caller 6508 */ 6509 if (hole_em) { 6510 u64 calc_end = extent_map_end(hole_em); 6511 6512 if (calc_end <= start || (hole_em->start > end)) { 6513 free_extent_map(hole_em); 6514 hole_em = NULL; 6515 } else { 6516 hole_start = max(hole_em->start, start); 6517 hole_len = calc_end - hole_start; 6518 } 6519 } 6520 em->bdev = NULL; 6521 if (hole_em && range_start > hole_start) { 6522 /* our hole starts before our delalloc, so we 6523 * have to return just the parts of the hole 6524 * that go until the delalloc starts 6525 */ 6526 em->len = min(hole_len, 6527 range_start - hole_start); 6528 em->start = hole_start; 6529 em->orig_start = hole_start; 6530 /* 6531 * don't adjust block start at all, 6532 * it is fixed at EXTENT_MAP_HOLE 6533 */ 6534 em->block_start = hole_em->block_start; 6535 em->block_len = hole_len; 6536 if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags)) 6537 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 6538 } else { 6539 em->start = range_start; 6540 em->len = found; 6541 em->orig_start = range_start; 6542 em->block_start = EXTENT_MAP_DELALLOC; 6543 em->block_len = found; 6544 } 6545 } else if (hole_em) { 6546 return hole_em; 6547 } 6548 out: 6549 6550 free_extent_map(hole_em); 6551 if (err) { 6552 free_extent_map(em); 6553 return ERR_PTR(err); 6554 } 6555 return em; 6556 } 6557 6558 static struct extent_map *btrfs_new_extent_direct(struct inode *inode, 6559 u64 start, u64 len) 6560 { 6561 struct btrfs_root *root = BTRFS_I(inode)->root; 6562 struct extent_map *em; 6563 struct btrfs_key ins; 6564 u64 alloc_hint; 6565 int ret; 6566 6567 alloc_hint = get_extent_allocation_hint(inode, start, len); 6568 ret = btrfs_reserve_extent(root, len, root->sectorsize, 0, 6569 alloc_hint, &ins, 1, 1); 6570 if (ret) 6571 return ERR_PTR(ret); 6572 6573 em = create_pinned_em(inode, start, ins.offset, start, ins.objectid, 6574 ins.offset, ins.offset, ins.offset, 0); 6575 if (IS_ERR(em)) { 6576 btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1); 6577 return em; 6578 } 6579 6580 ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid, 6581 ins.offset, ins.offset, 0); 6582 if (ret) { 6583 btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1); 6584 free_extent_map(em); 6585 return ERR_PTR(ret); 6586 } 6587 6588 return em; 6589 } 6590 6591 /* 6592 * returns 1 when the nocow is safe, < 1 on error, 0 if the 6593 * block must be cow'd 6594 */ 6595 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, 6596 u64 *orig_start, u64 *orig_block_len, 6597 u64 *ram_bytes) 6598 { 6599 struct btrfs_trans_handle *trans; 6600 struct btrfs_path *path; 6601 int ret; 6602 struct extent_buffer *leaf; 6603 struct btrfs_root *root = BTRFS_I(inode)->root; 6604 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 6605 struct btrfs_file_extent_item *fi; 6606 struct btrfs_key key; 6607 u64 disk_bytenr; 6608 u64 backref_offset; 6609 u64 extent_end; 6610 u64 num_bytes; 6611 int slot; 6612 int found_type; 6613 bool nocow = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW); 6614 6615 path = btrfs_alloc_path(); 6616 if (!path) 6617 return -ENOMEM; 6618 6619 ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(inode), 6620 offset, 0); 6621 if (ret < 0) 6622 goto out; 6623 6624 slot = path->slots[0]; 6625 if (ret == 1) { 6626 if (slot == 0) { 6627 /* can't find the item, must cow */ 6628 ret = 0; 6629 goto out; 6630 } 6631 slot--; 6632 } 6633 ret = 0; 6634 leaf = path->nodes[0]; 6635 btrfs_item_key_to_cpu(leaf, &key, slot); 6636 if (key.objectid != btrfs_ino(inode) || 6637 key.type != BTRFS_EXTENT_DATA_KEY) { 6638 /* not our file or wrong item type, must cow */ 6639 goto out; 6640 } 6641 6642 if (key.offset > offset) { 6643 /* Wrong offset, must cow */ 6644 goto out; 6645 } 6646 6647 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); 6648 found_type = btrfs_file_extent_type(leaf, fi); 6649 if (found_type != BTRFS_FILE_EXTENT_REG && 6650 found_type != BTRFS_FILE_EXTENT_PREALLOC) { 6651 /* not a regular extent, must cow */ 6652 goto out; 6653 } 6654 6655 if (!nocow && found_type == BTRFS_FILE_EXTENT_REG) 6656 goto out; 6657 6658 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi); 6659 if (extent_end <= offset) 6660 goto out; 6661 6662 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 6663 if (disk_bytenr == 0) 6664 goto out; 6665 6666 if (btrfs_file_extent_compression(leaf, fi) || 6667 btrfs_file_extent_encryption(leaf, fi) || 6668 btrfs_file_extent_other_encoding(leaf, fi)) 6669 goto out; 6670 6671 backref_offset = btrfs_file_extent_offset(leaf, fi); 6672 6673 if (orig_start) { 6674 *orig_start = key.offset - backref_offset; 6675 *orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi); 6676 *ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi); 6677 } 6678 6679 if (btrfs_extent_readonly(root, disk_bytenr)) 6680 goto out; 6681 6682 num_bytes = min(offset + *len, extent_end) - offset; 6683 if (!nocow && found_type == BTRFS_FILE_EXTENT_PREALLOC) { 6684 u64 range_end; 6685 6686 range_end = round_up(offset + num_bytes, root->sectorsize) - 1; 6687 ret = test_range_bit(io_tree, offset, range_end, 6688 EXTENT_DELALLOC, 0, NULL); 6689 if (ret) { 6690 ret = -EAGAIN; 6691 goto out; 6692 } 6693 } 6694 6695 btrfs_release_path(path); 6696 6697 /* 6698 * look for other files referencing this extent, if we 6699 * find any we must cow 6700 */ 6701 trans = btrfs_join_transaction(root); 6702 if (IS_ERR(trans)) { 6703 ret = 0; 6704 goto out; 6705 } 6706 6707 ret = btrfs_cross_ref_exist(trans, root, btrfs_ino(inode), 6708 key.offset - backref_offset, disk_bytenr); 6709 btrfs_end_transaction(trans, root); 6710 if (ret) { 6711 ret = 0; 6712 goto out; 6713 } 6714 6715 /* 6716 * adjust disk_bytenr and num_bytes to cover just the bytes 6717 * in this extent we are about to write. If there 6718 * are any csums in that range we have to cow in order 6719 * to keep the csums correct 6720 */ 6721 disk_bytenr += backref_offset; 6722 disk_bytenr += offset - key.offset; 6723 if (csum_exist_in_range(root, disk_bytenr, num_bytes)) 6724 goto out; 6725 /* 6726 * all of the above have passed, it is safe to overwrite this extent 6727 * without cow 6728 */ 6729 *len = num_bytes; 6730 ret = 1; 6731 out: 6732 btrfs_free_path(path); 6733 return ret; 6734 } 6735 6736 bool btrfs_page_exists_in_range(struct inode *inode, loff_t start, loff_t end) 6737 { 6738 struct radix_tree_root *root = &inode->i_mapping->page_tree; 6739 int found = false; 6740 void **pagep = NULL; 6741 struct page *page = NULL; 6742 int start_idx; 6743 int end_idx; 6744 6745 start_idx = start >> PAGE_CACHE_SHIFT; 6746 6747 /* 6748 * end is the last byte in the last page. end == start is legal 6749 */ 6750 end_idx = end >> PAGE_CACHE_SHIFT; 6751 6752 rcu_read_lock(); 6753 6754 /* Most of the code in this while loop is lifted from 6755 * find_get_page. It's been modified to begin searching from a 6756 * page and return just the first page found in that range. If the 6757 * found idx is less than or equal to the end idx then we know that 6758 * a page exists. If no pages are found or if those pages are 6759 * outside of the range then we're fine (yay!) */ 6760 while (page == NULL && 6761 radix_tree_gang_lookup_slot(root, &pagep, NULL, start_idx, 1)) { 6762 page = radix_tree_deref_slot(pagep); 6763 if (unlikely(!page)) 6764 break; 6765 6766 if (radix_tree_exception(page)) { 6767 if (radix_tree_deref_retry(page)) { 6768 page = NULL; 6769 continue; 6770 } 6771 /* 6772 * Otherwise, shmem/tmpfs must be storing a swap entry 6773 * here as an exceptional entry: so return it without 6774 * attempting to raise page count. 6775 */ 6776 page = NULL; 6777 break; /* TODO: Is this relevant for this use case? */ 6778 } 6779 6780 if (!page_cache_get_speculative(page)) { 6781 page = NULL; 6782 continue; 6783 } 6784 6785 /* 6786 * Has the page moved? 6787 * This is part of the lockless pagecache protocol. See 6788 * include/linux/pagemap.h for details. 6789 */ 6790 if (unlikely(page != *pagep)) { 6791 page_cache_release(page); 6792 page = NULL; 6793 } 6794 } 6795 6796 if (page) { 6797 if (page->index <= end_idx) 6798 found = true; 6799 page_cache_release(page); 6800 } 6801 6802 rcu_read_unlock(); 6803 return found; 6804 } 6805 6806 static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend, 6807 struct extent_state **cached_state, int writing) 6808 { 6809 struct btrfs_ordered_extent *ordered; 6810 int ret = 0; 6811 6812 while (1) { 6813 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, 6814 0, cached_state); 6815 /* 6816 * We're concerned with the entire range that we're going to be 6817 * doing DIO to, so we need to make sure theres no ordered 6818 * extents in this range. 6819 */ 6820 ordered = btrfs_lookup_ordered_range(inode, lockstart, 6821 lockend - lockstart + 1); 6822 6823 /* 6824 * We need to make sure there are no buffered pages in this 6825 * range either, we could have raced between the invalidate in 6826 * generic_file_direct_write and locking the extent. The 6827 * invalidate needs to happen so that reads after a write do not 6828 * get stale data. 6829 */ 6830 if (!ordered && 6831 (!writing || 6832 !btrfs_page_exists_in_range(inode, lockstart, lockend))) 6833 break; 6834 6835 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend, 6836 cached_state, GFP_NOFS); 6837 6838 if (ordered) { 6839 btrfs_start_ordered_extent(inode, ordered, 1); 6840 btrfs_put_ordered_extent(ordered); 6841 } else { 6842 /* Screw you mmap */ 6843 ret = filemap_write_and_wait_range(inode->i_mapping, 6844 lockstart, 6845 lockend); 6846 if (ret) 6847 break; 6848 6849 /* 6850 * If we found a page that couldn't be invalidated just 6851 * fall back to buffered. 6852 */ 6853 ret = invalidate_inode_pages2_range(inode->i_mapping, 6854 lockstart >> PAGE_CACHE_SHIFT, 6855 lockend >> PAGE_CACHE_SHIFT); 6856 if (ret) 6857 break; 6858 } 6859 6860 cond_resched(); 6861 } 6862 6863 return ret; 6864 } 6865 6866 static struct extent_map *create_pinned_em(struct inode *inode, u64 start, 6867 u64 len, u64 orig_start, 6868 u64 block_start, u64 block_len, 6869 u64 orig_block_len, u64 ram_bytes, 6870 int type) 6871 { 6872 struct extent_map_tree *em_tree; 6873 struct extent_map *em; 6874 struct btrfs_root *root = BTRFS_I(inode)->root; 6875 int ret; 6876 6877 em_tree = &BTRFS_I(inode)->extent_tree; 6878 em = alloc_extent_map(); 6879 if (!em) 6880 return ERR_PTR(-ENOMEM); 6881 6882 em->start = start; 6883 em->orig_start = orig_start; 6884 em->mod_start = start; 6885 em->mod_len = len; 6886 em->len = len; 6887 em->block_len = block_len; 6888 em->block_start = block_start; 6889 em->bdev = root->fs_info->fs_devices->latest_bdev; 6890 em->orig_block_len = orig_block_len; 6891 em->ram_bytes = ram_bytes; 6892 em->generation = -1; 6893 set_bit(EXTENT_FLAG_PINNED, &em->flags); 6894 if (type == BTRFS_ORDERED_PREALLOC) 6895 set_bit(EXTENT_FLAG_FILLING, &em->flags); 6896 6897 do { 6898 btrfs_drop_extent_cache(inode, em->start, 6899 em->start + em->len - 1, 0); 6900 write_lock(&em_tree->lock); 6901 ret = add_extent_mapping(em_tree, em, 1); 6902 write_unlock(&em_tree->lock); 6903 } while (ret == -EEXIST); 6904 6905 if (ret) { 6906 free_extent_map(em); 6907 return ERR_PTR(ret); 6908 } 6909 6910 return em; 6911 } 6912 6913 6914 static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock, 6915 struct buffer_head *bh_result, int create) 6916 { 6917 struct extent_map *em; 6918 struct btrfs_root *root = BTRFS_I(inode)->root; 6919 struct extent_state *cached_state = NULL; 6920 u64 start = iblock << inode->i_blkbits; 6921 u64 lockstart, lockend; 6922 u64 len = bh_result->b_size; 6923 int unlock_bits = EXTENT_LOCKED; 6924 int ret = 0; 6925 6926 if (create) 6927 unlock_bits |= EXTENT_DELALLOC | EXTENT_DIRTY; 6928 else 6929 len = min_t(u64, len, root->sectorsize); 6930 6931 lockstart = start; 6932 lockend = start + len - 1; 6933 6934 /* 6935 * If this errors out it's because we couldn't invalidate pagecache for 6936 * this range and we need to fallback to buffered. 6937 */ 6938 if (lock_extent_direct(inode, lockstart, lockend, &cached_state, create)) 6939 return -ENOTBLK; 6940 6941 em = btrfs_get_extent(inode, NULL, 0, start, len, 0); 6942 if (IS_ERR(em)) { 6943 ret = PTR_ERR(em); 6944 goto unlock_err; 6945 } 6946 6947 /* 6948 * Ok for INLINE and COMPRESSED extents we need to fallback on buffered 6949 * io. INLINE is special, and we could probably kludge it in here, but 6950 * it's still buffered so for safety lets just fall back to the generic 6951 * buffered path. 6952 * 6953 * For COMPRESSED we _have_ to read the entire extent in so we can 6954 * decompress it, so there will be buffering required no matter what we 6955 * do, so go ahead and fallback to buffered. 6956 * 6957 * We return -ENOTBLK because thats what makes DIO go ahead and go back 6958 * to buffered IO. Don't blame me, this is the price we pay for using 6959 * the generic code. 6960 */ 6961 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) || 6962 em->block_start == EXTENT_MAP_INLINE) { 6963 free_extent_map(em); 6964 ret = -ENOTBLK; 6965 goto unlock_err; 6966 } 6967 6968 /* Just a good old fashioned hole, return */ 6969 if (!create && (em->block_start == EXTENT_MAP_HOLE || 6970 test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) { 6971 free_extent_map(em); 6972 goto unlock_err; 6973 } 6974 6975 /* 6976 * We don't allocate a new extent in the following cases 6977 * 6978 * 1) The inode is marked as NODATACOW. In this case we'll just use the 6979 * existing extent. 6980 * 2) The extent is marked as PREALLOC. We're good to go here and can 6981 * just use the extent. 6982 * 6983 */ 6984 if (!create) { 6985 len = min(len, em->len - (start - em->start)); 6986 lockstart = start + len; 6987 goto unlock; 6988 } 6989 6990 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) || 6991 ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) && 6992 em->block_start != EXTENT_MAP_HOLE)) { 6993 int type; 6994 int ret; 6995 u64 block_start, orig_start, orig_block_len, ram_bytes; 6996 6997 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) 6998 type = BTRFS_ORDERED_PREALLOC; 6999 else 7000 type = BTRFS_ORDERED_NOCOW; 7001 len = min(len, em->len - (start - em->start)); 7002 block_start = em->block_start + (start - em->start); 7003 7004 if (can_nocow_extent(inode, start, &len, &orig_start, 7005 &orig_block_len, &ram_bytes) == 1) { 7006 if (type == BTRFS_ORDERED_PREALLOC) { 7007 free_extent_map(em); 7008 em = create_pinned_em(inode, start, len, 7009 orig_start, 7010 block_start, len, 7011 orig_block_len, 7012 ram_bytes, type); 7013 if (IS_ERR(em)) 7014 goto unlock_err; 7015 } 7016 7017 ret = btrfs_add_ordered_extent_dio(inode, start, 7018 block_start, len, len, type); 7019 if (ret) { 7020 free_extent_map(em); 7021 goto unlock_err; 7022 } 7023 goto unlock; 7024 } 7025 } 7026 7027 /* 7028 * this will cow the extent, reset the len in case we changed 7029 * it above 7030 */ 7031 len = bh_result->b_size; 7032 free_extent_map(em); 7033 em = btrfs_new_extent_direct(inode, start, len); 7034 if (IS_ERR(em)) { 7035 ret = PTR_ERR(em); 7036 goto unlock_err; 7037 } 7038 len = min(len, em->len - (start - em->start)); 7039 unlock: 7040 bh_result->b_blocknr = (em->block_start + (start - em->start)) >> 7041 inode->i_blkbits; 7042 bh_result->b_size = len; 7043 bh_result->b_bdev = em->bdev; 7044 set_buffer_mapped(bh_result); 7045 if (create) { 7046 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) 7047 set_buffer_new(bh_result); 7048 7049 /* 7050 * Need to update the i_size under the extent lock so buffered 7051 * readers will get the updated i_size when we unlock. 7052 */ 7053 if (start + len > i_size_read(inode)) 7054 i_size_write(inode, start + len); 7055 7056 spin_lock(&BTRFS_I(inode)->lock); 7057 BTRFS_I(inode)->outstanding_extents++; 7058 spin_unlock(&BTRFS_I(inode)->lock); 7059 7060 ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, 7061 lockstart + len - 1, EXTENT_DELALLOC, NULL, 7062 &cached_state, GFP_NOFS); 7063 BUG_ON(ret); 7064 } 7065 7066 /* 7067 * In the case of write we need to clear and unlock the entire range, 7068 * in the case of read we need to unlock only the end area that we 7069 * aren't using if there is any left over space. 7070 */ 7071 if (lockstart < lockend) { 7072 clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, 7073 lockend, unlock_bits, 1, 0, 7074 &cached_state, GFP_NOFS); 7075 } else { 7076 free_extent_state(cached_state); 7077 } 7078 7079 free_extent_map(em); 7080 7081 return 0; 7082 7083 unlock_err: 7084 clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend, 7085 unlock_bits, 1, 0, &cached_state, GFP_NOFS); 7086 return ret; 7087 } 7088 7089 static void btrfs_endio_direct_read(struct bio *bio, int err) 7090 { 7091 struct btrfs_dio_private *dip = bio->bi_private; 7092 struct bio_vec *bvec; 7093 struct inode *inode = dip->inode; 7094 struct btrfs_root *root = BTRFS_I(inode)->root; 7095 struct bio *dio_bio; 7096 u32 *csums = (u32 *)dip->csum; 7097 u64 start; 7098 int i; 7099 7100 start = dip->logical_offset; 7101 bio_for_each_segment_all(bvec, bio, i) { 7102 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { 7103 struct page *page = bvec->bv_page; 7104 char *kaddr; 7105 u32 csum = ~(u32)0; 7106 unsigned long flags; 7107 7108 local_irq_save(flags); 7109 kaddr = kmap_atomic(page); 7110 csum = btrfs_csum_data(kaddr + bvec->bv_offset, 7111 csum, bvec->bv_len); 7112 btrfs_csum_final(csum, (char *)&csum); 7113 kunmap_atomic(kaddr); 7114 local_irq_restore(flags); 7115 7116 flush_dcache_page(bvec->bv_page); 7117 if (csum != csums[i]) { 7118 btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u", 7119 btrfs_ino(inode), start, csum, 7120 csums[i]); 7121 err = -EIO; 7122 } 7123 } 7124 7125 start += bvec->bv_len; 7126 } 7127 7128 unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset, 7129 dip->logical_offset + dip->bytes - 1); 7130 dio_bio = dip->dio_bio; 7131 7132 kfree(dip); 7133 7134 /* If we had a csum failure make sure to clear the uptodate flag */ 7135 if (err) 7136 clear_bit(BIO_UPTODATE, &dio_bio->bi_flags); 7137 dio_end_io(dio_bio, err); 7138 bio_put(bio); 7139 } 7140 7141 static void btrfs_endio_direct_write(struct bio *bio, int err) 7142 { 7143 struct btrfs_dio_private *dip = bio->bi_private; 7144 struct inode *inode = dip->inode; 7145 struct btrfs_root *root = BTRFS_I(inode)->root; 7146 struct btrfs_ordered_extent *ordered = NULL; 7147 u64 ordered_offset = dip->logical_offset; 7148 u64 ordered_bytes = dip->bytes; 7149 struct bio *dio_bio; 7150 int ret; 7151 7152 if (err) 7153 goto out_done; 7154 again: 7155 ret = btrfs_dec_test_first_ordered_pending(inode, &ordered, 7156 &ordered_offset, 7157 ordered_bytes, !err); 7158 if (!ret) 7159 goto out_test; 7160 7161 btrfs_init_work(&ordered->work, finish_ordered_fn, NULL, NULL); 7162 btrfs_queue_work(root->fs_info->endio_write_workers, 7163 &ordered->work); 7164 out_test: 7165 /* 7166 * our bio might span multiple ordered extents. If we haven't 7167 * completed the accounting for the whole dio, go back and try again 7168 */ 7169 if (ordered_offset < dip->logical_offset + dip->bytes) { 7170 ordered_bytes = dip->logical_offset + dip->bytes - 7171 ordered_offset; 7172 ordered = NULL; 7173 goto again; 7174 } 7175 out_done: 7176 dio_bio = dip->dio_bio; 7177 7178 kfree(dip); 7179 7180 /* If we had an error make sure to clear the uptodate flag */ 7181 if (err) 7182 clear_bit(BIO_UPTODATE, &dio_bio->bi_flags); 7183 dio_end_io(dio_bio, err); 7184 bio_put(bio); 7185 } 7186 7187 static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw, 7188 struct bio *bio, int mirror_num, 7189 unsigned long bio_flags, u64 offset) 7190 { 7191 int ret; 7192 struct btrfs_root *root = BTRFS_I(inode)->root; 7193 ret = btrfs_csum_one_bio(root, inode, bio, offset, 1); 7194 BUG_ON(ret); /* -ENOMEM */ 7195 return 0; 7196 } 7197 7198 static void btrfs_end_dio_bio(struct bio *bio, int err) 7199 { 7200 struct btrfs_dio_private *dip = bio->bi_private; 7201 7202 if (err) { 7203 btrfs_err(BTRFS_I(dip->inode)->root->fs_info, 7204 "direct IO failed ino %llu rw %lu sector %#Lx len %u err no %d", 7205 btrfs_ino(dip->inode), bio->bi_rw, 7206 (unsigned long long)bio->bi_iter.bi_sector, 7207 bio->bi_iter.bi_size, err); 7208 dip->errors = 1; 7209 7210 /* 7211 * before atomic variable goto zero, we must make sure 7212 * dip->errors is perceived to be set. 7213 */ 7214 smp_mb__before_atomic(); 7215 } 7216 7217 /* if there are more bios still pending for this dio, just exit */ 7218 if (!atomic_dec_and_test(&dip->pending_bios)) 7219 goto out; 7220 7221 if (dip->errors) { 7222 bio_io_error(dip->orig_bio); 7223 } else { 7224 set_bit(BIO_UPTODATE, &dip->dio_bio->bi_flags); 7225 bio_endio(dip->orig_bio, 0); 7226 } 7227 out: 7228 bio_put(bio); 7229 } 7230 7231 static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev, 7232 u64 first_sector, gfp_t gfp_flags) 7233 { 7234 int nr_vecs = bio_get_nr_vecs(bdev); 7235 return btrfs_bio_alloc(bdev, first_sector, nr_vecs, gfp_flags); 7236 } 7237 7238 static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode, 7239 int rw, u64 file_offset, int skip_sum, 7240 int async_submit) 7241 { 7242 struct btrfs_dio_private *dip = bio->bi_private; 7243 int write = rw & REQ_WRITE; 7244 struct btrfs_root *root = BTRFS_I(inode)->root; 7245 int ret; 7246 7247 if (async_submit) 7248 async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers); 7249 7250 bio_get(bio); 7251 7252 if (!write) { 7253 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0); 7254 if (ret) 7255 goto err; 7256 } 7257 7258 if (skip_sum) 7259 goto map; 7260 7261 if (write && async_submit) { 7262 ret = btrfs_wq_submit_bio(root->fs_info, 7263 inode, rw, bio, 0, 0, 7264 file_offset, 7265 __btrfs_submit_bio_start_direct_io, 7266 __btrfs_submit_bio_done); 7267 goto err; 7268 } else if (write) { 7269 /* 7270 * If we aren't doing async submit, calculate the csum of the 7271 * bio now. 7272 */ 7273 ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1); 7274 if (ret) 7275 goto err; 7276 } else if (!skip_sum) { 7277 ret = btrfs_lookup_bio_sums_dio(root, inode, dip, bio, 7278 file_offset); 7279 if (ret) 7280 goto err; 7281 } 7282 7283 map: 7284 ret = btrfs_map_bio(root, rw, bio, 0, async_submit); 7285 err: 7286 bio_put(bio); 7287 return ret; 7288 } 7289 7290 static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip, 7291 int skip_sum) 7292 { 7293 struct inode *inode = dip->inode; 7294 struct btrfs_root *root = BTRFS_I(inode)->root; 7295 struct bio *bio; 7296 struct bio *orig_bio = dip->orig_bio; 7297 struct bio_vec *bvec = orig_bio->bi_io_vec; 7298 u64 start_sector = orig_bio->bi_iter.bi_sector; 7299 u64 file_offset = dip->logical_offset; 7300 u64 submit_len = 0; 7301 u64 map_length; 7302 int nr_pages = 0; 7303 int ret = 0; 7304 int async_submit = 0; 7305 7306 map_length = orig_bio->bi_iter.bi_size; 7307 ret = btrfs_map_block(root->fs_info, rw, start_sector << 9, 7308 &map_length, NULL, 0); 7309 if (ret) { 7310 bio_put(orig_bio); 7311 return -EIO; 7312 } 7313 7314 if (map_length >= orig_bio->bi_iter.bi_size) { 7315 bio = orig_bio; 7316 goto submit; 7317 } 7318 7319 /* async crcs make it difficult to collect full stripe writes. */ 7320 if (btrfs_get_alloc_profile(root, 1) & 7321 (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) 7322 async_submit = 0; 7323 else 7324 async_submit = 1; 7325 7326 bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS); 7327 if (!bio) 7328 return -ENOMEM; 7329 bio->bi_private = dip; 7330 bio->bi_end_io = btrfs_end_dio_bio; 7331 atomic_inc(&dip->pending_bios); 7332 7333 while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) { 7334 if (unlikely(map_length < submit_len + bvec->bv_len || 7335 bio_add_page(bio, bvec->bv_page, bvec->bv_len, 7336 bvec->bv_offset) < bvec->bv_len)) { 7337 /* 7338 * inc the count before we submit the bio so 7339 * we know the end IO handler won't happen before 7340 * we inc the count. Otherwise, the dip might get freed 7341 * before we're done setting it up 7342 */ 7343 atomic_inc(&dip->pending_bios); 7344 ret = __btrfs_submit_dio_bio(bio, inode, rw, 7345 file_offset, skip_sum, 7346 async_submit); 7347 if (ret) { 7348 bio_put(bio); 7349 atomic_dec(&dip->pending_bios); 7350 goto out_err; 7351 } 7352 7353 start_sector += submit_len >> 9; 7354 file_offset += submit_len; 7355 7356 submit_len = 0; 7357 nr_pages = 0; 7358 7359 bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, 7360 start_sector, GFP_NOFS); 7361 if (!bio) 7362 goto out_err; 7363 bio->bi_private = dip; 7364 bio->bi_end_io = btrfs_end_dio_bio; 7365 7366 map_length = orig_bio->bi_iter.bi_size; 7367 ret = btrfs_map_block(root->fs_info, rw, 7368 start_sector << 9, 7369 &map_length, NULL, 0); 7370 if (ret) { 7371 bio_put(bio); 7372 goto out_err; 7373 } 7374 } else { 7375 submit_len += bvec->bv_len; 7376 nr_pages++; 7377 bvec++; 7378 } 7379 } 7380 7381 submit: 7382 ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum, 7383 async_submit); 7384 if (!ret) 7385 return 0; 7386 7387 bio_put(bio); 7388 out_err: 7389 dip->errors = 1; 7390 /* 7391 * before atomic variable goto zero, we must 7392 * make sure dip->errors is perceived to be set. 7393 */ 7394 smp_mb__before_atomic(); 7395 if (atomic_dec_and_test(&dip->pending_bios)) 7396 bio_io_error(dip->orig_bio); 7397 7398 /* bio_end_io() will handle error, so we needn't return it */ 7399 return 0; 7400 } 7401 7402 static void btrfs_submit_direct(int rw, struct bio *dio_bio, 7403 struct inode *inode, loff_t file_offset) 7404 { 7405 struct btrfs_root *root = BTRFS_I(inode)->root; 7406 struct btrfs_dio_private *dip; 7407 struct bio *io_bio; 7408 int skip_sum; 7409 int sum_len; 7410 int write = rw & REQ_WRITE; 7411 int ret = 0; 7412 u16 csum_size; 7413 7414 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; 7415 7416 io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS); 7417 if (!io_bio) { 7418 ret = -ENOMEM; 7419 goto free_ordered; 7420 } 7421 7422 if (!skip_sum && !write) { 7423 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); 7424 sum_len = dio_bio->bi_iter.bi_size >> 7425 inode->i_sb->s_blocksize_bits; 7426 sum_len *= csum_size; 7427 } else { 7428 sum_len = 0; 7429 } 7430 7431 dip = kmalloc(sizeof(*dip) + sum_len, GFP_NOFS); 7432 if (!dip) { 7433 ret = -ENOMEM; 7434 goto free_io_bio; 7435 } 7436 7437 dip->private = dio_bio->bi_private; 7438 dip->inode = inode; 7439 dip->logical_offset = file_offset; 7440 dip->bytes = dio_bio->bi_iter.bi_size; 7441 dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9; 7442 io_bio->bi_private = dip; 7443 dip->errors = 0; 7444 dip->orig_bio = io_bio; 7445 dip->dio_bio = dio_bio; 7446 atomic_set(&dip->pending_bios, 0); 7447 7448 if (write) 7449 io_bio->bi_end_io = btrfs_endio_direct_write; 7450 else 7451 io_bio->bi_end_io = btrfs_endio_direct_read; 7452 7453 ret = btrfs_submit_direct_hook(rw, dip, skip_sum); 7454 if (!ret) 7455 return; 7456 7457 free_io_bio: 7458 bio_put(io_bio); 7459 7460 free_ordered: 7461 /* 7462 * If this is a write, we need to clean up the reserved space and kill 7463 * the ordered extent. 7464 */ 7465 if (write) { 7466 struct btrfs_ordered_extent *ordered; 7467 ordered = btrfs_lookup_ordered_extent(inode, file_offset); 7468 if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) && 7469 !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) 7470 btrfs_free_reserved_extent(root, ordered->start, 7471 ordered->disk_len, 1); 7472 btrfs_put_ordered_extent(ordered); 7473 btrfs_put_ordered_extent(ordered); 7474 } 7475 bio_endio(dio_bio, ret); 7476 } 7477 7478 static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb, 7479 const struct iov_iter *iter, loff_t offset) 7480 { 7481 int seg; 7482 int i; 7483 unsigned blocksize_mask = root->sectorsize - 1; 7484 ssize_t retval = -EINVAL; 7485 7486 if (offset & blocksize_mask) 7487 goto out; 7488 7489 if (iov_iter_alignment(iter) & blocksize_mask) 7490 goto out; 7491 7492 /* If this is a write we don't need to check anymore */ 7493 if (rw & WRITE) 7494 return 0; 7495 /* 7496 * Check to make sure we don't have duplicate iov_base's in this 7497 * iovec, if so return EINVAL, otherwise we'll get csum errors 7498 * when reading back. 7499 */ 7500 for (seg = 0; seg < iter->nr_segs; seg++) { 7501 for (i = seg + 1; i < iter->nr_segs; i++) { 7502 if (iter->iov[seg].iov_base == iter->iov[i].iov_base) 7503 goto out; 7504 } 7505 } 7506 retval = 0; 7507 out: 7508 return retval; 7509 } 7510 7511 static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb, 7512 struct iov_iter *iter, loff_t offset) 7513 { 7514 struct file *file = iocb->ki_filp; 7515 struct inode *inode = file->f_mapping->host; 7516 size_t count = 0; 7517 int flags = 0; 7518 bool wakeup = true; 7519 bool relock = false; 7520 ssize_t ret; 7521 7522 if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iter, offset)) 7523 return 0; 7524 7525 atomic_inc(&inode->i_dio_count); 7526 smp_mb__after_atomic(); 7527 7528 /* 7529 * The generic stuff only does filemap_write_and_wait_range, which 7530 * isn't enough if we've written compressed pages to this area, so 7531 * we need to flush the dirty pages again to make absolutely sure 7532 * that any outstanding dirty pages are on disk. 7533 */ 7534 count = iov_iter_count(iter); 7535 if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, 7536 &BTRFS_I(inode)->runtime_flags)) 7537 filemap_fdatawrite_range(inode->i_mapping, offset, count); 7538 7539 if (rw & WRITE) { 7540 /* 7541 * If the write DIO is beyond the EOF, we need update 7542 * the isize, but it is protected by i_mutex. So we can 7543 * not unlock the i_mutex at this case. 7544 */ 7545 if (offset + count <= inode->i_size) { 7546 mutex_unlock(&inode->i_mutex); 7547 relock = true; 7548 } 7549 ret = btrfs_delalloc_reserve_space(inode, count); 7550 if (ret) 7551 goto out; 7552 } else if (unlikely(test_bit(BTRFS_INODE_READDIO_NEED_LOCK, 7553 &BTRFS_I(inode)->runtime_flags))) { 7554 inode_dio_done(inode); 7555 flags = DIO_LOCKING | DIO_SKIP_HOLES; 7556 wakeup = false; 7557 } 7558 7559 ret = __blockdev_direct_IO(rw, iocb, inode, 7560 BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev, 7561 iter, offset, btrfs_get_blocks_direct, NULL, 7562 btrfs_submit_direct, flags); 7563 if (rw & WRITE) { 7564 if (ret < 0 && ret != -EIOCBQUEUED) 7565 btrfs_delalloc_release_space(inode, count); 7566 else if (ret >= 0 && (size_t)ret < count) 7567 btrfs_delalloc_release_space(inode, 7568 count - (size_t)ret); 7569 else 7570 btrfs_delalloc_release_metadata(inode, 0); 7571 } 7572 out: 7573 if (wakeup) 7574 inode_dio_done(inode); 7575 if (relock) 7576 mutex_lock(&inode->i_mutex); 7577 7578 return ret; 7579 } 7580 7581 #define BTRFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC) 7582 7583 static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 7584 __u64 start, __u64 len) 7585 { 7586 int ret; 7587 7588 ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS); 7589 if (ret) 7590 return ret; 7591 7592 return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap); 7593 } 7594 7595 int btrfs_readpage(struct file *file, struct page *page) 7596 { 7597 struct extent_io_tree *tree; 7598 tree = &BTRFS_I(page->mapping->host)->io_tree; 7599 return extent_read_full_page(tree, page, btrfs_get_extent, 0); 7600 } 7601 7602 static int btrfs_writepage(struct page *page, struct writeback_control *wbc) 7603 { 7604 struct extent_io_tree *tree; 7605 7606 7607 if (current->flags & PF_MEMALLOC) { 7608 redirty_page_for_writepage(wbc, page); 7609 unlock_page(page); 7610 return 0; 7611 } 7612 tree = &BTRFS_I(page->mapping->host)->io_tree; 7613 return extent_write_full_page(tree, page, btrfs_get_extent, wbc); 7614 } 7615 7616 static int btrfs_writepages(struct address_space *mapping, 7617 struct writeback_control *wbc) 7618 { 7619 struct extent_io_tree *tree; 7620 7621 tree = &BTRFS_I(mapping->host)->io_tree; 7622 return extent_writepages(tree, mapping, btrfs_get_extent, wbc); 7623 } 7624 7625 static int 7626 btrfs_readpages(struct file *file, struct address_space *mapping, 7627 struct list_head *pages, unsigned nr_pages) 7628 { 7629 struct extent_io_tree *tree; 7630 tree = &BTRFS_I(mapping->host)->io_tree; 7631 return extent_readpages(tree, mapping, pages, nr_pages, 7632 btrfs_get_extent); 7633 } 7634 static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags) 7635 { 7636 struct extent_io_tree *tree; 7637 struct extent_map_tree *map; 7638 int ret; 7639 7640 tree = &BTRFS_I(page->mapping->host)->io_tree; 7641 map = &BTRFS_I(page->mapping->host)->extent_tree; 7642 ret = try_release_extent_mapping(map, tree, page, gfp_flags); 7643 if (ret == 1) { 7644 ClearPagePrivate(page); 7645 set_page_private(page, 0); 7646 page_cache_release(page); 7647 } 7648 return ret; 7649 } 7650 7651 static int btrfs_releasepage(struct page *page, gfp_t gfp_flags) 7652 { 7653 if (PageWriteback(page) || PageDirty(page)) 7654 return 0; 7655 return __btrfs_releasepage(page, gfp_flags & GFP_NOFS); 7656 } 7657 7658 static void btrfs_invalidatepage(struct page *page, unsigned int offset, 7659 unsigned int length) 7660 { 7661 struct inode *inode = page->mapping->host; 7662 struct extent_io_tree *tree; 7663 struct btrfs_ordered_extent *ordered; 7664 struct extent_state *cached_state = NULL; 7665 u64 page_start = page_offset(page); 7666 u64 page_end = page_start + PAGE_CACHE_SIZE - 1; 7667 int inode_evicting = inode->i_state & I_FREEING; 7668 7669 /* 7670 * we have the page locked, so new writeback can't start, 7671 * and the dirty bit won't be cleared while we are here. 7672 * 7673 * Wait for IO on this page so that we can safely clear 7674 * the PagePrivate2 bit and do ordered accounting 7675 */ 7676 wait_on_page_writeback(page); 7677 7678 tree = &BTRFS_I(inode)->io_tree; 7679 if (offset) { 7680 btrfs_releasepage(page, GFP_NOFS); 7681 return; 7682 } 7683 7684 if (!inode_evicting) 7685 lock_extent_bits(tree, page_start, page_end, 0, &cached_state); 7686 ordered = btrfs_lookup_ordered_extent(inode, page_start); 7687 if (ordered) { 7688 /* 7689 * IO on this page will never be started, so we need 7690 * to account for any ordered extents now 7691 */ 7692 if (!inode_evicting) 7693 clear_extent_bit(tree, page_start, page_end, 7694 EXTENT_DIRTY | EXTENT_DELALLOC | 7695 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING | 7696 EXTENT_DEFRAG, 1, 0, &cached_state, 7697 GFP_NOFS); 7698 /* 7699 * whoever cleared the private bit is responsible 7700 * for the finish_ordered_io 7701 */ 7702 if (TestClearPagePrivate2(page)) { 7703 struct btrfs_ordered_inode_tree *tree; 7704 u64 new_len; 7705 7706 tree = &BTRFS_I(inode)->ordered_tree; 7707 7708 spin_lock_irq(&tree->lock); 7709 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags); 7710 new_len = page_start - ordered->file_offset; 7711 if (new_len < ordered->truncated_len) 7712 ordered->truncated_len = new_len; 7713 spin_unlock_irq(&tree->lock); 7714 7715 if (btrfs_dec_test_ordered_pending(inode, &ordered, 7716 page_start, 7717 PAGE_CACHE_SIZE, 1)) 7718 btrfs_finish_ordered_io(ordered); 7719 } 7720 btrfs_put_ordered_extent(ordered); 7721 if (!inode_evicting) { 7722 cached_state = NULL; 7723 lock_extent_bits(tree, page_start, page_end, 0, 7724 &cached_state); 7725 } 7726 } 7727 7728 if (!inode_evicting) { 7729 clear_extent_bit(tree, page_start, page_end, 7730 EXTENT_LOCKED | EXTENT_DIRTY | 7731 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | 7732 EXTENT_DEFRAG, 1, 1, 7733 &cached_state, GFP_NOFS); 7734 7735 __btrfs_releasepage(page, GFP_NOFS); 7736 } 7737 7738 ClearPageChecked(page); 7739 if (PagePrivate(page)) { 7740 ClearPagePrivate(page); 7741 set_page_private(page, 0); 7742 page_cache_release(page); 7743 } 7744 } 7745 7746 /* 7747 * btrfs_page_mkwrite() is not allowed to change the file size as it gets 7748 * called from a page fault handler when a page is first dirtied. Hence we must 7749 * be careful to check for EOF conditions here. We set the page up correctly 7750 * for a written page which means we get ENOSPC checking when writing into 7751 * holes and correct delalloc and unwritten extent mapping on filesystems that 7752 * support these features. 7753 * 7754 * We are not allowed to take the i_mutex here so we have to play games to 7755 * protect against truncate races as the page could now be beyond EOF. Because 7756 * vmtruncate() writes the inode size before removing pages, once we have the 7757 * page lock we can determine safely if the page is beyond EOF. If it is not 7758 * beyond EOF, then the page is guaranteed safe against truncation until we 7759 * unlock the page. 7760 */ 7761 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 7762 { 7763 struct page *page = vmf->page; 7764 struct inode *inode = file_inode(vma->vm_file); 7765 struct btrfs_root *root = BTRFS_I(inode)->root; 7766 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 7767 struct btrfs_ordered_extent *ordered; 7768 struct extent_state *cached_state = NULL; 7769 char *kaddr; 7770 unsigned long zero_start; 7771 loff_t size; 7772 int ret; 7773 int reserved = 0; 7774 u64 page_start; 7775 u64 page_end; 7776 7777 sb_start_pagefault(inode->i_sb); 7778 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE); 7779 if (!ret) { 7780 ret = file_update_time(vma->vm_file); 7781 reserved = 1; 7782 } 7783 if (ret) { 7784 if (ret == -ENOMEM) 7785 ret = VM_FAULT_OOM; 7786 else /* -ENOSPC, -EIO, etc */ 7787 ret = VM_FAULT_SIGBUS; 7788 if (reserved) 7789 goto out; 7790 goto out_noreserve; 7791 } 7792 7793 ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */ 7794 again: 7795 lock_page(page); 7796 size = i_size_read(inode); 7797 page_start = page_offset(page); 7798 page_end = page_start + PAGE_CACHE_SIZE - 1; 7799 7800 if ((page->mapping != inode->i_mapping) || 7801 (page_start >= size)) { 7802 /* page got truncated out from underneath us */ 7803 goto out_unlock; 7804 } 7805 wait_on_page_writeback(page); 7806 7807 lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state); 7808 set_page_extent_mapped(page); 7809 7810 /* 7811 * we can't set the delalloc bits if there are pending ordered 7812 * extents. Drop our locks and wait for them to finish 7813 */ 7814 ordered = btrfs_lookup_ordered_extent(inode, page_start); 7815 if (ordered) { 7816 unlock_extent_cached(io_tree, page_start, page_end, 7817 &cached_state, GFP_NOFS); 7818 unlock_page(page); 7819 btrfs_start_ordered_extent(inode, ordered, 1); 7820 btrfs_put_ordered_extent(ordered); 7821 goto again; 7822 } 7823 7824 /* 7825 * XXX - page_mkwrite gets called every time the page is dirtied, even 7826 * if it was already dirty, so for space accounting reasons we need to 7827 * clear any delalloc bits for the range we are fixing to save. There 7828 * is probably a better way to do this, but for now keep consistent with 7829 * prepare_pages in the normal write path. 7830 */ 7831 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end, 7832 EXTENT_DIRTY | EXTENT_DELALLOC | 7833 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 7834 0, 0, &cached_state, GFP_NOFS); 7835 7836 ret = btrfs_set_extent_delalloc(inode, page_start, page_end, 7837 &cached_state); 7838 if (ret) { 7839 unlock_extent_cached(io_tree, page_start, page_end, 7840 &cached_state, GFP_NOFS); 7841 ret = VM_FAULT_SIGBUS; 7842 goto out_unlock; 7843 } 7844 ret = 0; 7845 7846 /* page is wholly or partially inside EOF */ 7847 if (page_start + PAGE_CACHE_SIZE > size) 7848 zero_start = size & ~PAGE_CACHE_MASK; 7849 else 7850 zero_start = PAGE_CACHE_SIZE; 7851 7852 if (zero_start != PAGE_CACHE_SIZE) { 7853 kaddr = kmap(page); 7854 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start); 7855 flush_dcache_page(page); 7856 kunmap(page); 7857 } 7858 ClearPageChecked(page); 7859 set_page_dirty(page); 7860 SetPageUptodate(page); 7861 7862 BTRFS_I(inode)->last_trans = root->fs_info->generation; 7863 BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid; 7864 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit; 7865 7866 unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS); 7867 7868 out_unlock: 7869 if (!ret) { 7870 sb_end_pagefault(inode->i_sb); 7871 return VM_FAULT_LOCKED; 7872 } 7873 unlock_page(page); 7874 out: 7875 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE); 7876 out_noreserve: 7877 sb_end_pagefault(inode->i_sb); 7878 return ret; 7879 } 7880 7881 static int btrfs_truncate(struct inode *inode) 7882 { 7883 struct btrfs_root *root = BTRFS_I(inode)->root; 7884 struct btrfs_block_rsv *rsv; 7885 int ret = 0; 7886 int err = 0; 7887 struct btrfs_trans_handle *trans; 7888 u64 mask = root->sectorsize - 1; 7889 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1); 7890 7891 ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask), 7892 (u64)-1); 7893 if (ret) 7894 return ret; 7895 7896 /* 7897 * Yes ladies and gentelment, this is indeed ugly. The fact is we have 7898 * 3 things going on here 7899 * 7900 * 1) We need to reserve space for our orphan item and the space to 7901 * delete our orphan item. Lord knows we don't want to have a dangling 7902 * orphan item because we didn't reserve space to remove it. 7903 * 7904 * 2) We need to reserve space to update our inode. 7905 * 7906 * 3) We need to have something to cache all the space that is going to 7907 * be free'd up by the truncate operation, but also have some slack 7908 * space reserved in case it uses space during the truncate (thank you 7909 * very much snapshotting). 7910 * 7911 * And we need these to all be seperate. The fact is we can use alot of 7912 * space doing the truncate, and we have no earthly idea how much space 7913 * we will use, so we need the truncate reservation to be seperate so it 7914 * doesn't end up using space reserved for updating the inode or 7915 * removing the orphan item. We also need to be able to stop the 7916 * transaction and start a new one, which means we need to be able to 7917 * update the inode several times, and we have no idea of knowing how 7918 * many times that will be, so we can't just reserve 1 item for the 7919 * entirety of the opration, so that has to be done seperately as well. 7920 * Then there is the orphan item, which does indeed need to be held on 7921 * to for the whole operation, and we need nobody to touch this reserved 7922 * space except the orphan code. 7923 * 7924 * So that leaves us with 7925 * 7926 * 1) root->orphan_block_rsv - for the orphan deletion. 7927 * 2) rsv - for the truncate reservation, which we will steal from the 7928 * transaction reservation. 7929 * 3) fs_info->trans_block_rsv - this will have 1 items worth left for 7930 * updating the inode. 7931 */ 7932 rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP); 7933 if (!rsv) 7934 return -ENOMEM; 7935 rsv->size = min_size; 7936 rsv->failfast = 1; 7937 7938 /* 7939 * 1 for the truncate slack space 7940 * 1 for updating the inode. 7941 */ 7942 trans = btrfs_start_transaction(root, 2); 7943 if (IS_ERR(trans)) { 7944 err = PTR_ERR(trans); 7945 goto out; 7946 } 7947 7948 /* Migrate the slack space for the truncate to our reserve */ 7949 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv, 7950 min_size); 7951 BUG_ON(ret); 7952 7953 /* 7954 * So if we truncate and then write and fsync we normally would just 7955 * write the extents that changed, which is a problem if we need to 7956 * first truncate that entire inode. So set this flag so we write out 7957 * all of the extents in the inode to the sync log so we're completely 7958 * safe. 7959 */ 7960 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags); 7961 trans->block_rsv = rsv; 7962 7963 while (1) { 7964 ret = btrfs_truncate_inode_items(trans, root, inode, 7965 inode->i_size, 7966 BTRFS_EXTENT_DATA_KEY); 7967 if (ret != -ENOSPC) { 7968 err = ret; 7969 break; 7970 } 7971 7972 trans->block_rsv = &root->fs_info->trans_block_rsv; 7973 ret = btrfs_update_inode(trans, root, inode); 7974 if (ret) { 7975 err = ret; 7976 break; 7977 } 7978 7979 btrfs_end_transaction(trans, root); 7980 btrfs_btree_balance_dirty(root); 7981 7982 trans = btrfs_start_transaction(root, 2); 7983 if (IS_ERR(trans)) { 7984 ret = err = PTR_ERR(trans); 7985 trans = NULL; 7986 break; 7987 } 7988 7989 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, 7990 rsv, min_size); 7991 BUG_ON(ret); /* shouldn't happen */ 7992 trans->block_rsv = rsv; 7993 } 7994 7995 if (ret == 0 && inode->i_nlink > 0) { 7996 trans->block_rsv = root->orphan_block_rsv; 7997 ret = btrfs_orphan_del(trans, inode); 7998 if (ret) 7999 err = ret; 8000 } 8001 8002 if (trans) { 8003 trans->block_rsv = &root->fs_info->trans_block_rsv; 8004 ret = btrfs_update_inode(trans, root, inode); 8005 if (ret && !err) 8006 err = ret; 8007 8008 ret = btrfs_end_transaction(trans, root); 8009 btrfs_btree_balance_dirty(root); 8010 } 8011 8012 out: 8013 btrfs_free_block_rsv(root, rsv); 8014 8015 if (ret && !err) 8016 err = ret; 8017 8018 return err; 8019 } 8020 8021 /* 8022 * create a new subvolume directory/inode (helper for the ioctl). 8023 */ 8024 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans, 8025 struct btrfs_root *new_root, 8026 struct btrfs_root *parent_root, 8027 u64 new_dirid) 8028 { 8029 struct inode *inode; 8030 int err; 8031 u64 index = 0; 8032 8033 inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, 8034 new_dirid, new_dirid, 8035 S_IFDIR | (~current_umask() & S_IRWXUGO), 8036 &index); 8037 if (IS_ERR(inode)) 8038 return PTR_ERR(inode); 8039 inode->i_op = &btrfs_dir_inode_operations; 8040 inode->i_fop = &btrfs_dir_file_operations; 8041 8042 set_nlink(inode, 1); 8043 btrfs_i_size_write(inode, 0); 8044 8045 err = btrfs_subvol_inherit_props(trans, new_root, parent_root); 8046 if (err) 8047 btrfs_err(new_root->fs_info, 8048 "error inheriting subvolume %llu properties: %d", 8049 new_root->root_key.objectid, err); 8050 8051 err = btrfs_update_inode(trans, new_root, inode); 8052 8053 iput(inode); 8054 return err; 8055 } 8056 8057 struct inode *btrfs_alloc_inode(struct super_block *sb) 8058 { 8059 struct btrfs_inode *ei; 8060 struct inode *inode; 8061 8062 ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS); 8063 if (!ei) 8064 return NULL; 8065 8066 ei->root = NULL; 8067 ei->generation = 0; 8068 ei->last_trans = 0; 8069 ei->last_sub_trans = 0; 8070 ei->logged_trans = 0; 8071 ei->delalloc_bytes = 0; 8072 ei->disk_i_size = 0; 8073 ei->flags = 0; 8074 ei->csum_bytes = 0; 8075 ei->index_cnt = (u64)-1; 8076 ei->dir_index = 0; 8077 ei->last_unlink_trans = 0; 8078 ei->last_log_commit = 0; 8079 8080 spin_lock_init(&ei->lock); 8081 ei->outstanding_extents = 0; 8082 ei->reserved_extents = 0; 8083 8084 ei->runtime_flags = 0; 8085 ei->force_compress = BTRFS_COMPRESS_NONE; 8086 8087 ei->delayed_node = NULL; 8088 8089 inode = &ei->vfs_inode; 8090 extent_map_tree_init(&ei->extent_tree); 8091 extent_io_tree_init(&ei->io_tree, &inode->i_data); 8092 extent_io_tree_init(&ei->io_failure_tree, &inode->i_data); 8093 ei->io_tree.track_uptodate = 1; 8094 ei->io_failure_tree.track_uptodate = 1; 8095 atomic_set(&ei->sync_writers, 0); 8096 mutex_init(&ei->log_mutex); 8097 mutex_init(&ei->delalloc_mutex); 8098 btrfs_ordered_inode_tree_init(&ei->ordered_tree); 8099 INIT_LIST_HEAD(&ei->delalloc_inodes); 8100 RB_CLEAR_NODE(&ei->rb_node); 8101 8102 return inode; 8103 } 8104 8105 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 8106 void btrfs_test_destroy_inode(struct inode *inode) 8107 { 8108 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); 8109 kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode)); 8110 } 8111 #endif 8112 8113 static void btrfs_i_callback(struct rcu_head *head) 8114 { 8115 struct inode *inode = container_of(head, struct inode, i_rcu); 8116 kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode)); 8117 } 8118 8119 void btrfs_destroy_inode(struct inode *inode) 8120 { 8121 struct btrfs_ordered_extent *ordered; 8122 struct btrfs_root *root = BTRFS_I(inode)->root; 8123 8124 WARN_ON(!hlist_empty(&inode->i_dentry)); 8125 WARN_ON(inode->i_data.nrpages); 8126 WARN_ON(BTRFS_I(inode)->outstanding_extents); 8127 WARN_ON(BTRFS_I(inode)->reserved_extents); 8128 WARN_ON(BTRFS_I(inode)->delalloc_bytes); 8129 WARN_ON(BTRFS_I(inode)->csum_bytes); 8130 8131 /* 8132 * This can happen where we create an inode, but somebody else also 8133 * created the same inode and we need to destroy the one we already 8134 * created. 8135 */ 8136 if (!root) 8137 goto free; 8138 8139 if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 8140 &BTRFS_I(inode)->runtime_flags)) { 8141 btrfs_info(root->fs_info, "inode %llu still on the orphan list", 8142 btrfs_ino(inode)); 8143 atomic_dec(&root->orphan_inodes); 8144 } 8145 8146 while (1) { 8147 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1); 8148 if (!ordered) 8149 break; 8150 else { 8151 btrfs_err(root->fs_info, "found ordered extent %llu %llu on inode cleanup", 8152 ordered->file_offset, ordered->len); 8153 btrfs_remove_ordered_extent(inode, ordered); 8154 btrfs_put_ordered_extent(ordered); 8155 btrfs_put_ordered_extent(ordered); 8156 } 8157 } 8158 inode_tree_del(inode); 8159 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); 8160 free: 8161 call_rcu(&inode->i_rcu, btrfs_i_callback); 8162 } 8163 8164 int btrfs_drop_inode(struct inode *inode) 8165 { 8166 struct btrfs_root *root = BTRFS_I(inode)->root; 8167 8168 if (root == NULL) 8169 return 1; 8170 8171 /* the snap/subvol tree is on deleting */ 8172 if (btrfs_root_refs(&root->root_item) == 0) 8173 return 1; 8174 else 8175 return generic_drop_inode(inode); 8176 } 8177 8178 static void init_once(void *foo) 8179 { 8180 struct btrfs_inode *ei = (struct btrfs_inode *) foo; 8181 8182 inode_init_once(&ei->vfs_inode); 8183 } 8184 8185 void btrfs_destroy_cachep(void) 8186 { 8187 /* 8188 * Make sure all delayed rcu free inodes are flushed before we 8189 * destroy cache. 8190 */ 8191 rcu_barrier(); 8192 if (btrfs_inode_cachep) 8193 kmem_cache_destroy(btrfs_inode_cachep); 8194 if (btrfs_trans_handle_cachep) 8195 kmem_cache_destroy(btrfs_trans_handle_cachep); 8196 if (btrfs_transaction_cachep) 8197 kmem_cache_destroy(btrfs_transaction_cachep); 8198 if (btrfs_path_cachep) 8199 kmem_cache_destroy(btrfs_path_cachep); 8200 if (btrfs_free_space_cachep) 8201 kmem_cache_destroy(btrfs_free_space_cachep); 8202 if (btrfs_delalloc_work_cachep) 8203 kmem_cache_destroy(btrfs_delalloc_work_cachep); 8204 } 8205 8206 int btrfs_init_cachep(void) 8207 { 8208 btrfs_inode_cachep = kmem_cache_create("btrfs_inode", 8209 sizeof(struct btrfs_inode), 0, 8210 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once); 8211 if (!btrfs_inode_cachep) 8212 goto fail; 8213 8214 btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle", 8215 sizeof(struct btrfs_trans_handle), 0, 8216 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL); 8217 if (!btrfs_trans_handle_cachep) 8218 goto fail; 8219 8220 btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction", 8221 sizeof(struct btrfs_transaction), 0, 8222 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL); 8223 if (!btrfs_transaction_cachep) 8224 goto fail; 8225 8226 btrfs_path_cachep = kmem_cache_create("btrfs_path", 8227 sizeof(struct btrfs_path), 0, 8228 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL); 8229 if (!btrfs_path_cachep) 8230 goto fail; 8231 8232 btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space", 8233 sizeof(struct btrfs_free_space), 0, 8234 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL); 8235 if (!btrfs_free_space_cachep) 8236 goto fail; 8237 8238 btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work", 8239 sizeof(struct btrfs_delalloc_work), 0, 8240 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, 8241 NULL); 8242 if (!btrfs_delalloc_work_cachep) 8243 goto fail; 8244 8245 return 0; 8246 fail: 8247 btrfs_destroy_cachep(); 8248 return -ENOMEM; 8249 } 8250 8251 static int btrfs_getattr(struct vfsmount *mnt, 8252 struct dentry *dentry, struct kstat *stat) 8253 { 8254 u64 delalloc_bytes; 8255 struct inode *inode = dentry->d_inode; 8256 u32 blocksize = inode->i_sb->s_blocksize; 8257 8258 generic_fillattr(inode, stat); 8259 stat->dev = BTRFS_I(inode)->root->anon_dev; 8260 stat->blksize = PAGE_CACHE_SIZE; 8261 8262 spin_lock(&BTRFS_I(inode)->lock); 8263 delalloc_bytes = BTRFS_I(inode)->delalloc_bytes; 8264 spin_unlock(&BTRFS_I(inode)->lock); 8265 stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) + 8266 ALIGN(delalloc_bytes, blocksize)) >> 9; 8267 return 0; 8268 } 8269 8270 static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry, 8271 struct inode *new_dir, struct dentry *new_dentry) 8272 { 8273 struct btrfs_trans_handle *trans; 8274 struct btrfs_root *root = BTRFS_I(old_dir)->root; 8275 struct btrfs_root *dest = BTRFS_I(new_dir)->root; 8276 struct inode *new_inode = new_dentry->d_inode; 8277 struct inode *old_inode = old_dentry->d_inode; 8278 struct timespec ctime = CURRENT_TIME; 8279 u64 index = 0; 8280 u64 root_objectid; 8281 int ret; 8282 u64 old_ino = btrfs_ino(old_inode); 8283 8284 if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID) 8285 return -EPERM; 8286 8287 /* we only allow rename subvolume link between subvolumes */ 8288 if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest) 8289 return -EXDEV; 8290 8291 if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID || 8292 (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID)) 8293 return -ENOTEMPTY; 8294 8295 if (S_ISDIR(old_inode->i_mode) && new_inode && 8296 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) 8297 return -ENOTEMPTY; 8298 8299 8300 /* check for collisions, even if the name isn't there */ 8301 ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino, 8302 new_dentry->d_name.name, 8303 new_dentry->d_name.len); 8304 8305 if (ret) { 8306 if (ret == -EEXIST) { 8307 /* we shouldn't get 8308 * eexist without a new_inode */ 8309 if (WARN_ON(!new_inode)) { 8310 return ret; 8311 } 8312 } else { 8313 /* maybe -EOVERFLOW */ 8314 return ret; 8315 } 8316 } 8317 ret = 0; 8318 8319 /* 8320 * we're using rename to replace one file with another. Start IO on it 8321 * now so we don't add too much work to the end of the transaction 8322 */ 8323 if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size) 8324 filemap_flush(old_inode->i_mapping); 8325 8326 /* close the racy window with snapshot create/destroy ioctl */ 8327 if (old_ino == BTRFS_FIRST_FREE_OBJECTID) 8328 down_read(&root->fs_info->subvol_sem); 8329 /* 8330 * We want to reserve the absolute worst case amount of items. So if 8331 * both inodes are subvols and we need to unlink them then that would 8332 * require 4 item modifications, but if they are both normal inodes it 8333 * would require 5 item modifications, so we'll assume their normal 8334 * inodes. So 5 * 2 is 10, plus 1 for the new link, so 11 total items 8335 * should cover the worst case number of items we'll modify. 8336 */ 8337 trans = btrfs_start_transaction(root, 11); 8338 if (IS_ERR(trans)) { 8339 ret = PTR_ERR(trans); 8340 goto out_notrans; 8341 } 8342 8343 if (dest != root) 8344 btrfs_record_root_in_trans(trans, dest); 8345 8346 ret = btrfs_set_inode_index(new_dir, &index); 8347 if (ret) 8348 goto out_fail; 8349 8350 BTRFS_I(old_inode)->dir_index = 0ULL; 8351 if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) { 8352 /* force full log commit if subvolume involved. */ 8353 btrfs_set_log_full_commit(root->fs_info, trans); 8354 } else { 8355 ret = btrfs_insert_inode_ref(trans, dest, 8356 new_dentry->d_name.name, 8357 new_dentry->d_name.len, 8358 old_ino, 8359 btrfs_ino(new_dir), index); 8360 if (ret) 8361 goto out_fail; 8362 /* 8363 * this is an ugly little race, but the rename is required 8364 * to make sure that if we crash, the inode is either at the 8365 * old name or the new one. pinning the log transaction lets 8366 * us make sure we don't allow a log commit to come in after 8367 * we unlink the name but before we add the new name back in. 8368 */ 8369 btrfs_pin_log_trans(root); 8370 } 8371 8372 inode_inc_iversion(old_dir); 8373 inode_inc_iversion(new_dir); 8374 inode_inc_iversion(old_inode); 8375 old_dir->i_ctime = old_dir->i_mtime = ctime; 8376 new_dir->i_ctime = new_dir->i_mtime = ctime; 8377 old_inode->i_ctime = ctime; 8378 8379 if (old_dentry->d_parent != new_dentry->d_parent) 8380 btrfs_record_unlink_dir(trans, old_dir, old_inode, 1); 8381 8382 if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) { 8383 root_objectid = BTRFS_I(old_inode)->root->root_key.objectid; 8384 ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid, 8385 old_dentry->d_name.name, 8386 old_dentry->d_name.len); 8387 } else { 8388 ret = __btrfs_unlink_inode(trans, root, old_dir, 8389 old_dentry->d_inode, 8390 old_dentry->d_name.name, 8391 old_dentry->d_name.len); 8392 if (!ret) 8393 ret = btrfs_update_inode(trans, root, old_inode); 8394 } 8395 if (ret) { 8396 btrfs_abort_transaction(trans, root, ret); 8397 goto out_fail; 8398 } 8399 8400 if (new_inode) { 8401 inode_inc_iversion(new_inode); 8402 new_inode->i_ctime = CURRENT_TIME; 8403 if (unlikely(btrfs_ino(new_inode) == 8404 BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) { 8405 root_objectid = BTRFS_I(new_inode)->location.objectid; 8406 ret = btrfs_unlink_subvol(trans, dest, new_dir, 8407 root_objectid, 8408 new_dentry->d_name.name, 8409 new_dentry->d_name.len); 8410 BUG_ON(new_inode->i_nlink == 0); 8411 } else { 8412 ret = btrfs_unlink_inode(trans, dest, new_dir, 8413 new_dentry->d_inode, 8414 new_dentry->d_name.name, 8415 new_dentry->d_name.len); 8416 } 8417 if (!ret && new_inode->i_nlink == 0) 8418 ret = btrfs_orphan_add(trans, new_dentry->d_inode); 8419 if (ret) { 8420 btrfs_abort_transaction(trans, root, ret); 8421 goto out_fail; 8422 } 8423 } 8424 8425 ret = btrfs_add_link(trans, new_dir, old_inode, 8426 new_dentry->d_name.name, 8427 new_dentry->d_name.len, 0, index); 8428 if (ret) { 8429 btrfs_abort_transaction(trans, root, ret); 8430 goto out_fail; 8431 } 8432 8433 if (old_inode->i_nlink == 1) 8434 BTRFS_I(old_inode)->dir_index = index; 8435 8436 if (old_ino != BTRFS_FIRST_FREE_OBJECTID) { 8437 struct dentry *parent = new_dentry->d_parent; 8438 btrfs_log_new_name(trans, old_inode, old_dir, parent); 8439 btrfs_end_log_trans(root); 8440 } 8441 out_fail: 8442 btrfs_end_transaction(trans, root); 8443 out_notrans: 8444 if (old_ino == BTRFS_FIRST_FREE_OBJECTID) 8445 up_read(&root->fs_info->subvol_sem); 8446 8447 return ret; 8448 } 8449 8450 static int btrfs_rename2(struct inode *old_dir, struct dentry *old_dentry, 8451 struct inode *new_dir, struct dentry *new_dentry, 8452 unsigned int flags) 8453 { 8454 if (flags & ~RENAME_NOREPLACE) 8455 return -EINVAL; 8456 8457 return btrfs_rename(old_dir, old_dentry, new_dir, new_dentry); 8458 } 8459 8460 static void btrfs_run_delalloc_work(struct btrfs_work *work) 8461 { 8462 struct btrfs_delalloc_work *delalloc_work; 8463 struct inode *inode; 8464 8465 delalloc_work = container_of(work, struct btrfs_delalloc_work, 8466 work); 8467 inode = delalloc_work->inode; 8468 if (delalloc_work->wait) { 8469 btrfs_wait_ordered_range(inode, 0, (u64)-1); 8470 } else { 8471 filemap_flush(inode->i_mapping); 8472 if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, 8473 &BTRFS_I(inode)->runtime_flags)) 8474 filemap_flush(inode->i_mapping); 8475 } 8476 8477 if (delalloc_work->delay_iput) 8478 btrfs_add_delayed_iput(inode); 8479 else 8480 iput(inode); 8481 complete(&delalloc_work->completion); 8482 } 8483 8484 struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode, 8485 int wait, int delay_iput) 8486 { 8487 struct btrfs_delalloc_work *work; 8488 8489 work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS); 8490 if (!work) 8491 return NULL; 8492 8493 init_completion(&work->completion); 8494 INIT_LIST_HEAD(&work->list); 8495 work->inode = inode; 8496 work->wait = wait; 8497 work->delay_iput = delay_iput; 8498 btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL, NULL); 8499 8500 return work; 8501 } 8502 8503 void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work) 8504 { 8505 wait_for_completion(&work->completion); 8506 kmem_cache_free(btrfs_delalloc_work_cachep, work); 8507 } 8508 8509 /* 8510 * some fairly slow code that needs optimization. This walks the list 8511 * of all the inodes with pending delalloc and forces them to disk. 8512 */ 8513 static int __start_delalloc_inodes(struct btrfs_root *root, int delay_iput, 8514 int nr) 8515 { 8516 struct btrfs_inode *binode; 8517 struct inode *inode; 8518 struct btrfs_delalloc_work *work, *next; 8519 struct list_head works; 8520 struct list_head splice; 8521 int ret = 0; 8522 8523 INIT_LIST_HEAD(&works); 8524 INIT_LIST_HEAD(&splice); 8525 8526 mutex_lock(&root->delalloc_mutex); 8527 spin_lock(&root->delalloc_lock); 8528 list_splice_init(&root->delalloc_inodes, &splice); 8529 while (!list_empty(&splice)) { 8530 binode = list_entry(splice.next, struct btrfs_inode, 8531 delalloc_inodes); 8532 8533 list_move_tail(&binode->delalloc_inodes, 8534 &root->delalloc_inodes); 8535 inode = igrab(&binode->vfs_inode); 8536 if (!inode) { 8537 cond_resched_lock(&root->delalloc_lock); 8538 continue; 8539 } 8540 spin_unlock(&root->delalloc_lock); 8541 8542 work = btrfs_alloc_delalloc_work(inode, 0, delay_iput); 8543 if (unlikely(!work)) { 8544 if (delay_iput) 8545 btrfs_add_delayed_iput(inode); 8546 else 8547 iput(inode); 8548 ret = -ENOMEM; 8549 goto out; 8550 } 8551 list_add_tail(&work->list, &works); 8552 btrfs_queue_work(root->fs_info->flush_workers, 8553 &work->work); 8554 ret++; 8555 if (nr != -1 && ret >= nr) 8556 goto out; 8557 cond_resched(); 8558 spin_lock(&root->delalloc_lock); 8559 } 8560 spin_unlock(&root->delalloc_lock); 8561 8562 out: 8563 list_for_each_entry_safe(work, next, &works, list) { 8564 list_del_init(&work->list); 8565 btrfs_wait_and_free_delalloc_work(work); 8566 } 8567 8568 if (!list_empty_careful(&splice)) { 8569 spin_lock(&root->delalloc_lock); 8570 list_splice_tail(&splice, &root->delalloc_inodes); 8571 spin_unlock(&root->delalloc_lock); 8572 } 8573 mutex_unlock(&root->delalloc_mutex); 8574 return ret; 8575 } 8576 8577 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput) 8578 { 8579 int ret; 8580 8581 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) 8582 return -EROFS; 8583 8584 ret = __start_delalloc_inodes(root, delay_iput, -1); 8585 if (ret > 0) 8586 ret = 0; 8587 /* 8588 * the filemap_flush will queue IO into the worker threads, but 8589 * we have to make sure the IO is actually started and that 8590 * ordered extents get created before we return 8591 */ 8592 atomic_inc(&root->fs_info->async_submit_draining); 8593 while (atomic_read(&root->fs_info->nr_async_submits) || 8594 atomic_read(&root->fs_info->async_delalloc_pages)) { 8595 wait_event(root->fs_info->async_submit_wait, 8596 (atomic_read(&root->fs_info->nr_async_submits) == 0 && 8597 atomic_read(&root->fs_info->async_delalloc_pages) == 0)); 8598 } 8599 atomic_dec(&root->fs_info->async_submit_draining); 8600 return ret; 8601 } 8602 8603 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput, 8604 int nr) 8605 { 8606 struct btrfs_root *root; 8607 struct list_head splice; 8608 int ret; 8609 8610 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) 8611 return -EROFS; 8612 8613 INIT_LIST_HEAD(&splice); 8614 8615 mutex_lock(&fs_info->delalloc_root_mutex); 8616 spin_lock(&fs_info->delalloc_root_lock); 8617 list_splice_init(&fs_info->delalloc_roots, &splice); 8618 while (!list_empty(&splice) && nr) { 8619 root = list_first_entry(&splice, struct btrfs_root, 8620 delalloc_root); 8621 root = btrfs_grab_fs_root(root); 8622 BUG_ON(!root); 8623 list_move_tail(&root->delalloc_root, 8624 &fs_info->delalloc_roots); 8625 spin_unlock(&fs_info->delalloc_root_lock); 8626 8627 ret = __start_delalloc_inodes(root, delay_iput, nr); 8628 btrfs_put_fs_root(root); 8629 if (ret < 0) 8630 goto out; 8631 8632 if (nr != -1) { 8633 nr -= ret; 8634 WARN_ON(nr < 0); 8635 } 8636 spin_lock(&fs_info->delalloc_root_lock); 8637 } 8638 spin_unlock(&fs_info->delalloc_root_lock); 8639 8640 ret = 0; 8641 atomic_inc(&fs_info->async_submit_draining); 8642 while (atomic_read(&fs_info->nr_async_submits) || 8643 atomic_read(&fs_info->async_delalloc_pages)) { 8644 wait_event(fs_info->async_submit_wait, 8645 (atomic_read(&fs_info->nr_async_submits) == 0 && 8646 atomic_read(&fs_info->async_delalloc_pages) == 0)); 8647 } 8648 atomic_dec(&fs_info->async_submit_draining); 8649 out: 8650 if (!list_empty_careful(&splice)) { 8651 spin_lock(&fs_info->delalloc_root_lock); 8652 list_splice_tail(&splice, &fs_info->delalloc_roots); 8653 spin_unlock(&fs_info->delalloc_root_lock); 8654 } 8655 mutex_unlock(&fs_info->delalloc_root_mutex); 8656 return ret; 8657 } 8658 8659 static int btrfs_symlink(struct inode *dir, struct dentry *dentry, 8660 const char *symname) 8661 { 8662 struct btrfs_trans_handle *trans; 8663 struct btrfs_root *root = BTRFS_I(dir)->root; 8664 struct btrfs_path *path; 8665 struct btrfs_key key; 8666 struct inode *inode = NULL; 8667 int err; 8668 int drop_inode = 0; 8669 u64 objectid; 8670 u64 index = 0; 8671 int name_len; 8672 int datasize; 8673 unsigned long ptr; 8674 struct btrfs_file_extent_item *ei; 8675 struct extent_buffer *leaf; 8676 8677 name_len = strlen(symname); 8678 if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root)) 8679 return -ENAMETOOLONG; 8680 8681 /* 8682 * 2 items for inode item and ref 8683 * 2 items for dir items 8684 * 1 item for xattr if selinux is on 8685 */ 8686 trans = btrfs_start_transaction(root, 5); 8687 if (IS_ERR(trans)) 8688 return PTR_ERR(trans); 8689 8690 err = btrfs_find_free_ino(root, &objectid); 8691 if (err) 8692 goto out_unlock; 8693 8694 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name, 8695 dentry->d_name.len, btrfs_ino(dir), objectid, 8696 S_IFLNK|S_IRWXUGO, &index); 8697 if (IS_ERR(inode)) { 8698 err = PTR_ERR(inode); 8699 goto out_unlock; 8700 } 8701 8702 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); 8703 if (err) { 8704 drop_inode = 1; 8705 goto out_unlock; 8706 } 8707 8708 /* 8709 * If the active LSM wants to access the inode during 8710 * d_instantiate it needs these. Smack checks to see 8711 * if the filesystem supports xattrs by looking at the 8712 * ops vector. 8713 */ 8714 inode->i_fop = &btrfs_file_operations; 8715 inode->i_op = &btrfs_file_inode_operations; 8716 8717 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 8718 if (err) 8719 drop_inode = 1; 8720 else { 8721 inode->i_mapping->a_ops = &btrfs_aops; 8722 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 8723 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops; 8724 } 8725 if (drop_inode) 8726 goto out_unlock; 8727 8728 path = btrfs_alloc_path(); 8729 if (!path) { 8730 err = -ENOMEM; 8731 drop_inode = 1; 8732 goto out_unlock; 8733 } 8734 key.objectid = btrfs_ino(inode); 8735 key.offset = 0; 8736 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY); 8737 datasize = btrfs_file_extent_calc_inline_size(name_len); 8738 err = btrfs_insert_empty_item(trans, root, path, &key, 8739 datasize); 8740 if (err) { 8741 drop_inode = 1; 8742 btrfs_free_path(path); 8743 goto out_unlock; 8744 } 8745 leaf = path->nodes[0]; 8746 ei = btrfs_item_ptr(leaf, path->slots[0], 8747 struct btrfs_file_extent_item); 8748 btrfs_set_file_extent_generation(leaf, ei, trans->transid); 8749 btrfs_set_file_extent_type(leaf, ei, 8750 BTRFS_FILE_EXTENT_INLINE); 8751 btrfs_set_file_extent_encryption(leaf, ei, 0); 8752 btrfs_set_file_extent_compression(leaf, ei, 0); 8753 btrfs_set_file_extent_other_encoding(leaf, ei, 0); 8754 btrfs_set_file_extent_ram_bytes(leaf, ei, name_len); 8755 8756 ptr = btrfs_file_extent_inline_start(ei); 8757 write_extent_buffer(leaf, symname, ptr, name_len); 8758 btrfs_mark_buffer_dirty(leaf); 8759 btrfs_free_path(path); 8760 8761 inode->i_op = &btrfs_symlink_inode_operations; 8762 inode->i_mapping->a_ops = &btrfs_symlink_aops; 8763 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 8764 inode_set_bytes(inode, name_len); 8765 btrfs_i_size_write(inode, name_len); 8766 err = btrfs_update_inode(trans, root, inode); 8767 if (err) 8768 drop_inode = 1; 8769 8770 out_unlock: 8771 if (!err) 8772 d_instantiate(dentry, inode); 8773 btrfs_end_transaction(trans, root); 8774 if (drop_inode) { 8775 inode_dec_link_count(inode); 8776 iput(inode); 8777 } 8778 btrfs_btree_balance_dirty(root); 8779 return err; 8780 } 8781 8782 static int __btrfs_prealloc_file_range(struct inode *inode, int mode, 8783 u64 start, u64 num_bytes, u64 min_size, 8784 loff_t actual_len, u64 *alloc_hint, 8785 struct btrfs_trans_handle *trans) 8786 { 8787 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 8788 struct extent_map *em; 8789 struct btrfs_root *root = BTRFS_I(inode)->root; 8790 struct btrfs_key ins; 8791 u64 cur_offset = start; 8792 u64 i_size; 8793 u64 cur_bytes; 8794 int ret = 0; 8795 bool own_trans = true; 8796 8797 if (trans) 8798 own_trans = false; 8799 while (num_bytes > 0) { 8800 if (own_trans) { 8801 trans = btrfs_start_transaction(root, 3); 8802 if (IS_ERR(trans)) { 8803 ret = PTR_ERR(trans); 8804 break; 8805 } 8806 } 8807 8808 cur_bytes = min(num_bytes, 256ULL * 1024 * 1024); 8809 cur_bytes = max(cur_bytes, min_size); 8810 ret = btrfs_reserve_extent(root, cur_bytes, min_size, 0, 8811 *alloc_hint, &ins, 1, 0); 8812 if (ret) { 8813 if (own_trans) 8814 btrfs_end_transaction(trans, root); 8815 break; 8816 } 8817 8818 ret = insert_reserved_file_extent(trans, inode, 8819 cur_offset, ins.objectid, 8820 ins.offset, ins.offset, 8821 ins.offset, 0, 0, 0, 8822 BTRFS_FILE_EXTENT_PREALLOC); 8823 if (ret) { 8824 btrfs_free_reserved_extent(root, ins.objectid, 8825 ins.offset, 0); 8826 btrfs_abort_transaction(trans, root, ret); 8827 if (own_trans) 8828 btrfs_end_transaction(trans, root); 8829 break; 8830 } 8831 btrfs_drop_extent_cache(inode, cur_offset, 8832 cur_offset + ins.offset -1, 0); 8833 8834 em = alloc_extent_map(); 8835 if (!em) { 8836 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 8837 &BTRFS_I(inode)->runtime_flags); 8838 goto next; 8839 } 8840 8841 em->start = cur_offset; 8842 em->orig_start = cur_offset; 8843 em->len = ins.offset; 8844 em->block_start = ins.objectid; 8845 em->block_len = ins.offset; 8846 em->orig_block_len = ins.offset; 8847 em->ram_bytes = ins.offset; 8848 em->bdev = root->fs_info->fs_devices->latest_bdev; 8849 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 8850 em->generation = trans->transid; 8851 8852 while (1) { 8853 write_lock(&em_tree->lock); 8854 ret = add_extent_mapping(em_tree, em, 1); 8855 write_unlock(&em_tree->lock); 8856 if (ret != -EEXIST) 8857 break; 8858 btrfs_drop_extent_cache(inode, cur_offset, 8859 cur_offset + ins.offset - 1, 8860 0); 8861 } 8862 free_extent_map(em); 8863 next: 8864 num_bytes -= ins.offset; 8865 cur_offset += ins.offset; 8866 *alloc_hint = ins.objectid + ins.offset; 8867 8868 inode_inc_iversion(inode); 8869 inode->i_ctime = CURRENT_TIME; 8870 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC; 8871 if (!(mode & FALLOC_FL_KEEP_SIZE) && 8872 (actual_len > inode->i_size) && 8873 (cur_offset > inode->i_size)) { 8874 if (cur_offset > actual_len) 8875 i_size = actual_len; 8876 else 8877 i_size = cur_offset; 8878 i_size_write(inode, i_size); 8879 btrfs_ordered_update_i_size(inode, i_size, NULL); 8880 } 8881 8882 ret = btrfs_update_inode(trans, root, inode); 8883 8884 if (ret) { 8885 btrfs_abort_transaction(trans, root, ret); 8886 if (own_trans) 8887 btrfs_end_transaction(trans, root); 8888 break; 8889 } 8890 8891 if (own_trans) 8892 btrfs_end_transaction(trans, root); 8893 } 8894 return ret; 8895 } 8896 8897 int btrfs_prealloc_file_range(struct inode *inode, int mode, 8898 u64 start, u64 num_bytes, u64 min_size, 8899 loff_t actual_len, u64 *alloc_hint) 8900 { 8901 return __btrfs_prealloc_file_range(inode, mode, start, num_bytes, 8902 min_size, actual_len, alloc_hint, 8903 NULL); 8904 } 8905 8906 int btrfs_prealloc_file_range_trans(struct inode *inode, 8907 struct btrfs_trans_handle *trans, int mode, 8908 u64 start, u64 num_bytes, u64 min_size, 8909 loff_t actual_len, u64 *alloc_hint) 8910 { 8911 return __btrfs_prealloc_file_range(inode, mode, start, num_bytes, 8912 min_size, actual_len, alloc_hint, trans); 8913 } 8914 8915 static int btrfs_set_page_dirty(struct page *page) 8916 { 8917 return __set_page_dirty_nobuffers(page); 8918 } 8919 8920 static int btrfs_permission(struct inode *inode, int mask) 8921 { 8922 struct btrfs_root *root = BTRFS_I(inode)->root; 8923 umode_t mode = inode->i_mode; 8924 8925 if (mask & MAY_WRITE && 8926 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) { 8927 if (btrfs_root_readonly(root)) 8928 return -EROFS; 8929 if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) 8930 return -EACCES; 8931 } 8932 return generic_permission(inode, mask); 8933 } 8934 8935 static int btrfs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) 8936 { 8937 struct btrfs_trans_handle *trans; 8938 struct btrfs_root *root = BTRFS_I(dir)->root; 8939 struct inode *inode = NULL; 8940 u64 objectid; 8941 u64 index; 8942 int ret = 0; 8943 8944 /* 8945 * 5 units required for adding orphan entry 8946 */ 8947 trans = btrfs_start_transaction(root, 5); 8948 if (IS_ERR(trans)) 8949 return PTR_ERR(trans); 8950 8951 ret = btrfs_find_free_ino(root, &objectid); 8952 if (ret) 8953 goto out; 8954 8955 inode = btrfs_new_inode(trans, root, dir, NULL, 0, 8956 btrfs_ino(dir), objectid, mode, &index); 8957 if (IS_ERR(inode)) { 8958 ret = PTR_ERR(inode); 8959 inode = NULL; 8960 goto out; 8961 } 8962 8963 ret = btrfs_init_inode_security(trans, inode, dir, NULL); 8964 if (ret) 8965 goto out; 8966 8967 ret = btrfs_update_inode(trans, root, inode); 8968 if (ret) 8969 goto out; 8970 8971 inode->i_fop = &btrfs_file_operations; 8972 inode->i_op = &btrfs_file_inode_operations; 8973 8974 inode->i_mapping->a_ops = &btrfs_aops; 8975 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 8976 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops; 8977 8978 ret = btrfs_orphan_add(trans, inode); 8979 if (ret) 8980 goto out; 8981 8982 d_tmpfile(dentry, inode); 8983 mark_inode_dirty(inode); 8984 8985 out: 8986 btrfs_end_transaction(trans, root); 8987 if (ret) 8988 iput(inode); 8989 btrfs_balance_delayed_items(root); 8990 btrfs_btree_balance_dirty(root); 8991 8992 return ret; 8993 } 8994 8995 static const struct inode_operations btrfs_dir_inode_operations = { 8996 .getattr = btrfs_getattr, 8997 .lookup = btrfs_lookup, 8998 .create = btrfs_create, 8999 .unlink = btrfs_unlink, 9000 .link = btrfs_link, 9001 .mkdir = btrfs_mkdir, 9002 .rmdir = btrfs_rmdir, 9003 .rename2 = btrfs_rename2, 9004 .symlink = btrfs_symlink, 9005 .setattr = btrfs_setattr, 9006 .mknod = btrfs_mknod, 9007 .setxattr = btrfs_setxattr, 9008 .getxattr = btrfs_getxattr, 9009 .listxattr = btrfs_listxattr, 9010 .removexattr = btrfs_removexattr, 9011 .permission = btrfs_permission, 9012 .get_acl = btrfs_get_acl, 9013 .set_acl = btrfs_set_acl, 9014 .update_time = btrfs_update_time, 9015 .tmpfile = btrfs_tmpfile, 9016 }; 9017 static const struct inode_operations btrfs_dir_ro_inode_operations = { 9018 .lookup = btrfs_lookup, 9019 .permission = btrfs_permission, 9020 .get_acl = btrfs_get_acl, 9021 .set_acl = btrfs_set_acl, 9022 .update_time = btrfs_update_time, 9023 }; 9024 9025 static const struct file_operations btrfs_dir_file_operations = { 9026 .llseek = generic_file_llseek, 9027 .read = generic_read_dir, 9028 .iterate = btrfs_real_readdir, 9029 .unlocked_ioctl = btrfs_ioctl, 9030 #ifdef CONFIG_COMPAT 9031 .compat_ioctl = btrfs_ioctl, 9032 #endif 9033 .release = btrfs_release_file, 9034 .fsync = btrfs_sync_file, 9035 }; 9036 9037 static struct extent_io_ops btrfs_extent_io_ops = { 9038 .fill_delalloc = run_delalloc_range, 9039 .submit_bio_hook = btrfs_submit_bio_hook, 9040 .merge_bio_hook = btrfs_merge_bio_hook, 9041 .readpage_end_io_hook = btrfs_readpage_end_io_hook, 9042 .writepage_end_io_hook = btrfs_writepage_end_io_hook, 9043 .writepage_start_hook = btrfs_writepage_start_hook, 9044 .set_bit_hook = btrfs_set_bit_hook, 9045 .clear_bit_hook = btrfs_clear_bit_hook, 9046 .merge_extent_hook = btrfs_merge_extent_hook, 9047 .split_extent_hook = btrfs_split_extent_hook, 9048 }; 9049 9050 /* 9051 * btrfs doesn't support the bmap operation because swapfiles 9052 * use bmap to make a mapping of extents in the file. They assume 9053 * these extents won't change over the life of the file and they 9054 * use the bmap result to do IO directly to the drive. 9055 * 9056 * the btrfs bmap call would return logical addresses that aren't 9057 * suitable for IO and they also will change frequently as COW 9058 * operations happen. So, swapfile + btrfs == corruption. 9059 * 9060 * For now we're avoiding this by dropping bmap. 9061 */ 9062 static const struct address_space_operations btrfs_aops = { 9063 .readpage = btrfs_readpage, 9064 .writepage = btrfs_writepage, 9065 .writepages = btrfs_writepages, 9066 .readpages = btrfs_readpages, 9067 .direct_IO = btrfs_direct_IO, 9068 .invalidatepage = btrfs_invalidatepage, 9069 .releasepage = btrfs_releasepage, 9070 .set_page_dirty = btrfs_set_page_dirty, 9071 .error_remove_page = generic_error_remove_page, 9072 }; 9073 9074 static const struct address_space_operations btrfs_symlink_aops = { 9075 .readpage = btrfs_readpage, 9076 .writepage = btrfs_writepage, 9077 .invalidatepage = btrfs_invalidatepage, 9078 .releasepage = btrfs_releasepage, 9079 }; 9080 9081 static const struct inode_operations btrfs_file_inode_operations = { 9082 .getattr = btrfs_getattr, 9083 .setattr = btrfs_setattr, 9084 .setxattr = btrfs_setxattr, 9085 .getxattr = btrfs_getxattr, 9086 .listxattr = btrfs_listxattr, 9087 .removexattr = btrfs_removexattr, 9088 .permission = btrfs_permission, 9089 .fiemap = btrfs_fiemap, 9090 .get_acl = btrfs_get_acl, 9091 .set_acl = btrfs_set_acl, 9092 .update_time = btrfs_update_time, 9093 }; 9094 static const struct inode_operations btrfs_special_inode_operations = { 9095 .getattr = btrfs_getattr, 9096 .setattr = btrfs_setattr, 9097 .permission = btrfs_permission, 9098 .setxattr = btrfs_setxattr, 9099 .getxattr = btrfs_getxattr, 9100 .listxattr = btrfs_listxattr, 9101 .removexattr = btrfs_removexattr, 9102 .get_acl = btrfs_get_acl, 9103 .set_acl = btrfs_set_acl, 9104 .update_time = btrfs_update_time, 9105 }; 9106 static const struct inode_operations btrfs_symlink_inode_operations = { 9107 .readlink = generic_readlink, 9108 .follow_link = page_follow_link_light, 9109 .put_link = page_put_link, 9110 .getattr = btrfs_getattr, 9111 .setattr = btrfs_setattr, 9112 .permission = btrfs_permission, 9113 .setxattr = btrfs_setxattr, 9114 .getxattr = btrfs_getxattr, 9115 .listxattr = btrfs_listxattr, 9116 .removexattr = btrfs_removexattr, 9117 .update_time = btrfs_update_time, 9118 }; 9119 9120 const struct dentry_operations btrfs_dentry_operations = { 9121 .d_delete = btrfs_dentry_delete, 9122 .d_release = btrfs_dentry_release, 9123 }; 9124