aboutsummaryrefslogtreecommitdiffstats
path: root/fs/btrfs/inode.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/btrfs/inode.c')
-rw-r--r--fs/btrfs/inode.c936
1 files changed, 580 insertions, 356 deletions
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index a3798a3aa0d2..fcd66b6a8086 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -50,6 +50,7 @@
50#include "tree-log.h" 50#include "tree-log.h"
51#include "compression.h" 51#include "compression.h"
52#include "locking.h" 52#include "locking.h"
53#include "free-space-cache.h"
53 54
54struct btrfs_iget_args { 55struct btrfs_iget_args {
55 u64 ino; 56 u64 ino;
@@ -70,6 +71,7 @@ static struct kmem_cache *btrfs_inode_cachep;
70struct kmem_cache *btrfs_trans_handle_cachep; 71struct kmem_cache *btrfs_trans_handle_cachep;
71struct kmem_cache *btrfs_transaction_cachep; 72struct kmem_cache *btrfs_transaction_cachep;
72struct kmem_cache *btrfs_path_cachep; 73struct kmem_cache *btrfs_path_cachep;
74struct kmem_cache *btrfs_free_space_cachep;
73 75
74#define S_SHIFT 12 76#define S_SHIFT 12
75static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = { 77static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
@@ -82,7 +84,8 @@ static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
82 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK, 84 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
83}; 85};
84 86
85static void btrfs_truncate(struct inode *inode); 87static int btrfs_setsize(struct inode *inode, loff_t newsize);
88static int btrfs_truncate(struct inode *inode);
86static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end); 89static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
87static noinline int cow_file_range(struct inode *inode, 90static noinline int cow_file_range(struct inode *inode,
88 struct page *locked_page, 91 struct page *locked_page,
@@ -90,13 +93,14 @@ static noinline int cow_file_range(struct inode *inode,
90 unsigned long *nr_written, int unlock); 93 unsigned long *nr_written, int unlock);
91 94
92static int btrfs_init_inode_security(struct btrfs_trans_handle *trans, 95static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
93 struct inode *inode, struct inode *dir) 96 struct inode *inode, struct inode *dir,
97 const struct qstr *qstr)
94{ 98{
95 int err; 99 int err;
96 100
97 err = btrfs_init_acl(trans, inode, dir); 101 err = btrfs_init_acl(trans, inode, dir);
98 if (!err) 102 if (!err)
99 err = btrfs_xattr_security_init(trans, inode, dir); 103 err = btrfs_xattr_security_init(trans, inode, dir, qstr);
100 return err; 104 return err;
101} 105}
102 106
@@ -108,6 +112,7 @@ static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
108static noinline int insert_inline_extent(struct btrfs_trans_handle *trans, 112static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
109 struct btrfs_root *root, struct inode *inode, 113 struct btrfs_root *root, struct inode *inode,
110 u64 start, size_t size, size_t compressed_size, 114 u64 start, size_t size, size_t compressed_size,
115 int compress_type,
111 struct page **compressed_pages) 116 struct page **compressed_pages)
112{ 117{
113 struct btrfs_key key; 118 struct btrfs_key key;
@@ -122,12 +127,9 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
122 size_t cur_size = size; 127 size_t cur_size = size;
123 size_t datasize; 128 size_t datasize;
124 unsigned long offset; 129 unsigned long offset;
125 int use_compress = 0;
126 130
127 if (compressed_size && compressed_pages) { 131 if (compressed_size && compressed_pages)
128 use_compress = 1;
129 cur_size = compressed_size; 132 cur_size = compressed_size;
130 }
131 133
132 path = btrfs_alloc_path(); 134 path = btrfs_alloc_path();
133 if (!path) 135 if (!path)
@@ -159,7 +161,7 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
159 btrfs_set_file_extent_ram_bytes(leaf, ei, size); 161 btrfs_set_file_extent_ram_bytes(leaf, ei, size);
160 ptr = btrfs_file_extent_inline_start(ei); 162 ptr = btrfs_file_extent_inline_start(ei);
161 163
162 if (use_compress) { 164 if (compress_type != BTRFS_COMPRESS_NONE) {
163 struct page *cpage; 165 struct page *cpage;
164 int i = 0; 166 int i = 0;
165 while (compressed_size > 0) { 167 while (compressed_size > 0) {
@@ -176,7 +178,7 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
176 compressed_size -= cur_size; 178 compressed_size -= cur_size;
177 } 179 }
178 btrfs_set_file_extent_compression(leaf, ei, 180 btrfs_set_file_extent_compression(leaf, ei,
179 BTRFS_COMPRESS_ZLIB); 181 compress_type);
180 } else { 182 } else {
181 page = find_get_page(inode->i_mapping, 183 page = find_get_page(inode->i_mapping,
182 start >> PAGE_CACHE_SHIFT); 184 start >> PAGE_CACHE_SHIFT);
@@ -217,7 +219,7 @@ fail:
217static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans, 219static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
218 struct btrfs_root *root, 220 struct btrfs_root *root,
219 struct inode *inode, u64 start, u64 end, 221 struct inode *inode, u64 start, u64 end,
220 size_t compressed_size, 222 size_t compressed_size, int compress_type,
221 struct page **compressed_pages) 223 struct page **compressed_pages)
222{ 224{
223 u64 isize = i_size_read(inode); 225 u64 isize = i_size_read(inode);
@@ -250,7 +252,7 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
250 inline_len = min_t(u64, isize, actual_end); 252 inline_len = min_t(u64, isize, actual_end);
251 ret = insert_inline_extent(trans, root, inode, start, 253 ret = insert_inline_extent(trans, root, inode, start,
252 inline_len, compressed_size, 254 inline_len, compressed_size,
253 compressed_pages); 255 compress_type, compressed_pages);
254 BUG_ON(ret); 256 BUG_ON(ret);
255 btrfs_delalloc_release_metadata(inode, end + 1 - start); 257 btrfs_delalloc_release_metadata(inode, end + 1 - start);
256 btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0); 258 btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
@@ -263,6 +265,7 @@ struct async_extent {
263 u64 compressed_size; 265 u64 compressed_size;
264 struct page **pages; 266 struct page **pages;
265 unsigned long nr_pages; 267 unsigned long nr_pages;
268 int compress_type;
266 struct list_head list; 269 struct list_head list;
267}; 270};
268 271
@@ -280,16 +283,19 @@ static noinline int add_async_extent(struct async_cow *cow,
280 u64 start, u64 ram_size, 283 u64 start, u64 ram_size,
281 u64 compressed_size, 284 u64 compressed_size,
282 struct page **pages, 285 struct page **pages,
283 unsigned long nr_pages) 286 unsigned long nr_pages,
287 int compress_type)
284{ 288{
285 struct async_extent *async_extent; 289 struct async_extent *async_extent;
286 290
287 async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS); 291 async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
292 BUG_ON(!async_extent);
288 async_extent->start = start; 293 async_extent->start = start;
289 async_extent->ram_size = ram_size; 294 async_extent->ram_size = ram_size;
290 async_extent->compressed_size = compressed_size; 295 async_extent->compressed_size = compressed_size;
291 async_extent->pages = pages; 296 async_extent->pages = pages;
292 async_extent->nr_pages = nr_pages; 297 async_extent->nr_pages = nr_pages;
298 async_extent->compress_type = compress_type;
293 list_add_tail(&async_extent->list, &cow->extents); 299 list_add_tail(&async_extent->list, &cow->extents);
294 return 0; 300 return 0;
295} 301}
@@ -332,6 +338,7 @@ static noinline int compress_file_range(struct inode *inode,
332 unsigned long max_uncompressed = 128 * 1024; 338 unsigned long max_uncompressed = 128 * 1024;
333 int i; 339 int i;
334 int will_compress; 340 int will_compress;
341 int compress_type = root->fs_info->compress_type;
335 342
336 actual_end = min_t(u64, isize, end + 1); 343 actual_end = min_t(u64, isize, end + 1);
337again: 344again:
@@ -377,16 +384,22 @@ again:
377 */ 384 */
378 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) && 385 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
379 (btrfs_test_opt(root, COMPRESS) || 386 (btrfs_test_opt(root, COMPRESS) ||
380 (BTRFS_I(inode)->force_compress))) { 387 (BTRFS_I(inode)->force_compress) ||
388 (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
381 WARN_ON(pages); 389 WARN_ON(pages);
382 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS); 390 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
391 BUG_ON(!pages);
392
393 if (BTRFS_I(inode)->force_compress)
394 compress_type = BTRFS_I(inode)->force_compress;
383 395
384 ret = btrfs_zlib_compress_pages(inode->i_mapping, start, 396 ret = btrfs_compress_pages(compress_type,
385 total_compressed, pages, 397 inode->i_mapping, start,
386 nr_pages, &nr_pages_ret, 398 total_compressed, pages,
387 &total_in, 399 nr_pages, &nr_pages_ret,
388 &total_compressed, 400 &total_in,
389 max_compressed); 401 &total_compressed,
402 max_compressed);
390 403
391 if (!ret) { 404 if (!ret) {
392 unsigned long offset = total_compressed & 405 unsigned long offset = total_compressed &
@@ -408,7 +421,7 @@ again:
408 } 421 }
409 if (start == 0) { 422 if (start == 0) {
410 trans = btrfs_join_transaction(root, 1); 423 trans = btrfs_join_transaction(root, 1);
411 BUG_ON(!trans); 424 BUG_ON(IS_ERR(trans));
412 btrfs_set_trans_block_group(trans, inode); 425 btrfs_set_trans_block_group(trans, inode);
413 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 426 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
414 427
@@ -418,12 +431,13 @@ again:
418 * to make an uncompressed inline extent. 431 * to make an uncompressed inline extent.
419 */ 432 */
420 ret = cow_file_range_inline(trans, root, inode, 433 ret = cow_file_range_inline(trans, root, inode,
421 start, end, 0, NULL); 434 start, end, 0, 0, NULL);
422 } else { 435 } else {
423 /* try making a compressed inline extent */ 436 /* try making a compressed inline extent */
424 ret = cow_file_range_inline(trans, root, inode, 437 ret = cow_file_range_inline(trans, root, inode,
425 start, end, 438 start, end,
426 total_compressed, pages); 439 total_compressed,
440 compress_type, pages);
427 } 441 }
428 if (ret == 0) { 442 if (ret == 0) {
429 /* 443 /*
@@ -493,7 +507,8 @@ again:
493 * and will submit them to the elevator. 507 * and will submit them to the elevator.
494 */ 508 */
495 add_async_extent(async_cow, start, num_bytes, 509 add_async_extent(async_cow, start, num_bytes,
496 total_compressed, pages, nr_pages_ret); 510 total_compressed, pages, nr_pages_ret,
511 compress_type);
497 512
498 if (start + num_bytes < end) { 513 if (start + num_bytes < end) {
499 start += num_bytes; 514 start += num_bytes;
@@ -515,7 +530,8 @@ cleanup_and_bail_uncompressed:
515 __set_page_dirty_nobuffers(locked_page); 530 __set_page_dirty_nobuffers(locked_page);
516 /* unlocked later on in the async handlers */ 531 /* unlocked later on in the async handlers */
517 } 532 }
518 add_async_extent(async_cow, start, end - start + 1, 0, NULL, 0); 533 add_async_extent(async_cow, start, end - start + 1,
534 0, NULL, 0, BTRFS_COMPRESS_NONE);
519 *num_added += 1; 535 *num_added += 1;
520 } 536 }
521 537
@@ -602,6 +618,7 @@ retry:
602 GFP_NOFS); 618 GFP_NOFS);
603 619
604 trans = btrfs_join_transaction(root, 1); 620 trans = btrfs_join_transaction(root, 1);
621 BUG_ON(IS_ERR(trans));
605 ret = btrfs_reserve_extent(trans, root, 622 ret = btrfs_reserve_extent(trans, root,
606 async_extent->compressed_size, 623 async_extent->compressed_size,
607 async_extent->compressed_size, 624 async_extent->compressed_size,
@@ -633,6 +650,7 @@ retry:
633 async_extent->ram_size - 1, 0); 650 async_extent->ram_size - 1, 0);
634 651
635 em = alloc_extent_map(GFP_NOFS); 652 em = alloc_extent_map(GFP_NOFS);
653 BUG_ON(!em);
636 em->start = async_extent->start; 654 em->start = async_extent->start;
637 em->len = async_extent->ram_size; 655 em->len = async_extent->ram_size;
638 em->orig_start = em->start; 656 em->orig_start = em->start;
@@ -640,6 +658,7 @@ retry:
640 em->block_start = ins.objectid; 658 em->block_start = ins.objectid;
641 em->block_len = ins.offset; 659 em->block_len = ins.offset;
642 em->bdev = root->fs_info->fs_devices->latest_bdev; 660 em->bdev = root->fs_info->fs_devices->latest_bdev;
661 em->compress_type = async_extent->compress_type;
643 set_bit(EXTENT_FLAG_PINNED, &em->flags); 662 set_bit(EXTENT_FLAG_PINNED, &em->flags);
644 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 663 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
645 664
@@ -656,11 +675,13 @@ retry:
656 async_extent->ram_size - 1, 0); 675 async_extent->ram_size - 1, 0);
657 } 676 }
658 677
659 ret = btrfs_add_ordered_extent(inode, async_extent->start, 678 ret = btrfs_add_ordered_extent_compress(inode,
660 ins.objectid, 679 async_extent->start,
661 async_extent->ram_size, 680 ins.objectid,
662 ins.offset, 681 async_extent->ram_size,
663 BTRFS_ORDERED_COMPRESSED); 682 ins.offset,
683 BTRFS_ORDERED_COMPRESSED,
684 async_extent->compress_type);
664 BUG_ON(ret); 685 BUG_ON(ret);
665 686
666 /* 687 /*
@@ -758,7 +779,7 @@ static noinline int cow_file_range(struct inode *inode,
758 779
759 BUG_ON(root == root->fs_info->tree_root); 780 BUG_ON(root == root->fs_info->tree_root);
760 trans = btrfs_join_transaction(root, 1); 781 trans = btrfs_join_transaction(root, 1);
761 BUG_ON(!trans); 782 BUG_ON(IS_ERR(trans));
762 btrfs_set_trans_block_group(trans, inode); 783 btrfs_set_trans_block_group(trans, inode);
763 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 784 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
764 785
@@ -770,7 +791,7 @@ static noinline int cow_file_range(struct inode *inode,
770 if (start == 0) { 791 if (start == 0) {
771 /* lets try to make an inline extent */ 792 /* lets try to make an inline extent */
772 ret = cow_file_range_inline(trans, root, inode, 793 ret = cow_file_range_inline(trans, root, inode,
773 start, end, 0, NULL); 794 start, end, 0, 0, NULL);
774 if (ret == 0) { 795 if (ret == 0) {
775 extent_clear_unlock_delalloc(inode, 796 extent_clear_unlock_delalloc(inode,
776 &BTRFS_I(inode)->io_tree, 797 &BTRFS_I(inode)->io_tree,
@@ -806,6 +827,7 @@ static noinline int cow_file_range(struct inode *inode,
806 BUG_ON(ret); 827 BUG_ON(ret);
807 828
808 em = alloc_extent_map(GFP_NOFS); 829 em = alloc_extent_map(GFP_NOFS);
830 BUG_ON(!em);
809 em->start = start; 831 em->start = start;
810 em->orig_start = em->start; 832 em->orig_start = em->start;
811 ram_size = ins.offset; 833 ram_size = ins.offset;
@@ -1036,7 +1058,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
1036 } else { 1058 } else {
1037 trans = btrfs_join_transaction(root, 1); 1059 trans = btrfs_join_transaction(root, 1);
1038 } 1060 }
1039 BUG_ON(!trans); 1061 BUG_ON(IS_ERR(trans));
1040 1062
1041 cow_start = (u64)-1; 1063 cow_start = (u64)-1;
1042 cur_offset = start; 1064 cur_offset = start;
@@ -1155,6 +1177,7 @@ out_check:
1155 struct extent_map_tree *em_tree; 1177 struct extent_map_tree *em_tree;
1156 em_tree = &BTRFS_I(inode)->extent_tree; 1178 em_tree = &BTRFS_I(inode)->extent_tree;
1157 em = alloc_extent_map(GFP_NOFS); 1179 em = alloc_extent_map(GFP_NOFS);
1180 BUG_ON(!em);
1158 em->start = cur_offset; 1181 em->start = cur_offset;
1159 em->orig_start = em->start; 1182 em->orig_start = em->start;
1160 em->len = num_bytes; 1183 em->len = num_bytes;
@@ -1236,7 +1259,8 @@ static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1236 ret = run_delalloc_nocow(inode, locked_page, start, end, 1259 ret = run_delalloc_nocow(inode, locked_page, start, end,
1237 page_started, 0, nr_written); 1260 page_started, 0, nr_written);
1238 else if (!btrfs_test_opt(root, COMPRESS) && 1261 else if (!btrfs_test_opt(root, COMPRESS) &&
1239 !(BTRFS_I(inode)->force_compress)) 1262 !(BTRFS_I(inode)->force_compress) &&
1263 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))
1240 ret = cow_file_range(inode, locked_page, start, end, 1264 ret = cow_file_range(inode, locked_page, start, end,
1241 page_started, nr_written, 1); 1265 page_started, nr_written, 1);
1242 else 1266 else
@@ -1443,8 +1467,11 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1443 if (bio_flags & EXTENT_BIO_COMPRESSED) { 1467 if (bio_flags & EXTENT_BIO_COMPRESSED) {
1444 return btrfs_submit_compressed_read(inode, bio, 1468 return btrfs_submit_compressed_read(inode, bio,
1445 mirror_num, bio_flags); 1469 mirror_num, bio_flags);
1446 } else if (!skip_sum) 1470 } else if (!skip_sum) {
1447 btrfs_lookup_bio_sums(root, inode, bio, NULL); 1471 ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
1472 if (ret)
1473 return ret;
1474 }
1448 goto mapit; 1475 goto mapit;
1449 } else if (!skip_sum) { 1476 } else if (!skip_sum) {
1450 /* csum items have already been cloned */ 1477 /* csum items have already been cloned */
@@ -1544,6 +1571,7 @@ out:
1544out_page: 1571out_page:
1545 unlock_page(page); 1572 unlock_page(page);
1546 page_cache_release(page); 1573 page_cache_release(page);
1574 kfree(fixup);
1547} 1575}
1548 1576
1549/* 1577/*
@@ -1670,7 +1698,7 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1670 struct btrfs_ordered_extent *ordered_extent = NULL; 1698 struct btrfs_ordered_extent *ordered_extent = NULL;
1671 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 1699 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1672 struct extent_state *cached_state = NULL; 1700 struct extent_state *cached_state = NULL;
1673 int compressed = 0; 1701 int compress_type = 0;
1674 int ret; 1702 int ret;
1675 bool nolock = false; 1703 bool nolock = false;
1676 1704
@@ -1690,7 +1718,7 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1690 trans = btrfs_join_transaction_nolock(root, 1); 1718 trans = btrfs_join_transaction_nolock(root, 1);
1691 else 1719 else
1692 trans = btrfs_join_transaction(root, 1); 1720 trans = btrfs_join_transaction(root, 1);
1693 BUG_ON(!trans); 1721 BUG_ON(IS_ERR(trans));
1694 btrfs_set_trans_block_group(trans, inode); 1722 btrfs_set_trans_block_group(trans, inode);
1695 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 1723 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1696 ret = btrfs_update_inode(trans, root, inode); 1724 ret = btrfs_update_inode(trans, root, inode);
@@ -1707,13 +1735,14 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1707 trans = btrfs_join_transaction_nolock(root, 1); 1735 trans = btrfs_join_transaction_nolock(root, 1);
1708 else 1736 else
1709 trans = btrfs_join_transaction(root, 1); 1737 trans = btrfs_join_transaction(root, 1);
1738 BUG_ON(IS_ERR(trans));
1710 btrfs_set_trans_block_group(trans, inode); 1739 btrfs_set_trans_block_group(trans, inode);
1711 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 1740 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1712 1741
1713 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) 1742 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
1714 compressed = 1; 1743 compress_type = ordered_extent->compress_type;
1715 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { 1744 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1716 BUG_ON(compressed); 1745 BUG_ON(compress_type);
1717 ret = btrfs_mark_extent_written(trans, inode, 1746 ret = btrfs_mark_extent_written(trans, inode,
1718 ordered_extent->file_offset, 1747 ordered_extent->file_offset,
1719 ordered_extent->file_offset + 1748 ordered_extent->file_offset +
@@ -1727,7 +1756,7 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1727 ordered_extent->disk_len, 1756 ordered_extent->disk_len,
1728 ordered_extent->len, 1757 ordered_extent->len,
1729 ordered_extent->len, 1758 ordered_extent->len,
1730 compressed, 0, 0, 1759 compress_type, 0, 0,
1731 BTRFS_FILE_EXTENT_REG); 1760 BTRFS_FILE_EXTENT_REG);
1732 unpin_extent_cache(&BTRFS_I(inode)->extent_tree, 1761 unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
1733 ordered_extent->file_offset, 1762 ordered_extent->file_offset,
@@ -1741,9 +1770,12 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1741 add_pending_csums(trans, inode, ordered_extent->file_offset, 1770 add_pending_csums(trans, inode, ordered_extent->file_offset,
1742 &ordered_extent->list); 1771 &ordered_extent->list);
1743 1772
1744 btrfs_ordered_update_i_size(inode, 0, ordered_extent); 1773 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1745 ret = btrfs_update_inode(trans, root, inode); 1774 if (!ret) {
1746 BUG_ON(ret); 1775 ret = btrfs_update_inode(trans, root, inode);
1776 BUG_ON(ret);
1777 }
1778 ret = 0;
1747out: 1779out:
1748 if (nolock) { 1780 if (nolock) {
1749 if (trans) 1781 if (trans)
@@ -1765,6 +1797,8 @@ out:
1765static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end, 1797static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1766 struct extent_state *state, int uptodate) 1798 struct extent_state *state, int uptodate)
1767{ 1799{
1800 trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
1801
1768 ClearPagePrivate2(page); 1802 ClearPagePrivate2(page);
1769 return btrfs_finish_ordered_io(page->mapping->host, start, end); 1803 return btrfs_finish_ordered_io(page->mapping->host, start, end);
1770} 1804}
@@ -1829,6 +1863,8 @@ static int btrfs_io_failed_hook(struct bio *failed_bio,
1829 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { 1863 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
1830 logical = em->block_start; 1864 logical = em->block_start;
1831 failrec->bio_flags = EXTENT_BIO_COMPRESSED; 1865 failrec->bio_flags = EXTENT_BIO_COMPRESSED;
1866 extent_set_compress_type(&failrec->bio_flags,
1867 em->compress_type);
1832 } 1868 }
1833 failrec->logical = logical; 1869 failrec->logical = logical;
1834 free_extent_map(em); 1870 free_extent_map(em);
@@ -1873,10 +1909,10 @@ static int btrfs_io_failed_hook(struct bio *failed_bio,
1873 else 1909 else
1874 rw = READ; 1910 rw = READ;
1875 1911
1876 BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio, 1912 ret = BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
1877 failrec->last_mirror, 1913 failrec->last_mirror,
1878 failrec->bio_flags, 0); 1914 failrec->bio_flags, 0);
1879 return 0; 1915 return ret;
1880} 1916}
1881 1917
1882/* 1918/*
@@ -1892,7 +1928,7 @@ static int btrfs_clean_io_failures(struct inode *inode, u64 start)
1892 1928
1893 private = 0; 1929 private = 0;
1894 if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private, 1930 if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
1895 (u64)-1, 1, EXTENT_DIRTY)) { 1931 (u64)-1, 1, EXTENT_DIRTY, 0)) {
1896 ret = get_state_private(&BTRFS_I(inode)->io_failure_tree, 1932 ret = get_state_private(&BTRFS_I(inode)->io_failure_tree,
1897 start, &private_failure); 1933 start, &private_failure);
1898 if (ret == 0) { 1934 if (ret == 0) {
@@ -2188,8 +2224,6 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
2188 insert = 1; 2224 insert = 1;
2189#endif 2225#endif
2190 insert = 1; 2226 insert = 1;
2191 } else {
2192 WARN_ON(!BTRFS_I(inode)->orphan_meta_reserved);
2193 } 2227 }
2194 2228
2195 if (!BTRFS_I(inode)->orphan_meta_reserved) { 2229 if (!BTRFS_I(inode)->orphan_meta_reserved) {
@@ -2260,7 +2294,7 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
2260 * this cleans up any orphans that may be left on the list from the last use 2294 * this cleans up any orphans that may be left on the list from the last use
2261 * of this root. 2295 * of this root.
2262 */ 2296 */
2263void btrfs_orphan_cleanup(struct btrfs_root *root) 2297int btrfs_orphan_cleanup(struct btrfs_root *root)
2264{ 2298{
2265 struct btrfs_path *path; 2299 struct btrfs_path *path;
2266 struct extent_buffer *leaf; 2300 struct extent_buffer *leaf;
@@ -2270,10 +2304,13 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
2270 int ret = 0, nr_unlink = 0, nr_truncate = 0; 2304 int ret = 0, nr_unlink = 0, nr_truncate = 0;
2271 2305
2272 if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED)) 2306 if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
2273 return; 2307 return 0;
2274 2308
2275 path = btrfs_alloc_path(); 2309 path = btrfs_alloc_path();
2276 BUG_ON(!path); 2310 if (!path) {
2311 ret = -ENOMEM;
2312 goto out;
2313 }
2277 path->reada = -1; 2314 path->reada = -1;
2278 2315
2279 key.objectid = BTRFS_ORPHAN_OBJECTID; 2316 key.objectid = BTRFS_ORPHAN_OBJECTID;
@@ -2282,18 +2319,16 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
2282 2319
2283 while (1) { 2320 while (1) {
2284 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 2321 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2285 if (ret < 0) { 2322 if (ret < 0)
2286 printk(KERN_ERR "Error searching slot for orphan: %d" 2323 goto out;
2287 "\n", ret);
2288 break;
2289 }
2290 2324
2291 /* 2325 /*
2292 * if ret == 0 means we found what we were searching for, which 2326 * if ret == 0 means we found what we were searching for, which
2293 * is weird, but possible, so only screw with path if we didnt 2327 * is weird, but possible, so only screw with path if we didn't
2294 * find the key and see if we have stuff that matches 2328 * find the key and see if we have stuff that matches
2295 */ 2329 */
2296 if (ret > 0) { 2330 if (ret > 0) {
2331 ret = 0;
2297 if (path->slots[0] == 0) 2332 if (path->slots[0] == 0)
2298 break; 2333 break;
2299 path->slots[0]--; 2334 path->slots[0]--;
@@ -2321,7 +2356,10 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
2321 found_key.type = BTRFS_INODE_ITEM_KEY; 2356 found_key.type = BTRFS_INODE_ITEM_KEY;
2322 found_key.offset = 0; 2357 found_key.offset = 0;
2323 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL); 2358 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
2324 BUG_ON(IS_ERR(inode)); 2359 if (IS_ERR(inode)) {
2360 ret = PTR_ERR(inode);
2361 goto out;
2362 }
2325 2363
2326 /* 2364 /*
2327 * add this inode to the orphan list so btrfs_orphan_del does 2365 * add this inode to the orphan list so btrfs_orphan_del does
@@ -2339,6 +2377,10 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
2339 */ 2377 */
2340 if (is_bad_inode(inode)) { 2378 if (is_bad_inode(inode)) {
2341 trans = btrfs_start_transaction(root, 0); 2379 trans = btrfs_start_transaction(root, 0);
2380 if (IS_ERR(trans)) {
2381 ret = PTR_ERR(trans);
2382 goto out;
2383 }
2342 btrfs_orphan_del(trans, inode); 2384 btrfs_orphan_del(trans, inode);
2343 btrfs_end_transaction(trans, root); 2385 btrfs_end_transaction(trans, root);
2344 iput(inode); 2386 iput(inode);
@@ -2347,17 +2389,22 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
2347 2389
2348 /* if we have links, this was a truncate, lets do that */ 2390 /* if we have links, this was a truncate, lets do that */
2349 if (inode->i_nlink) { 2391 if (inode->i_nlink) {
2392 if (!S_ISREG(inode->i_mode)) {
2393 WARN_ON(1);
2394 iput(inode);
2395 continue;
2396 }
2350 nr_truncate++; 2397 nr_truncate++;
2351 btrfs_truncate(inode); 2398 ret = btrfs_truncate(inode);
2352 } else { 2399 } else {
2353 nr_unlink++; 2400 nr_unlink++;
2354 } 2401 }
2355 2402
2356 /* this will do delete_inode and everything for us */ 2403 /* this will do delete_inode and everything for us */
2357 iput(inode); 2404 iput(inode);
2405 if (ret)
2406 goto out;
2358 } 2407 }
2359 btrfs_free_path(path);
2360
2361 root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE; 2408 root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
2362 2409
2363 if (root->orphan_block_rsv) 2410 if (root->orphan_block_rsv)
@@ -2366,13 +2413,20 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
2366 2413
2367 if (root->orphan_block_rsv || root->orphan_item_inserted) { 2414 if (root->orphan_block_rsv || root->orphan_item_inserted) {
2368 trans = btrfs_join_transaction(root, 1); 2415 trans = btrfs_join_transaction(root, 1);
2369 btrfs_end_transaction(trans, root); 2416 if (!IS_ERR(trans))
2417 btrfs_end_transaction(trans, root);
2370 } 2418 }
2371 2419
2372 if (nr_unlink) 2420 if (nr_unlink)
2373 printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink); 2421 printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
2374 if (nr_truncate) 2422 if (nr_truncate)
2375 printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate); 2423 printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
2424
2425out:
2426 if (ret)
2427 printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
2428 btrfs_free_path(path);
2429 return ret;
2376} 2430}
2377 2431
2378/* 2432/*
@@ -2539,6 +2593,13 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
2539 struct btrfs_inode_item *item, 2593 struct btrfs_inode_item *item,
2540 struct inode *inode) 2594 struct inode *inode)
2541{ 2595{
2596 if (!leaf->map_token)
2597 map_private_extent_buffer(leaf, (unsigned long)item,
2598 sizeof(struct btrfs_inode_item),
2599 &leaf->map_token, &leaf->kaddr,
2600 &leaf->map_start, &leaf->map_len,
2601 KM_USER1);
2602
2542 btrfs_set_inode_uid(leaf, item, inode->i_uid); 2603 btrfs_set_inode_uid(leaf, item, inode->i_uid);
2543 btrfs_set_inode_gid(leaf, item, inode->i_gid); 2604 btrfs_set_inode_gid(leaf, item, inode->i_gid);
2544 btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size); 2605 btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
@@ -2567,6 +2628,11 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
2567 btrfs_set_inode_rdev(leaf, item, inode->i_rdev); 2628 btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
2568 btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags); 2629 btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2569 btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group); 2630 btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group);
2631
2632 if (leaf->map_token) {
2633 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
2634 leaf->map_token = NULL;
2635 }
2570} 2636}
2571 2637
2572/* 2638/*
@@ -2611,10 +2677,10 @@ failed:
2611 * recovery code. It remove a link in a directory with a given name, and 2677 * recovery code. It remove a link in a directory with a given name, and
2612 * also drops the back refs in the inode to the directory 2678 * also drops the back refs in the inode to the directory
2613 */ 2679 */
2614int btrfs_unlink_inode(struct btrfs_trans_handle *trans, 2680static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2615 struct btrfs_root *root, 2681 struct btrfs_root *root,
2616 struct inode *dir, struct inode *inode, 2682 struct inode *dir, struct inode *inode,
2617 const char *name, int name_len) 2683 const char *name, int name_len)
2618{ 2684{
2619 struct btrfs_path *path; 2685 struct btrfs_path *path;
2620 int ret = 0; 2686 int ret = 0;
@@ -2626,7 +2692,7 @@ int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2626 path = btrfs_alloc_path(); 2692 path = btrfs_alloc_path();
2627 if (!path) { 2693 if (!path) {
2628 ret = -ENOMEM; 2694 ret = -ENOMEM;
2629 goto err; 2695 goto out;
2630 } 2696 }
2631 2697
2632 path->leave_spinning = 1; 2698 path->leave_spinning = 1;
@@ -2686,12 +2752,25 @@ err:
2686 btrfs_i_size_write(dir, dir->i_size - name_len * 2); 2752 btrfs_i_size_write(dir, dir->i_size - name_len * 2);
2687 inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME; 2753 inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
2688 btrfs_update_inode(trans, root, dir); 2754 btrfs_update_inode(trans, root, dir);
2689 btrfs_drop_nlink(inode);
2690 ret = btrfs_update_inode(trans, root, inode);
2691out: 2755out:
2692 return ret; 2756 return ret;
2693} 2757}
2694 2758
2759int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2760 struct btrfs_root *root,
2761 struct inode *dir, struct inode *inode,
2762 const char *name, int name_len)
2763{
2764 int ret;
2765 ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
2766 if (!ret) {
2767 btrfs_drop_nlink(inode);
2768 ret = btrfs_update_inode(trans, root, inode);
2769 }
2770 return ret;
2771}
2772
2773
2695/* helper to check if there is any shared block in the path */ 2774/* helper to check if there is any shared block in the path */
2696static int check_path_shared(struct btrfs_root *root, 2775static int check_path_shared(struct btrfs_root *root,
2697 struct btrfs_path *path) 2776 struct btrfs_path *path)
@@ -2699,9 +2778,10 @@ static int check_path_shared(struct btrfs_root *root,
2699 struct extent_buffer *eb; 2778 struct extent_buffer *eb;
2700 int level; 2779 int level;
2701 u64 refs = 1; 2780 u64 refs = 1;
2702 int uninitialized_var(ret);
2703 2781
2704 for (level = 0; level < BTRFS_MAX_LEVEL; level++) { 2782 for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
2783 int ret;
2784
2705 if (!path->nodes[level]) 2785 if (!path->nodes[level])
2706 break; 2786 break;
2707 eb = path->nodes[level]; 2787 eb = path->nodes[level];
@@ -2712,7 +2792,7 @@ static int check_path_shared(struct btrfs_root *root,
2712 if (refs > 1) 2792 if (refs > 1)
2713 return 1; 2793 return 1;
2714 } 2794 }
2715 return ret; /* XXX callers? */ 2795 return 0;
2716} 2796}
2717 2797
2718/* 2798/*
@@ -3512,7 +3592,13 @@ out:
3512 return ret; 3592 return ret;
3513} 3593}
3514 3594
3515int btrfs_cont_expand(struct inode *inode, loff_t size) 3595/*
3596 * This function puts in dummy file extents for the area we're creating a hole
3597 * for. So if we are truncating this file to a larger size we need to insert
3598 * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for
3599 * the range between oldsize and size
3600 */
3601int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
3516{ 3602{
3517 struct btrfs_trans_handle *trans; 3603 struct btrfs_trans_handle *trans;
3518 struct btrfs_root *root = BTRFS_I(inode)->root; 3604 struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -3520,7 +3606,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
3520 struct extent_map *em = NULL; 3606 struct extent_map *em = NULL;
3521 struct extent_state *cached_state = NULL; 3607 struct extent_state *cached_state = NULL;
3522 u64 mask = root->sectorsize - 1; 3608 u64 mask = root->sectorsize - 1;
3523 u64 hole_start = (inode->i_size + mask) & ~mask; 3609 u64 hole_start = (oldsize + mask) & ~mask;
3524 u64 block_end = (size + mask) & ~mask; 3610 u64 block_end = (size + mask) & ~mask;
3525 u64 last_byte; 3611 u64 last_byte;
3526 u64 cur_offset; 3612 u64 cur_offset;
@@ -3565,13 +3651,15 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
3565 err = btrfs_drop_extents(trans, inode, cur_offset, 3651 err = btrfs_drop_extents(trans, inode, cur_offset,
3566 cur_offset + hole_size, 3652 cur_offset + hole_size,
3567 &hint_byte, 1); 3653 &hint_byte, 1);
3568 BUG_ON(err); 3654 if (err)
3655 break;
3569 3656
3570 err = btrfs_insert_file_extent(trans, root, 3657 err = btrfs_insert_file_extent(trans, root,
3571 inode->i_ino, cur_offset, 0, 3658 inode->i_ino, cur_offset, 0,
3572 0, hole_size, 0, hole_size, 3659 0, hole_size, 0, hole_size,
3573 0, 0, 0); 3660 0, 0, 0);
3574 BUG_ON(err); 3661 if (err)
3662 break;
3575 3663
3576 btrfs_drop_extent_cache(inode, hole_start, 3664 btrfs_drop_extent_cache(inode, hole_start,
3577 last_byte - 1, 0); 3665 last_byte - 1, 0);
@@ -3591,94 +3679,58 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
3591 return err; 3679 return err;
3592} 3680}
3593 3681
3594static int btrfs_setattr_size(struct inode *inode, struct iattr *attr) 3682static int btrfs_setsize(struct inode *inode, loff_t newsize)
3595{ 3683{
3596 struct btrfs_root *root = BTRFS_I(inode)->root; 3684 loff_t oldsize = i_size_read(inode);
3597 struct btrfs_trans_handle *trans;
3598 unsigned long nr;
3599 int ret; 3685 int ret;
3600 3686
3601 if (attr->ia_size == inode->i_size) 3687 if (newsize == oldsize)
3602 return 0; 3688 return 0;
3603 3689
3604 if (attr->ia_size > inode->i_size) { 3690 if (newsize > oldsize) {
3605 unsigned long limit; 3691 i_size_write(inode, newsize);
3606 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur; 3692 btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
3607 if (attr->ia_size > inode->i_sb->s_maxbytes) 3693 truncate_pagecache(inode, oldsize, newsize);
3608 return -EFBIG; 3694 ret = btrfs_cont_expand(inode, oldsize, newsize);
3609 if (limit != RLIM_INFINITY && attr->ia_size > limit) {
3610 send_sig(SIGXFSZ, current, 0);
3611 return -EFBIG;
3612 }
3613 }
3614
3615 trans = btrfs_start_transaction(root, 5);
3616 if (IS_ERR(trans))
3617 return PTR_ERR(trans);
3618
3619 btrfs_set_trans_block_group(trans, inode);
3620
3621 ret = btrfs_orphan_add(trans, inode);
3622 BUG_ON(ret);
3623
3624 nr = trans->blocks_used;
3625 btrfs_end_transaction(trans, root);
3626 btrfs_btree_balance_dirty(root, nr);
3627
3628 if (attr->ia_size > inode->i_size) {
3629 ret = btrfs_cont_expand(inode, attr->ia_size);
3630 if (ret) { 3695 if (ret) {
3631 btrfs_truncate(inode); 3696 btrfs_setsize(inode, oldsize);
3632 return ret; 3697 return ret;
3633 } 3698 }
3634 3699
3635 i_size_write(inode, attr->ia_size); 3700 mark_inode_dirty(inode);
3636 btrfs_ordered_update_i_size(inode, inode->i_size, NULL); 3701 } else {
3637 3702
3638 trans = btrfs_start_transaction(root, 0); 3703 /*
3639 BUG_ON(IS_ERR(trans)); 3704 * We're truncating a file that used to have good data down to
3640 btrfs_set_trans_block_group(trans, inode); 3705 * zero. Make sure it gets into the ordered flush list so that
3641 trans->block_rsv = root->orphan_block_rsv; 3706 * any new writes get down to disk quickly.
3642 BUG_ON(!trans->block_rsv); 3707 */
3708 if (newsize == 0)
3709 BTRFS_I(inode)->ordered_data_close = 1;
3643 3710
3644 ret = btrfs_update_inode(trans, root, inode); 3711 /* we don't support swapfiles, so vmtruncate shouldn't fail */
3645 BUG_ON(ret); 3712 truncate_setsize(inode, newsize);
3646 if (inode->i_nlink > 0) { 3713 ret = btrfs_truncate(inode);
3647 ret = btrfs_orphan_del(trans, inode);
3648 BUG_ON(ret);
3649 }
3650 nr = trans->blocks_used;
3651 btrfs_end_transaction(trans, root);
3652 btrfs_btree_balance_dirty(root, nr);
3653 return 0;
3654 } 3714 }
3655 3715
3656 /* 3716 return ret;
3657 * We're truncating a file that used to have good data down to
3658 * zero. Make sure it gets into the ordered flush list so that
3659 * any new writes get down to disk quickly.
3660 */
3661 if (attr->ia_size == 0)
3662 BTRFS_I(inode)->ordered_data_close = 1;
3663
3664 /* we don't support swapfiles, so vmtruncate shouldn't fail */
3665 ret = vmtruncate(inode, attr->ia_size);
3666 BUG_ON(ret);
3667
3668 return 0;
3669} 3717}
3670 3718
3671static int btrfs_setattr(struct dentry *dentry, struct iattr *attr) 3719static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
3672{ 3720{
3673 struct inode *inode = dentry->d_inode; 3721 struct inode *inode = dentry->d_inode;
3722 struct btrfs_root *root = BTRFS_I(inode)->root;
3674 int err; 3723 int err;
3675 3724
3725 if (btrfs_root_readonly(root))
3726 return -EROFS;
3727
3676 err = inode_change_ok(inode, attr); 3728 err = inode_change_ok(inode, attr);
3677 if (err) 3729 if (err)
3678 return err; 3730 return err;
3679 3731
3680 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) { 3732 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
3681 err = btrfs_setattr_size(inode, attr); 3733 err = btrfs_setsize(inode, attr->ia_size);
3682 if (err) 3734 if (err)
3683 return err; 3735 return err;
3684 } 3736 }
@@ -3701,6 +3753,8 @@ void btrfs_evict_inode(struct inode *inode)
3701 unsigned long nr; 3753 unsigned long nr;
3702 int ret; 3754 int ret;
3703 3755
3756 trace_btrfs_inode_evict(inode);
3757
3704 truncate_inode_pages(&inode->i_data, 0); 3758 truncate_inode_pages(&inode->i_data, 0);
3705 if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 || 3759 if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
3706 root == root->fs_info->tree_root)) 3760 root == root->fs_info->tree_root))
@@ -4043,7 +4097,6 @@ struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
4043 BTRFS_I(inode)->root = root; 4097 BTRFS_I(inode)->root = root;
4044 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location)); 4098 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
4045 btrfs_read_locked_inode(inode); 4099 btrfs_read_locked_inode(inode);
4046
4047 inode_tree_add(inode); 4100 inode_tree_add(inode);
4048 unlock_new_inode(inode); 4101 unlock_new_inode(inode);
4049 if (new) 4102 if (new)
@@ -4115,11 +4168,13 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
4115 } 4168 }
4116 srcu_read_unlock(&root->fs_info->subvol_srcu, index); 4169 srcu_read_unlock(&root->fs_info->subvol_srcu, index);
4117 4170
4118 if (root != sub_root) { 4171 if (!IS_ERR(inode) && root != sub_root) {
4119 down_read(&root->fs_info->cleanup_work_sem); 4172 down_read(&root->fs_info->cleanup_work_sem);
4120 if (!(inode->i_sb->s_flags & MS_RDONLY)) 4173 if (!(inode->i_sb->s_flags & MS_RDONLY))
4121 btrfs_orphan_cleanup(sub_root); 4174 ret = btrfs_orphan_cleanup(sub_root);
4122 up_read(&root->fs_info->cleanup_work_sem); 4175 up_read(&root->fs_info->cleanup_work_sem);
4176 if (ret)
4177 inode = ERR_PTR(ret);
4123 } 4178 }
4124 4179
4125 return inode; 4180 return inode;
@@ -4167,10 +4222,8 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
4167 struct btrfs_key found_key; 4222 struct btrfs_key found_key;
4168 struct btrfs_path *path; 4223 struct btrfs_path *path;
4169 int ret; 4224 int ret;
4170 u32 nritems;
4171 struct extent_buffer *leaf; 4225 struct extent_buffer *leaf;
4172 int slot; 4226 int slot;
4173 int advance;
4174 unsigned char d_type; 4227 unsigned char d_type;
4175 int over = 0; 4228 int over = 0;
4176 u32 di_cur; 4229 u32 di_cur;
@@ -4213,27 +4266,19 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
4213 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 4266 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4214 if (ret < 0) 4267 if (ret < 0)
4215 goto err; 4268 goto err;
4216 advance = 0;
4217 4269
4218 while (1) { 4270 while (1) {
4219 leaf = path->nodes[0]; 4271 leaf = path->nodes[0];
4220 nritems = btrfs_header_nritems(leaf);
4221 slot = path->slots[0]; 4272 slot = path->slots[0];
4222 if (advance || slot >= nritems) { 4273 if (slot >= btrfs_header_nritems(leaf)) {
4223 if (slot >= nritems - 1) { 4274 ret = btrfs_next_leaf(root, path);
4224 ret = btrfs_next_leaf(root, path); 4275 if (ret < 0)
4225 if (ret) 4276 goto err;
4226 break; 4277 else if (ret > 0)
4227 leaf = path->nodes[0]; 4278 break;
4228 nritems = btrfs_header_nritems(leaf); 4279 continue;
4229 slot = path->slots[0];
4230 } else {
4231 slot++;
4232 path->slots[0]++;
4233 }
4234 } 4280 }
4235 4281
4236 advance = 1;
4237 item = btrfs_item_nr(leaf, slot); 4282 item = btrfs_item_nr(leaf, slot);
4238 btrfs_item_key_to_cpu(leaf, &found_key, slot); 4283 btrfs_item_key_to_cpu(leaf, &found_key, slot);
4239 4284
@@ -4242,7 +4287,7 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
4242 if (btrfs_key_type(&found_key) != key_type) 4287 if (btrfs_key_type(&found_key) != key_type)
4243 break; 4288 break;
4244 if (found_key.offset < filp->f_pos) 4289 if (found_key.offset < filp->f_pos)
4245 continue; 4290 goto next;
4246 4291
4247 filp->f_pos = found_key.offset; 4292 filp->f_pos = found_key.offset;
4248 4293
@@ -4253,6 +4298,9 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
4253 while (di_cur < di_total) { 4298 while (di_cur < di_total) {
4254 struct btrfs_key location; 4299 struct btrfs_key location;
4255 4300
4301 if (verify_dir_item(root, leaf, di))
4302 break;
4303
4256 name_len = btrfs_dir_name_len(leaf, di); 4304 name_len = btrfs_dir_name_len(leaf, di);
4257 if (name_len <= sizeof(tmp_name)) { 4305 if (name_len <= sizeof(tmp_name)) {
4258 name_ptr = tmp_name; 4306 name_ptr = tmp_name;
@@ -4292,6 +4340,8 @@ skip:
4292 di_cur += di_len; 4340 di_cur += di_len;
4293 di = (struct btrfs_dir_item *)((char *)di + di_len); 4341 di = (struct btrfs_dir_item *)((char *)di + di_len);
4294 } 4342 }
4343next:
4344 path->slots[0]++;
4295 } 4345 }
4296 4346
4297 /* Reached end of directory/root. Bump pos past the last item. */ 4347 /* Reached end of directory/root. Bump pos past the last item. */
@@ -4328,6 +4378,8 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
4328 trans = btrfs_join_transaction_nolock(root, 1); 4378 trans = btrfs_join_transaction_nolock(root, 1);
4329 else 4379 else
4330 trans = btrfs_join_transaction(root, 1); 4380 trans = btrfs_join_transaction(root, 1);
4381 if (IS_ERR(trans))
4382 return PTR_ERR(trans);
4331 btrfs_set_trans_block_group(trans, inode); 4383 btrfs_set_trans_block_group(trans, inode);
4332 if (nolock) 4384 if (nolock)
4333 ret = btrfs_end_transaction_nolock(trans, root); 4385 ret = btrfs_end_transaction_nolock(trans, root);
@@ -4353,6 +4405,7 @@ void btrfs_dirty_inode(struct inode *inode)
4353 return; 4405 return;
4354 4406
4355 trans = btrfs_join_transaction(root, 1); 4407 trans = btrfs_join_transaction(root, 1);
4408 BUG_ON(IS_ERR(trans));
4356 btrfs_set_trans_block_group(trans, inode); 4409 btrfs_set_trans_block_group(trans, inode);
4357 4410
4358 ret = btrfs_update_inode(trans, root, inode); 4411 ret = btrfs_update_inode(trans, root, inode);
@@ -4481,12 +4534,17 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
4481 BUG_ON(!path); 4534 BUG_ON(!path);
4482 4535
4483 inode = new_inode(root->fs_info->sb); 4536 inode = new_inode(root->fs_info->sb);
4484 if (!inode) 4537 if (!inode) {
4538 btrfs_free_path(path);
4485 return ERR_PTR(-ENOMEM); 4539 return ERR_PTR(-ENOMEM);
4540 }
4486 4541
4487 if (dir) { 4542 if (dir) {
4543 trace_btrfs_inode_request(dir);
4544
4488 ret = btrfs_set_inode_index(dir, index); 4545 ret = btrfs_set_inode_index(dir, index);
4489 if (ret) { 4546 if (ret) {
4547 btrfs_free_path(path);
4490 iput(inode); 4548 iput(inode);
4491 return ERR_PTR(ret); 4549 return ERR_PTR(ret);
4492 } 4550 }
@@ -4553,12 +4611,16 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
4553 if ((mode & S_IFREG)) { 4611 if ((mode & S_IFREG)) {
4554 if (btrfs_test_opt(root, NODATASUM)) 4612 if (btrfs_test_opt(root, NODATASUM))
4555 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; 4613 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
4556 if (btrfs_test_opt(root, NODATACOW)) 4614 if (btrfs_test_opt(root, NODATACOW) ||
4615 (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
4557 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW; 4616 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
4558 } 4617 }
4559 4618
4560 insert_inode_hash(inode); 4619 insert_inode_hash(inode);
4561 inode_tree_add(inode); 4620 inode_tree_add(inode);
4621
4622 trace_btrfs_inode_new(inode);
4623
4562 return inode; 4624 return inode;
4563fail: 4625fail:
4564 if (dir) 4626 if (dir)
@@ -4673,7 +4735,7 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
4673 if (IS_ERR(inode)) 4735 if (IS_ERR(inode))
4674 goto out_unlock; 4736 goto out_unlock;
4675 4737
4676 err = btrfs_init_inode_security(trans, inode, dir); 4738 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
4677 if (err) { 4739 if (err) {
4678 drop_inode = 1; 4740 drop_inode = 1;
4679 goto out_unlock; 4741 goto out_unlock;
@@ -4734,7 +4796,7 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
4734 if (IS_ERR(inode)) 4796 if (IS_ERR(inode))
4735 goto out_unlock; 4797 goto out_unlock;
4736 4798
4737 err = btrfs_init_inode_security(trans, inode, dir); 4799 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
4738 if (err) { 4800 if (err) {
4739 drop_inode = 1; 4801 drop_inode = 1;
4740 goto out_unlock; 4802 goto out_unlock;
@@ -4775,30 +4837,31 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
4775 int err; 4837 int err;
4776 int drop_inode = 0; 4838 int drop_inode = 0;
4777 4839
4778 if (inode->i_nlink == 0)
4779 return -ENOENT;
4780
4781 /* do not allow sys_link's with other subvols of the same device */ 4840 /* do not allow sys_link's with other subvols of the same device */
4782 if (root->objectid != BTRFS_I(inode)->root->objectid) 4841 if (root->objectid != BTRFS_I(inode)->root->objectid)
4783 return -EPERM; 4842 return -EXDEV;
4784 4843
4785 btrfs_inc_nlink(inode); 4844 if (inode->i_nlink == ~0U)
4786 inode->i_ctime = CURRENT_TIME; 4845 return -EMLINK;
4787 4846
4788 err = btrfs_set_inode_index(dir, &index); 4847 err = btrfs_set_inode_index(dir, &index);
4789 if (err) 4848 if (err)
4790 goto fail; 4849 goto fail;
4791 4850
4792 /* 4851 /*
4793 * 1 item for inode ref 4852 * 2 items for inode and inode ref
4794 * 2 items for dir items 4853 * 2 items for dir items
4854 * 1 item for parent inode
4795 */ 4855 */
4796 trans = btrfs_start_transaction(root, 3); 4856 trans = btrfs_start_transaction(root, 5);
4797 if (IS_ERR(trans)) { 4857 if (IS_ERR(trans)) {
4798 err = PTR_ERR(trans); 4858 err = PTR_ERR(trans);
4799 goto fail; 4859 goto fail;
4800 } 4860 }
4801 4861
4862 btrfs_inc_nlink(inode);
4863 inode->i_ctime = CURRENT_TIME;
4864
4802 btrfs_set_trans_block_group(trans, dir); 4865 btrfs_set_trans_block_group(trans, dir);
4803 ihold(inode); 4866 ihold(inode);
4804 4867
@@ -4862,7 +4925,7 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
4862 4925
4863 drop_on_err = 1; 4926 drop_on_err = 1;
4864 4927
4865 err = btrfs_init_inode_security(trans, inode, dir); 4928 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
4866 if (err) 4929 if (err)
4867 goto out_fail; 4930 goto out_fail;
4868 4931
@@ -4928,8 +4991,10 @@ static noinline int uncompress_inline(struct btrfs_path *path,
4928 size_t max_size; 4991 size_t max_size;
4929 unsigned long inline_size; 4992 unsigned long inline_size;
4930 unsigned long ptr; 4993 unsigned long ptr;
4994 int compress_type;
4931 4995
4932 WARN_ON(pg_offset != 0); 4996 WARN_ON(pg_offset != 0);
4997 compress_type = btrfs_file_extent_compression(leaf, item);
4933 max_size = btrfs_file_extent_ram_bytes(leaf, item); 4998 max_size = btrfs_file_extent_ram_bytes(leaf, item);
4934 inline_size = btrfs_file_extent_inline_item_len(leaf, 4999 inline_size = btrfs_file_extent_inline_item_len(leaf,
4935 btrfs_item_nr(leaf, path->slots[0])); 5000 btrfs_item_nr(leaf, path->slots[0]));
@@ -4939,8 +5004,8 @@ static noinline int uncompress_inline(struct btrfs_path *path,
4939 read_extent_buffer(leaf, tmp, ptr, inline_size); 5004 read_extent_buffer(leaf, tmp, ptr, inline_size);
4940 5005
4941 max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size); 5006 max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
4942 ret = btrfs_zlib_decompress(tmp, page, extent_offset, 5007 ret = btrfs_decompress(compress_type, tmp, page,
4943 inline_size, max_size); 5008 extent_offset, inline_size, max_size);
4944 if (ret) { 5009 if (ret) {
4945 char *kaddr = kmap_atomic(page, KM_USER0); 5010 char *kaddr = kmap_atomic(page, KM_USER0);
4946 unsigned long copy_size = min_t(u64, 5011 unsigned long copy_size = min_t(u64,
@@ -4982,7 +5047,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
4982 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 5047 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4983 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 5048 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4984 struct btrfs_trans_handle *trans = NULL; 5049 struct btrfs_trans_handle *trans = NULL;
4985 int compressed; 5050 int compress_type;
4986 5051
4987again: 5052again:
4988 read_lock(&em_tree->lock); 5053 read_lock(&em_tree->lock);
@@ -5041,7 +5106,7 @@ again:
5041 5106
5042 found_type = btrfs_file_extent_type(leaf, item); 5107 found_type = btrfs_file_extent_type(leaf, item);
5043 extent_start = found_key.offset; 5108 extent_start = found_key.offset;
5044 compressed = btrfs_file_extent_compression(leaf, item); 5109 compress_type = btrfs_file_extent_compression(leaf, item);
5045 if (found_type == BTRFS_FILE_EXTENT_REG || 5110 if (found_type == BTRFS_FILE_EXTENT_REG ||
5046 found_type == BTRFS_FILE_EXTENT_PREALLOC) { 5111 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5047 extent_end = extent_start + 5112 extent_end = extent_start +
@@ -5087,8 +5152,9 @@ again:
5087 em->block_start = EXTENT_MAP_HOLE; 5152 em->block_start = EXTENT_MAP_HOLE;
5088 goto insert; 5153 goto insert;
5089 } 5154 }
5090 if (compressed) { 5155 if (compress_type != BTRFS_COMPRESS_NONE) {
5091 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 5156 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5157 em->compress_type = compress_type;
5092 em->block_start = bytenr; 5158 em->block_start = bytenr;
5093 em->block_len = btrfs_file_extent_disk_num_bytes(leaf, 5159 em->block_len = btrfs_file_extent_disk_num_bytes(leaf,
5094 item); 5160 item);
@@ -5122,12 +5188,14 @@ again:
5122 em->len = (copy_size + root->sectorsize - 1) & 5188 em->len = (copy_size + root->sectorsize - 1) &
5123 ~((u64)root->sectorsize - 1); 5189 ~((u64)root->sectorsize - 1);
5124 em->orig_start = EXTENT_MAP_INLINE; 5190 em->orig_start = EXTENT_MAP_INLINE;
5125 if (compressed) 5191 if (compress_type) {
5126 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 5192 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5193 em->compress_type = compress_type;
5194 }
5127 ptr = btrfs_file_extent_inline_start(item) + extent_offset; 5195 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
5128 if (create == 0 && !PageUptodate(page)) { 5196 if (create == 0 && !PageUptodate(page)) {
5129 if (btrfs_file_extent_compression(leaf, item) == 5197 if (btrfs_file_extent_compression(leaf, item) !=
5130 BTRFS_COMPRESS_ZLIB) { 5198 BTRFS_COMPRESS_NONE) {
5131 ret = uncompress_inline(path, inode, page, 5199 ret = uncompress_inline(path, inode, page,
5132 pg_offset, 5200 pg_offset,
5133 extent_offset, item); 5201 extent_offset, item);
@@ -5152,6 +5220,8 @@ again:
5152 em = NULL; 5220 em = NULL;
5153 btrfs_release_path(root, path); 5221 btrfs_release_path(root, path);
5154 trans = btrfs_join_transaction(root, 1); 5222 trans = btrfs_join_transaction(root, 1);
5223 if (IS_ERR(trans))
5224 return ERR_CAST(trans);
5155 goto again; 5225 goto again;
5156 } 5226 }
5157 map = kmap(page); 5227 map = kmap(page);
@@ -5161,7 +5231,7 @@ again:
5161 btrfs_mark_buffer_dirty(leaf); 5231 btrfs_mark_buffer_dirty(leaf);
5162 } 5232 }
5163 set_extent_uptodate(io_tree, em->start, 5233 set_extent_uptodate(io_tree, em->start,
5164 extent_map_end(em) - 1, GFP_NOFS); 5234 extent_map_end(em) - 1, NULL, GFP_NOFS);
5165 goto insert; 5235 goto insert;
5166 } else { 5236 } else {
5167 printk(KERN_ERR "btrfs unknown found_type %d\n", found_type); 5237 printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
@@ -5228,6 +5298,9 @@ insert:
5228 } 5298 }
5229 write_unlock(&em_tree->lock); 5299 write_unlock(&em_tree->lock);
5230out: 5300out:
5301
5302 trace_btrfs_get_extent(root, em);
5303
5231 if (path) 5304 if (path)
5232 btrfs_free_path(path); 5305 btrfs_free_path(path);
5233 if (trans) { 5306 if (trans) {
@@ -5242,22 +5315,157 @@ out:
5242 return em; 5315 return em;
5243} 5316}
5244 5317
5318struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
5319 size_t pg_offset, u64 start, u64 len,
5320 int create)
5321{
5322 struct extent_map *em;
5323 struct extent_map *hole_em = NULL;
5324 u64 range_start = start;
5325 u64 end;
5326 u64 found;
5327 u64 found_end;
5328 int err = 0;
5329
5330 em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
5331 if (IS_ERR(em))
5332 return em;
5333 if (em) {
5334 /*
5335 * if our em maps to a hole, there might
5336 * actually be delalloc bytes behind it
5337 */
5338 if (em->block_start != EXTENT_MAP_HOLE)
5339 return em;
5340 else
5341 hole_em = em;
5342 }
5343
5344 /* check to see if we've wrapped (len == -1 or similar) */
5345 end = start + len;
5346 if (end < start)
5347 end = (u64)-1;
5348 else
5349 end -= 1;
5350
5351 em = NULL;
5352
5353 /* ok, we didn't find anything, lets look for delalloc */
5354 found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
5355 end, len, EXTENT_DELALLOC, 1);
5356 found_end = range_start + found;
5357 if (found_end < range_start)
5358 found_end = (u64)-1;
5359
5360 /*
5361 * we didn't find anything useful, return
5362 * the original results from get_extent()
5363 */
5364 if (range_start > end || found_end <= start) {
5365 em = hole_em;
5366 hole_em = NULL;
5367 goto out;
5368 }
5369
5370 /* adjust the range_start to make sure it doesn't
5371 * go backwards from the start they passed in
5372 */
5373 range_start = max(start,range_start);
5374 found = found_end - range_start;
5375
5376 if (found > 0) {
5377 u64 hole_start = start;
5378 u64 hole_len = len;
5379
5380 em = alloc_extent_map(GFP_NOFS);
5381 if (!em) {
5382 err = -ENOMEM;
5383 goto out;
5384 }
5385 /*
5386 * when btrfs_get_extent can't find anything it
5387 * returns one huge hole
5388 *
5389 * make sure what it found really fits our range, and
5390 * adjust to make sure it is based on the start from
5391 * the caller
5392 */
5393 if (hole_em) {
5394 u64 calc_end = extent_map_end(hole_em);
5395
5396 if (calc_end <= start || (hole_em->start > end)) {
5397 free_extent_map(hole_em);
5398 hole_em = NULL;
5399 } else {
5400 hole_start = max(hole_em->start, start);
5401 hole_len = calc_end - hole_start;
5402 }
5403 }
5404 em->bdev = NULL;
5405 if (hole_em && range_start > hole_start) {
5406 /* our hole starts before our delalloc, so we
5407 * have to return just the parts of the hole
5408 * that go until the delalloc starts
5409 */
5410 em->len = min(hole_len,
5411 range_start - hole_start);
5412 em->start = hole_start;
5413 em->orig_start = hole_start;
5414 /*
5415 * don't adjust block start at all,
5416 * it is fixed at EXTENT_MAP_HOLE
5417 */
5418 em->block_start = hole_em->block_start;
5419 em->block_len = hole_len;
5420 } else {
5421 em->start = range_start;
5422 em->len = found;
5423 em->orig_start = range_start;
5424 em->block_start = EXTENT_MAP_DELALLOC;
5425 em->block_len = found;
5426 }
5427 } else if (hole_em) {
5428 return hole_em;
5429 }
5430out:
5431
5432 free_extent_map(hole_em);
5433 if (err) {
5434 free_extent_map(em);
5435 return ERR_PTR(err);
5436 }
5437 return em;
5438}
5439
5245static struct extent_map *btrfs_new_extent_direct(struct inode *inode, 5440static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5441 struct extent_map *em,
5246 u64 start, u64 len) 5442 u64 start, u64 len)
5247{ 5443{
5248 struct btrfs_root *root = BTRFS_I(inode)->root; 5444 struct btrfs_root *root = BTRFS_I(inode)->root;
5249 struct btrfs_trans_handle *trans; 5445 struct btrfs_trans_handle *trans;
5250 struct extent_map *em;
5251 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 5446 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
5252 struct btrfs_key ins; 5447 struct btrfs_key ins;
5253 u64 alloc_hint; 5448 u64 alloc_hint;
5254 int ret; 5449 int ret;
5450 bool insert = false;
5255 5451
5256 btrfs_drop_extent_cache(inode, start, start + len - 1, 0); 5452 /*
5453 * Ok if the extent map we looked up is a hole and is for the exact
5454 * range we want, there is no reason to allocate a new one, however if
5455 * it is not right then we need to free this one and drop the cache for
5456 * our range.
5457 */
5458 if (em->block_start != EXTENT_MAP_HOLE || em->start != start ||
5459 em->len != len) {
5460 free_extent_map(em);
5461 em = NULL;
5462 insert = true;
5463 btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
5464 }
5257 5465
5258 trans = btrfs_join_transaction(root, 0); 5466 trans = btrfs_join_transaction(root, 0);
5259 if (!trans) 5467 if (IS_ERR(trans))
5260 return ERR_PTR(-ENOMEM); 5468 return ERR_CAST(trans);
5261 5469
5262 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 5470 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
5263 5471
@@ -5269,10 +5477,12 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5269 goto out; 5477 goto out;
5270 } 5478 }
5271 5479
5272 em = alloc_extent_map(GFP_NOFS);
5273 if (!em) { 5480 if (!em) {
5274 em = ERR_PTR(-ENOMEM); 5481 em = alloc_extent_map(GFP_NOFS);
5275 goto out; 5482 if (!em) {
5483 em = ERR_PTR(-ENOMEM);
5484 goto out;
5485 }
5276 } 5486 }
5277 5487
5278 em->start = start; 5488 em->start = start;
@@ -5282,9 +5492,15 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5282 em->block_start = ins.objectid; 5492 em->block_start = ins.objectid;
5283 em->block_len = ins.offset; 5493 em->block_len = ins.offset;
5284 em->bdev = root->fs_info->fs_devices->latest_bdev; 5494 em->bdev = root->fs_info->fs_devices->latest_bdev;
5495
5496 /*
5497 * We need to do this because if we're using the original em we searched
5498 * for, we could have EXTENT_FLAG_VACANCY set, and we don't want that.
5499 */
5500 em->flags = 0;
5285 set_bit(EXTENT_FLAG_PINNED, &em->flags); 5501 set_bit(EXTENT_FLAG_PINNED, &em->flags);
5286 5502
5287 while (1) { 5503 while (insert) {
5288 write_lock(&em_tree->lock); 5504 write_lock(&em_tree->lock);
5289 ret = add_extent_mapping(em_tree, em); 5505 ret = add_extent_mapping(em_tree, em);
5290 write_unlock(&em_tree->lock); 5506 write_unlock(&em_tree->lock);
@@ -5481,7 +5697,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
5481 * while we look for nocow cross refs 5697 * while we look for nocow cross refs
5482 */ 5698 */
5483 trans = btrfs_join_transaction(root, 0); 5699 trans = btrfs_join_transaction(root, 0);
5484 if (!trans) 5700 if (IS_ERR(trans))
5485 goto must_cow; 5701 goto must_cow;
5486 5702
5487 if (can_nocow_odirect(trans, inode, start, len) == 1) { 5703 if (can_nocow_odirect(trans, inode, start, len) == 1) {
@@ -5502,8 +5718,7 @@ must_cow:
5502 * it above 5718 * it above
5503 */ 5719 */
5504 len = bh_result->b_size; 5720 len = bh_result->b_size;
5505 free_extent_map(em); 5721 em = btrfs_new_extent_direct(inode, em, start, len);
5506 em = btrfs_new_extent_direct(inode, start, len);
5507 if (IS_ERR(em)) 5722 if (IS_ERR(em))
5508 return PTR_ERR(em); 5723 return PTR_ERR(em);
5509 len = min(len, em->len - (start - em->start)); 5724 len = min(len, em->len - (start - em->start));
@@ -5589,6 +5804,10 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
5589 5804
5590 kfree(dip->csums); 5805 kfree(dip->csums);
5591 kfree(dip); 5806 kfree(dip);
5807
5808 /* If we had a csum failure make sure to clear the uptodate flag */
5809 if (err)
5810 clear_bit(BIO_UPTODATE, &bio->bi_flags);
5592 dio_end_io(bio, err); 5811 dio_end_io(bio, err);
5593} 5812}
5594 5813
@@ -5616,7 +5835,7 @@ again:
5616 BUG_ON(!ordered); 5835 BUG_ON(!ordered);
5617 5836
5618 trans = btrfs_join_transaction(root, 1); 5837 trans = btrfs_join_transaction(root, 1);
5619 if (!trans) { 5838 if (IS_ERR(trans)) {
5620 err = -ENOMEM; 5839 err = -ENOMEM;
5621 goto out; 5840 goto out;
5622 } 5841 }
@@ -5662,8 +5881,10 @@ again:
5662 } 5881 }
5663 5882
5664 add_pending_csums(trans, inode, ordered->file_offset, &ordered->list); 5883 add_pending_csums(trans, inode, ordered->file_offset, &ordered->list);
5665 btrfs_ordered_update_i_size(inode, 0, ordered); 5884 ret = btrfs_ordered_update_i_size(inode, 0, ordered);
5666 btrfs_update_inode(trans, root, inode); 5885 if (!ret)
5886 btrfs_update_inode(trans, root, inode);
5887 ret = 0;
5667out_unlock: 5888out_unlock:
5668 unlock_extent_cached(&BTRFS_I(inode)->io_tree, ordered->file_offset, 5889 unlock_extent_cached(&BTRFS_I(inode)->io_tree, ordered->file_offset,
5669 ordered->file_offset + ordered->len - 1, 5890 ordered->file_offset + ordered->len - 1,
@@ -5690,6 +5911,10 @@ out_done:
5690 5911
5691 kfree(dip->csums); 5912 kfree(dip->csums);
5692 kfree(dip); 5913 kfree(dip);
5914
5915 /* If we had an error make sure to clear the uptodate flag */
5916 if (err)
5917 clear_bit(BIO_UPTODATE, &bio->bi_flags);
5693 dio_end_io(bio, err); 5918 dio_end_io(bio, err);
5694} 5919}
5695 5920
@@ -5745,7 +5970,7 @@ static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
5745 5970
5746static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode, 5971static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
5747 int rw, u64 file_offset, int skip_sum, 5972 int rw, u64 file_offset, int skip_sum,
5748 u32 *csums) 5973 u32 *csums, int async_submit)
5749{ 5974{
5750 int write = rw & REQ_WRITE; 5975 int write = rw & REQ_WRITE;
5751 struct btrfs_root *root = BTRFS_I(inode)->root; 5976 struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -5756,18 +5981,33 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
5756 if (ret) 5981 if (ret)
5757 goto err; 5982 goto err;
5758 5983
5759 if (write && !skip_sum) { 5984 if (skip_sum)
5985 goto map;
5986
5987 if (write && async_submit) {
5760 ret = btrfs_wq_submit_bio(root->fs_info, 5988 ret = btrfs_wq_submit_bio(root->fs_info,
5761 inode, rw, bio, 0, 0, 5989 inode, rw, bio, 0, 0,
5762 file_offset, 5990 file_offset,
5763 __btrfs_submit_bio_start_direct_io, 5991 __btrfs_submit_bio_start_direct_io,
5764 __btrfs_submit_bio_done); 5992 __btrfs_submit_bio_done);
5765 goto err; 5993 goto err;
5766 } else if (!skip_sum) 5994 } else if (write) {
5767 btrfs_lookup_bio_sums_dio(root, inode, bio, 5995 /*
5996 * If we aren't doing async submit, calculate the csum of the
5997 * bio now.
5998 */
5999 ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1);
6000 if (ret)
6001 goto err;
6002 } else if (!skip_sum) {
6003 ret = btrfs_lookup_bio_sums_dio(root, inode, bio,
5768 file_offset, csums); 6004 file_offset, csums);
6005 if (ret)
6006 goto err;
6007 }
5769 6008
5770 ret = btrfs_map_bio(root, rw, bio, 0, 1); 6009map:
6010 ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
5771err: 6011err:
5772 bio_put(bio); 6012 bio_put(bio);
5773 return ret; 6013 return ret;
@@ -5789,13 +6029,8 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
5789 int nr_pages = 0; 6029 int nr_pages = 0;
5790 u32 *csums = dip->csums; 6030 u32 *csums = dip->csums;
5791 int ret = 0; 6031 int ret = 0;
5792 6032 int async_submit = 0;
5793 bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS); 6033 int write = rw & REQ_WRITE;
5794 if (!bio)
5795 return -ENOMEM;
5796 bio->bi_private = dip;
5797 bio->bi_end_io = btrfs_end_dio_bio;
5798 atomic_inc(&dip->pending_bios);
5799 6034
5800 map_length = orig_bio->bi_size; 6035 map_length = orig_bio->bi_size;
5801 ret = btrfs_map_block(map_tree, READ, start_sector << 9, 6036 ret = btrfs_map_block(map_tree, READ, start_sector << 9,
@@ -5805,6 +6040,19 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
5805 return -EIO; 6040 return -EIO;
5806 } 6041 }
5807 6042
6043 if (map_length >= orig_bio->bi_size) {
6044 bio = orig_bio;
6045 goto submit;
6046 }
6047
6048 async_submit = 1;
6049 bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
6050 if (!bio)
6051 return -ENOMEM;
6052 bio->bi_private = dip;
6053 bio->bi_end_io = btrfs_end_dio_bio;
6054 atomic_inc(&dip->pending_bios);
6055
5808 while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) { 6056 while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
5809 if (unlikely(map_length < submit_len + bvec->bv_len || 6057 if (unlikely(map_length < submit_len + bvec->bv_len ||
5810 bio_add_page(bio, bvec->bv_page, bvec->bv_len, 6058 bio_add_page(bio, bvec->bv_page, bvec->bv_len,
@@ -5818,14 +6066,15 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
5818 atomic_inc(&dip->pending_bios); 6066 atomic_inc(&dip->pending_bios);
5819 ret = __btrfs_submit_dio_bio(bio, inode, rw, 6067 ret = __btrfs_submit_dio_bio(bio, inode, rw,
5820 file_offset, skip_sum, 6068 file_offset, skip_sum,
5821 csums); 6069 csums, async_submit);
5822 if (ret) { 6070 if (ret) {
5823 bio_put(bio); 6071 bio_put(bio);
5824 atomic_dec(&dip->pending_bios); 6072 atomic_dec(&dip->pending_bios);
5825 goto out_err; 6073 goto out_err;
5826 } 6074 }
5827 6075
5828 if (!skip_sum) 6076 /* Write's use the ordered csums */
6077 if (!write && !skip_sum)
5829 csums = csums + nr_pages; 6078 csums = csums + nr_pages;
5830 start_sector += submit_len >> 9; 6079 start_sector += submit_len >> 9;
5831 file_offset += submit_len; 6080 file_offset += submit_len;
@@ -5854,8 +6103,9 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
5854 } 6103 }
5855 } 6104 }
5856 6105
6106submit:
5857 ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum, 6107 ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
5858 csums); 6108 csums, async_submit);
5859 if (!ret) 6109 if (!ret)
5860 return 0; 6110 return 0;
5861 6111
@@ -5893,9 +6143,11 @@ static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
5893 } 6143 }
5894 dip->csums = NULL; 6144 dip->csums = NULL;
5895 6145
5896 if (!skip_sum) { 6146 /* Write's use the ordered csum stuff, so we don't need dip->csums */
6147 if (!write && !skip_sum) {
5897 dip->csums = kmalloc(sizeof(u32) * bio->bi_vcnt, GFP_NOFS); 6148 dip->csums = kmalloc(sizeof(u32) * bio->bi_vcnt, GFP_NOFS);
5898 if (!dip->csums) { 6149 if (!dip->csums) {
6150 kfree(dip);
5899 ret = -ENOMEM; 6151 ret = -ENOMEM;
5900 goto free_ordered; 6152 goto free_ordered;
5901 } 6153 }
@@ -5948,6 +6200,7 @@ static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *io
5948 unsigned long nr_segs) 6200 unsigned long nr_segs)
5949{ 6201{
5950 int seg; 6202 int seg;
6203 int i;
5951 size_t size; 6204 size_t size;
5952 unsigned long addr; 6205 unsigned long addr;
5953 unsigned blocksize_mask = root->sectorsize - 1; 6206 unsigned blocksize_mask = root->sectorsize - 1;
@@ -5962,8 +6215,22 @@ static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *io
5962 addr = (unsigned long)iov[seg].iov_base; 6215 addr = (unsigned long)iov[seg].iov_base;
5963 size = iov[seg].iov_len; 6216 size = iov[seg].iov_len;
5964 end += size; 6217 end += size;
5965 if ((addr & blocksize_mask) || (size & blocksize_mask)) 6218 if ((addr & blocksize_mask) || (size & blocksize_mask))
5966 goto out; 6219 goto out;
6220
6221 /* If this is a write we don't need to check anymore */
6222 if (rw & WRITE)
6223 continue;
6224
6225 /*
6226 * Check to make sure we don't have duplicate iov_base's in this
6227 * iovec, if so return EINVAL, otherwise we'll get csum errors
6228 * when reading back.
6229 */
6230 for (i = seg + 1; i < nr_segs; i++) {
6231 if (iov[seg].iov_base == iov[i].iov_base)
6232 goto out;
6233 }
5967 } 6234 }
5968 retval = 0; 6235 retval = 0;
5969out: 6236out:
@@ -6064,7 +6331,7 @@ out:
6064static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 6331static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
6065 __u64 start, __u64 len) 6332 __u64 start, __u64 len)
6066{ 6333{
6067 return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent); 6334 return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
6068} 6335}
6069 6336
6070int btrfs_readpage(struct file *file, struct page *page) 6337int btrfs_readpage(struct file *file, struct page *page)
@@ -6314,28 +6581,42 @@ out:
6314 return ret; 6581 return ret;
6315} 6582}
6316 6583
6317static void btrfs_truncate(struct inode *inode) 6584static int btrfs_truncate(struct inode *inode)
6318{ 6585{
6319 struct btrfs_root *root = BTRFS_I(inode)->root; 6586 struct btrfs_root *root = BTRFS_I(inode)->root;
6320 int ret; 6587 int ret;
6588 int err = 0;
6321 struct btrfs_trans_handle *trans; 6589 struct btrfs_trans_handle *trans;
6322 unsigned long nr; 6590 unsigned long nr;
6323 u64 mask = root->sectorsize - 1; 6591 u64 mask = root->sectorsize - 1;
6324 6592
6325 if (!S_ISREG(inode->i_mode)) {
6326 WARN_ON(1);
6327 return;
6328 }
6329
6330 ret = btrfs_truncate_page(inode->i_mapping, inode->i_size); 6593 ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
6331 if (ret) 6594 if (ret)
6332 return; 6595 return ret;
6333 6596
6334 btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1); 6597 btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
6335 btrfs_ordered_update_i_size(inode, inode->i_size, NULL); 6598 btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
6336 6599
6600 trans = btrfs_start_transaction(root, 5);
6601 if (IS_ERR(trans))
6602 return PTR_ERR(trans);
6603
6604 btrfs_set_trans_block_group(trans, inode);
6605
6606 ret = btrfs_orphan_add(trans, inode);
6607 if (ret) {
6608 btrfs_end_transaction(trans, root);
6609 return ret;
6610 }
6611
6612 nr = trans->blocks_used;
6613 btrfs_end_transaction(trans, root);
6614 btrfs_btree_balance_dirty(root, nr);
6615
6616 /* Now start a transaction for the truncate */
6337 trans = btrfs_start_transaction(root, 0); 6617 trans = btrfs_start_transaction(root, 0);
6338 BUG_ON(IS_ERR(trans)); 6618 if (IS_ERR(trans))
6619 return PTR_ERR(trans);
6339 btrfs_set_trans_block_group(trans, inode); 6620 btrfs_set_trans_block_group(trans, inode);
6340 trans->block_rsv = root->orphan_block_rsv; 6621 trans->block_rsv = root->orphan_block_rsv;
6341 6622
@@ -6362,29 +6643,38 @@ static void btrfs_truncate(struct inode *inode)
6362 while (1) { 6643 while (1) {
6363 if (!trans) { 6644 if (!trans) {
6364 trans = btrfs_start_transaction(root, 0); 6645 trans = btrfs_start_transaction(root, 0);
6365 BUG_ON(IS_ERR(trans)); 6646 if (IS_ERR(trans))
6647 return PTR_ERR(trans);
6366 btrfs_set_trans_block_group(trans, inode); 6648 btrfs_set_trans_block_group(trans, inode);
6367 trans->block_rsv = root->orphan_block_rsv; 6649 trans->block_rsv = root->orphan_block_rsv;
6368 } 6650 }
6369 6651
6370 ret = btrfs_block_rsv_check(trans, root, 6652 ret = btrfs_block_rsv_check(trans, root,
6371 root->orphan_block_rsv, 0, 5); 6653 root->orphan_block_rsv, 0, 5);
6372 if (ret) { 6654 if (ret == -EAGAIN) {
6373 BUG_ON(ret != -EAGAIN);
6374 ret = btrfs_commit_transaction(trans, root); 6655 ret = btrfs_commit_transaction(trans, root);
6375 BUG_ON(ret); 6656 if (ret)
6657 return ret;
6376 trans = NULL; 6658 trans = NULL;
6377 continue; 6659 continue;
6660 } else if (ret) {
6661 err = ret;
6662 break;
6378 } 6663 }
6379 6664
6380 ret = btrfs_truncate_inode_items(trans, root, inode, 6665 ret = btrfs_truncate_inode_items(trans, root, inode,
6381 inode->i_size, 6666 inode->i_size,
6382 BTRFS_EXTENT_DATA_KEY); 6667 BTRFS_EXTENT_DATA_KEY);
6383 if (ret != -EAGAIN) 6668 if (ret != -EAGAIN) {
6669 err = ret;
6384 break; 6670 break;
6671 }
6385 6672
6386 ret = btrfs_update_inode(trans, root, inode); 6673 ret = btrfs_update_inode(trans, root, inode);
6387 BUG_ON(ret); 6674 if (ret) {
6675 err = ret;
6676 break;
6677 }
6388 6678
6389 nr = trans->blocks_used; 6679 nr = trans->blocks_used;
6390 btrfs_end_transaction(trans, root); 6680 btrfs_end_transaction(trans, root);
@@ -6394,16 +6684,27 @@ static void btrfs_truncate(struct inode *inode)
6394 6684
6395 if (ret == 0 && inode->i_nlink > 0) { 6685 if (ret == 0 && inode->i_nlink > 0) {
6396 ret = btrfs_orphan_del(trans, inode); 6686 ret = btrfs_orphan_del(trans, inode);
6397 BUG_ON(ret); 6687 if (ret)
6688 err = ret;
6689 } else if (ret && inode->i_nlink > 0) {
6690 /*
6691 * Failed to do the truncate, remove us from the in memory
6692 * orphan list.
6693 */
6694 ret = btrfs_orphan_del(NULL, inode);
6398 } 6695 }
6399 6696
6400 ret = btrfs_update_inode(trans, root, inode); 6697 ret = btrfs_update_inode(trans, root, inode);
6401 BUG_ON(ret); 6698 if (ret && !err)
6699 err = ret;
6402 6700
6403 nr = trans->blocks_used; 6701 nr = trans->blocks_used;
6404 ret = btrfs_end_transaction_throttle(trans, root); 6702 ret = btrfs_end_transaction_throttle(trans, root);
6405 BUG_ON(ret); 6703 if (ret && !err)
6704 err = ret;
6406 btrfs_btree_balance_dirty(root, nr); 6705 btrfs_btree_balance_dirty(root, nr);
6706
6707 return err;
6407} 6708}
6408 6709
6409/* 6710/*
@@ -6470,14 +6771,13 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
6470 ei->index_cnt = (u64)-1; 6771 ei->index_cnt = (u64)-1;
6471 ei->last_unlink_trans = 0; 6772 ei->last_unlink_trans = 0;
6472 6773
6473 spin_lock_init(&ei->accounting_lock);
6474 atomic_set(&ei->outstanding_extents, 0); 6774 atomic_set(&ei->outstanding_extents, 0);
6475 ei->reserved_extents = 0; 6775 atomic_set(&ei->reserved_extents, 0);
6476 6776
6477 ei->ordered_data_close = 0; 6777 ei->ordered_data_close = 0;
6478 ei->orphan_meta_reserved = 0; 6778 ei->orphan_meta_reserved = 0;
6479 ei->dummy_inode = 0; 6779 ei->dummy_inode = 0;
6480 ei->force_compress = 0; 6780 ei->force_compress = BTRFS_COMPRESS_NONE;
6481 6781
6482 inode = &ei->vfs_inode; 6782 inode = &ei->vfs_inode;
6483 extent_map_tree_init(&ei->extent_tree, GFP_NOFS); 6783 extent_map_tree_init(&ei->extent_tree, GFP_NOFS);
@@ -6508,7 +6808,7 @@ void btrfs_destroy_inode(struct inode *inode)
6508 WARN_ON(!list_empty(&inode->i_dentry)); 6808 WARN_ON(!list_empty(&inode->i_dentry));
6509 WARN_ON(inode->i_data.nrpages); 6809 WARN_ON(inode->i_data.nrpages);
6510 WARN_ON(atomic_read(&BTRFS_I(inode)->outstanding_extents)); 6810 WARN_ON(atomic_read(&BTRFS_I(inode)->outstanding_extents));
6511 WARN_ON(BTRFS_I(inode)->reserved_extents); 6811 WARN_ON(atomic_read(&BTRFS_I(inode)->reserved_extents));
6512 6812
6513 /* 6813 /*
6514 * This can happen where we create an inode, but somebody else also 6814 * This can happen where we create an inode, but somebody else also
@@ -6600,6 +6900,8 @@ void btrfs_destroy_cachep(void)
6600 kmem_cache_destroy(btrfs_transaction_cachep); 6900 kmem_cache_destroy(btrfs_transaction_cachep);
6601 if (btrfs_path_cachep) 6901 if (btrfs_path_cachep)
6602 kmem_cache_destroy(btrfs_path_cachep); 6902 kmem_cache_destroy(btrfs_path_cachep);
6903 if (btrfs_free_space_cachep)
6904 kmem_cache_destroy(btrfs_free_space_cachep);
6603} 6905}
6604 6906
6605int btrfs_init_cachep(void) 6907int btrfs_init_cachep(void)
@@ -6628,6 +6930,12 @@ int btrfs_init_cachep(void)
6628 if (!btrfs_path_cachep) 6930 if (!btrfs_path_cachep)
6629 goto fail; 6931 goto fail;
6630 6932
6933 btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
6934 sizeof(struct btrfs_free_space), 0,
6935 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
6936 if (!btrfs_free_space_cachep)
6937 goto fail;
6938
6631 return 0; 6939 return 0;
6632fail: 6940fail:
6633 btrfs_destroy_cachep(); 6941 btrfs_destroy_cachep();
@@ -6646,6 +6954,26 @@ static int btrfs_getattr(struct vfsmount *mnt,
6646 return 0; 6954 return 0;
6647} 6955}
6648 6956
6957/*
6958 * If a file is moved, it will inherit the cow and compression flags of the new
6959 * directory.
6960 */
6961static void fixup_inode_flags(struct inode *dir, struct inode *inode)
6962{
6963 struct btrfs_inode *b_dir = BTRFS_I(dir);
6964 struct btrfs_inode *b_inode = BTRFS_I(inode);
6965
6966 if (b_dir->flags & BTRFS_INODE_NODATACOW)
6967 b_inode->flags |= BTRFS_INODE_NODATACOW;
6968 else
6969 b_inode->flags &= ~BTRFS_INODE_NODATACOW;
6970
6971 if (b_dir->flags & BTRFS_INODE_COMPRESS)
6972 b_inode->flags |= BTRFS_INODE_COMPRESS;
6973 else
6974 b_inode->flags &= ~BTRFS_INODE_COMPRESS;
6975}
6976
6649static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry, 6977static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
6650 struct inode *new_dir, struct dentry *new_dentry) 6978 struct inode *new_dir, struct dentry *new_dentry)
6651{ 6979{
@@ -6694,8 +7022,10 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
6694 * should cover the worst case number of items we'll modify. 7022 * should cover the worst case number of items we'll modify.
6695 */ 7023 */
6696 trans = btrfs_start_transaction(root, 20); 7024 trans = btrfs_start_transaction(root, 20);
6697 if (IS_ERR(trans)) 7025 if (IS_ERR(trans)) {
6698 return PTR_ERR(trans); 7026 ret = PTR_ERR(trans);
7027 goto out_notrans;
7028 }
6699 7029
6700 btrfs_set_trans_block_group(trans, new_dir); 7030 btrfs_set_trans_block_group(trans, new_dir);
6701 7031
@@ -6748,11 +7078,12 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
6748 old_dentry->d_name.name, 7078 old_dentry->d_name.name,
6749 old_dentry->d_name.len); 7079 old_dentry->d_name.len);
6750 } else { 7080 } else {
6751 btrfs_inc_nlink(old_dentry->d_inode); 7081 ret = __btrfs_unlink_inode(trans, root, old_dir,
6752 ret = btrfs_unlink_inode(trans, root, old_dir, 7082 old_dentry->d_inode,
6753 old_dentry->d_inode, 7083 old_dentry->d_name.name,
6754 old_dentry->d_name.name, 7084 old_dentry->d_name.len);
6755 old_dentry->d_name.len); 7085 if (!ret)
7086 ret = btrfs_update_inode(trans, root, old_inode);
6756 } 7087 }
6757 BUG_ON(ret); 7088 BUG_ON(ret);
6758 7089
@@ -6779,6 +7110,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
6779 } 7110 }
6780 } 7111 }
6781 7112
7113 fixup_inode_flags(new_dir, old_inode);
7114
6782 ret = btrfs_add_link(trans, new_dir, old_inode, 7115 ret = btrfs_add_link(trans, new_dir, old_inode,
6783 new_dentry->d_name.name, 7116 new_dentry->d_name.name,
6784 new_dentry->d_name.len, 0, index); 7117 new_dentry->d_name.len, 0, index);
@@ -6792,7 +7125,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
6792 } 7125 }
6793out_fail: 7126out_fail:
6794 btrfs_end_transaction_throttle(trans, root); 7127 btrfs_end_transaction_throttle(trans, root);
6795 7128out_notrans:
6796 if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) 7129 if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
6797 up_read(&root->fs_info->subvol_sem); 7130 up_read(&root->fs_info->subvol_sem);
6798 7131
@@ -6944,7 +7277,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
6944 if (IS_ERR(inode)) 7277 if (IS_ERR(inode))
6945 goto out_unlock; 7278 goto out_unlock;
6946 7279
6947 err = btrfs_init_inode_security(trans, inode, dir); 7280 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
6948 if (err) { 7281 if (err) {
6949 drop_inode = 1; 7282 drop_inode = 1;
6950 goto out_unlock; 7283 goto out_unlock;
@@ -7098,116 +7431,6 @@ int btrfs_prealloc_file_range_trans(struct inode *inode,
7098 min_size, actual_len, alloc_hint, trans); 7431 min_size, actual_len, alloc_hint, trans);
7099} 7432}
7100 7433
7101static long btrfs_fallocate(struct inode *inode, int mode,
7102 loff_t offset, loff_t len)
7103{
7104 struct extent_state *cached_state = NULL;
7105 u64 cur_offset;
7106 u64 last_byte;
7107 u64 alloc_start;
7108 u64 alloc_end;
7109 u64 alloc_hint = 0;
7110 u64 locked_end;
7111 u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
7112 struct extent_map *em;
7113 int ret;
7114
7115 alloc_start = offset & ~mask;
7116 alloc_end = (offset + len + mask) & ~mask;
7117
7118 /* We only support the FALLOC_FL_KEEP_SIZE mode */
7119 if (mode && (mode != FALLOC_FL_KEEP_SIZE))
7120 return -EOPNOTSUPP;
7121
7122 /*
7123 * wait for ordered IO before we have any locks. We'll loop again
7124 * below with the locks held.
7125 */
7126 btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);
7127
7128 mutex_lock(&inode->i_mutex);
7129 ret = inode_newsize_ok(inode, alloc_end);
7130 if (ret)
7131 goto out;
7132
7133 if (alloc_start > inode->i_size) {
7134 ret = btrfs_cont_expand(inode, alloc_start);
7135 if (ret)
7136 goto out;
7137 }
7138
7139 ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);
7140 if (ret)
7141 goto out;
7142
7143 locked_end = alloc_end - 1;
7144 while (1) {
7145 struct btrfs_ordered_extent *ordered;
7146
7147 /* the extent lock is ordered inside the running
7148 * transaction
7149 */
7150 lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,
7151 locked_end, 0, &cached_state, GFP_NOFS);
7152 ordered = btrfs_lookup_first_ordered_extent(inode,
7153 alloc_end - 1);
7154 if (ordered &&
7155 ordered->file_offset + ordered->len > alloc_start &&
7156 ordered->file_offset < alloc_end) {
7157 btrfs_put_ordered_extent(ordered);
7158 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
7159 alloc_start, locked_end,
7160 &cached_state, GFP_NOFS);
7161 /*
7162 * we can't wait on the range with the transaction
7163 * running or with the extent lock held
7164 */
7165 btrfs_wait_ordered_range(inode, alloc_start,
7166 alloc_end - alloc_start);
7167 } else {
7168 if (ordered)
7169 btrfs_put_ordered_extent(ordered);
7170 break;
7171 }
7172 }
7173
7174 cur_offset = alloc_start;
7175 while (1) {
7176 em = btrfs_get_extent(inode, NULL, 0, cur_offset,
7177 alloc_end - cur_offset, 0);
7178 BUG_ON(IS_ERR(em) || !em);
7179 last_byte = min(extent_map_end(em), alloc_end);
7180 last_byte = (last_byte + mask) & ~mask;
7181 if (em->block_start == EXTENT_MAP_HOLE ||
7182 (cur_offset >= inode->i_size &&
7183 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
7184 ret = btrfs_prealloc_file_range(inode, mode, cur_offset,
7185 last_byte - cur_offset,
7186 1 << inode->i_blkbits,
7187 offset + len,
7188 &alloc_hint);
7189 if (ret < 0) {
7190 free_extent_map(em);
7191 break;
7192 }
7193 }
7194 free_extent_map(em);
7195
7196 cur_offset = last_byte;
7197 if (cur_offset >= alloc_end) {
7198 ret = 0;
7199 break;
7200 }
7201 }
7202 unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
7203 &cached_state, GFP_NOFS);
7204
7205 btrfs_free_reserved_data_space(inode, alloc_end - alloc_start);
7206out:
7207 mutex_unlock(&inode->i_mutex);
7208 return ret;
7209}
7210
7211static int btrfs_set_page_dirty(struct page *page) 7434static int btrfs_set_page_dirty(struct page *page)
7212{ 7435{
7213 return __set_page_dirty_nobuffers(page); 7436 return __set_page_dirty_nobuffers(page);
@@ -7215,6 +7438,10 @@ static int btrfs_set_page_dirty(struct page *page)
7215 7438
7216static int btrfs_permission(struct inode *inode, int mask, unsigned int flags) 7439static int btrfs_permission(struct inode *inode, int mask, unsigned int flags)
7217{ 7440{
7441 struct btrfs_root *root = BTRFS_I(inode)->root;
7442
7443 if (btrfs_root_readonly(root) && (mask & MAY_WRITE))
7444 return -EROFS;
7218 if ((BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) && (mask & MAY_WRITE)) 7445 if ((BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) && (mask & MAY_WRITE))
7219 return -EACCES; 7446 return -EACCES;
7220 return generic_permission(inode, mask, flags, btrfs_check_acl); 7447 return generic_permission(inode, mask, flags, btrfs_check_acl);
@@ -7286,7 +7513,6 @@ static const struct address_space_operations btrfs_aops = {
7286 .writepage = btrfs_writepage, 7513 .writepage = btrfs_writepage,
7287 .writepages = btrfs_writepages, 7514 .writepages = btrfs_writepages,
7288 .readpages = btrfs_readpages, 7515 .readpages = btrfs_readpages,
7289 .sync_page = block_sync_page,
7290 .direct_IO = btrfs_direct_IO, 7516 .direct_IO = btrfs_direct_IO,
7291 .invalidatepage = btrfs_invalidatepage, 7517 .invalidatepage = btrfs_invalidatepage,
7292 .releasepage = btrfs_releasepage, 7518 .releasepage = btrfs_releasepage,
@@ -7302,7 +7528,6 @@ static const struct address_space_operations btrfs_symlink_aops = {
7302}; 7528};
7303 7529
7304static const struct inode_operations btrfs_file_inode_operations = { 7530static const struct inode_operations btrfs_file_inode_operations = {
7305 .truncate = btrfs_truncate,
7306 .getattr = btrfs_getattr, 7531 .getattr = btrfs_getattr,
7307 .setattr = btrfs_setattr, 7532 .setattr = btrfs_setattr,
7308 .setxattr = btrfs_setxattr, 7533 .setxattr = btrfs_setxattr,
@@ -7310,7 +7535,6 @@ static const struct inode_operations btrfs_file_inode_operations = {
7310 .listxattr = btrfs_listxattr, 7535 .listxattr = btrfs_listxattr,
7311 .removexattr = btrfs_removexattr, 7536 .removexattr = btrfs_removexattr,
7312 .permission = btrfs_permission, 7537 .permission = btrfs_permission,
7313 .fallocate = btrfs_fallocate,
7314 .fiemap = btrfs_fiemap, 7538 .fiemap = btrfs_fiemap,
7315}; 7539};
7316static const struct inode_operations btrfs_special_inode_operations = { 7540static const struct inode_operations btrfs_special_inode_operations = {
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-17 01:47:57 -0400