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.c507
1 files changed, 298 insertions, 209 deletions
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 85a1e5053fe6..16d9e8e191e6 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -71,6 +71,7 @@ static const struct file_operations btrfs_dir_file_operations;
71static struct extent_io_ops btrfs_extent_io_ops; 71static struct extent_io_ops btrfs_extent_io_ops;
72 72
73static struct kmem_cache *btrfs_inode_cachep; 73static struct kmem_cache *btrfs_inode_cachep;
74static struct kmem_cache *btrfs_delalloc_work_cachep;
74struct kmem_cache *btrfs_trans_handle_cachep; 75struct kmem_cache *btrfs_trans_handle_cachep;
75struct kmem_cache *btrfs_transaction_cachep; 76struct kmem_cache *btrfs_transaction_cachep;
76struct kmem_cache *btrfs_path_cachep; 77struct kmem_cache *btrfs_path_cachep;
@@ -94,8 +95,10 @@ static noinline int cow_file_range(struct inode *inode,
94 struct page *locked_page, 95 struct page *locked_page,
95 u64 start, u64 end, int *page_started, 96 u64 start, u64 end, int *page_started,
96 unsigned long *nr_written, int unlock); 97 unsigned long *nr_written, int unlock);
97static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans, 98static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
98 struct btrfs_root *root, struct inode *inode); 99 u64 len, u64 orig_start,
100 u64 block_start, u64 block_len,
101 u64 orig_block_len, int type);
99 102
100static int btrfs_init_inode_security(struct btrfs_trans_handle *trans, 103static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
101 struct inode *inode, struct inode *dir, 104 struct inode *inode, struct inode *dir,
@@ -700,14 +703,19 @@ retry:
700 703
701 em->block_start = ins.objectid; 704 em->block_start = ins.objectid;
702 em->block_len = ins.offset; 705 em->block_len = ins.offset;
706 em->orig_block_len = ins.offset;
703 em->bdev = root->fs_info->fs_devices->latest_bdev; 707 em->bdev = root->fs_info->fs_devices->latest_bdev;
704 em->compress_type = async_extent->compress_type; 708 em->compress_type = async_extent->compress_type;
705 set_bit(EXTENT_FLAG_PINNED, &em->flags); 709 set_bit(EXTENT_FLAG_PINNED, &em->flags);
706 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 710 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
711 em->generation = -1;
707 712
708 while (1) { 713 while (1) {
709 write_lock(&em_tree->lock); 714 write_lock(&em_tree->lock);
710 ret = add_extent_mapping(em_tree, em); 715 ret = add_extent_mapping(em_tree, em);
716 if (!ret)
717 list_move(&em->list,
718 &em_tree->modified_extents);
711 write_unlock(&em_tree->lock); 719 write_unlock(&em_tree->lock);
712 if (ret != -EEXIST) { 720 if (ret != -EEXIST) {
713 free_extent_map(em); 721 free_extent_map(em);
@@ -805,14 +813,14 @@ static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
805 * required to start IO on it. It may be clean and already done with 813 * required to start IO on it. It may be clean and already done with
806 * IO when we return. 814 * IO when we return.
807 */ 815 */
808static noinline int cow_file_range(struct inode *inode, 816static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
809 struct page *locked_page, 817 struct inode *inode,
810 u64 start, u64 end, int *page_started, 818 struct btrfs_root *root,
811 unsigned long *nr_written, 819 struct page *locked_page,
812 int unlock) 820 u64 start, u64 end, int *page_started,
821 unsigned long *nr_written,
822 int unlock)
813{ 823{
814 struct btrfs_root *root = BTRFS_I(inode)->root;
815 struct btrfs_trans_handle *trans;
816 u64 alloc_hint = 0; 824 u64 alloc_hint = 0;
817 u64 num_bytes; 825 u64 num_bytes;
818 unsigned long ram_size; 826 unsigned long ram_size;
@@ -825,25 +833,10 @@ static noinline int cow_file_range(struct inode *inode,
825 int ret = 0; 833 int ret = 0;
826 834
827 BUG_ON(btrfs_is_free_space_inode(inode)); 835 BUG_ON(btrfs_is_free_space_inode(inode));
828 trans = btrfs_join_transaction(root);
829 if (IS_ERR(trans)) {
830 extent_clear_unlock_delalloc(inode,
831 &BTRFS_I(inode)->io_tree,
832 start, end, locked_page,
833 EXTENT_CLEAR_UNLOCK_PAGE |
834 EXTENT_CLEAR_UNLOCK |
835 EXTENT_CLEAR_DELALLOC |
836 EXTENT_CLEAR_DIRTY |
837 EXTENT_SET_WRITEBACK |
838 EXTENT_END_WRITEBACK);
839 return PTR_ERR(trans);
840 }
841 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
842 836
843 num_bytes = (end - start + blocksize) & ~(blocksize - 1); 837 num_bytes = (end - start + blocksize) & ~(blocksize - 1);
844 num_bytes = max(blocksize, num_bytes); 838 num_bytes = max(blocksize, num_bytes);
845 disk_num_bytes = num_bytes; 839 disk_num_bytes = num_bytes;
846 ret = 0;
847 840
848 /* if this is a small write inside eof, kick off defrag */ 841 /* if this is a small write inside eof, kick off defrag */
849 if (num_bytes < 64 * 1024 && 842 if (num_bytes < 64 * 1024 &&
@@ -902,12 +895,17 @@ static noinline int cow_file_range(struct inode *inode,
902 895
903 em->block_start = ins.objectid; 896 em->block_start = ins.objectid;
904 em->block_len = ins.offset; 897 em->block_len = ins.offset;
898 em->orig_block_len = ins.offset;
905 em->bdev = root->fs_info->fs_devices->latest_bdev; 899 em->bdev = root->fs_info->fs_devices->latest_bdev;
906 set_bit(EXTENT_FLAG_PINNED, &em->flags); 900 set_bit(EXTENT_FLAG_PINNED, &em->flags);
901 em->generation = -1;
907 902
908 while (1) { 903 while (1) {
909 write_lock(&em_tree->lock); 904 write_lock(&em_tree->lock);
910 ret = add_extent_mapping(em_tree, em); 905 ret = add_extent_mapping(em_tree, em);
906 if (!ret)
907 list_move(&em->list,
908 &em_tree->modified_extents);
911 write_unlock(&em_tree->lock); 909 write_unlock(&em_tree->lock);
912 if (ret != -EEXIST) { 910 if (ret != -EEXIST) {
913 free_extent_map(em); 911 free_extent_map(em);
@@ -954,11 +952,9 @@ static noinline int cow_file_range(struct inode *inode,
954 alloc_hint = ins.objectid + ins.offset; 952 alloc_hint = ins.objectid + ins.offset;
955 start += cur_alloc_size; 953 start += cur_alloc_size;
956 } 954 }
957 ret = 0;
958out: 955out:
959 btrfs_end_transaction(trans, root);
960
961 return ret; 956 return ret;
957
962out_unlock: 958out_unlock:
963 extent_clear_unlock_delalloc(inode, 959 extent_clear_unlock_delalloc(inode,
964 &BTRFS_I(inode)->io_tree, 960 &BTRFS_I(inode)->io_tree,
@@ -973,6 +969,39 @@ out_unlock:
973 goto out; 969 goto out;
974} 970}
975 971
972static noinline int cow_file_range(struct inode *inode,
973 struct page *locked_page,
974 u64 start, u64 end, int *page_started,
975 unsigned long *nr_written,
976 int unlock)
977{
978 struct btrfs_trans_handle *trans;
979 struct btrfs_root *root = BTRFS_I(inode)->root;
980 int ret;
981
982 trans = btrfs_join_transaction(root);
983 if (IS_ERR(trans)) {
984 extent_clear_unlock_delalloc(inode,
985 &BTRFS_I(inode)->io_tree,
986 start, end, locked_page,
987 EXTENT_CLEAR_UNLOCK_PAGE |
988 EXTENT_CLEAR_UNLOCK |
989 EXTENT_CLEAR_DELALLOC |
990 EXTENT_CLEAR_DIRTY |
991 EXTENT_SET_WRITEBACK |
992 EXTENT_END_WRITEBACK);
993 return PTR_ERR(trans);
994 }
995 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
996
997 ret = __cow_file_range(trans, inode, root, locked_page, start, end,
998 page_started, nr_written, unlock);
999
1000 btrfs_end_transaction(trans, root);
1001
1002 return ret;
1003}
1004
976/* 1005/*
977 * work queue call back to started compression on a file and pages 1006 * work queue call back to started compression on a file and pages
978 */ 1007 */
@@ -1128,6 +1157,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
1128 u64 extent_offset; 1157 u64 extent_offset;
1129 u64 disk_bytenr; 1158 u64 disk_bytenr;
1130 u64 num_bytes; 1159 u64 num_bytes;
1160 u64 disk_num_bytes;
1131 int extent_type; 1161 int extent_type;
1132 int ret, err; 1162 int ret, err;
1133 int type; 1163 int type;
@@ -1230,6 +1260,8 @@ next_slot:
1230 extent_offset = btrfs_file_extent_offset(leaf, fi); 1260 extent_offset = btrfs_file_extent_offset(leaf, fi);
1231 extent_end = found_key.offset + 1261 extent_end = found_key.offset +
1232 btrfs_file_extent_num_bytes(leaf, fi); 1262 btrfs_file_extent_num_bytes(leaf, fi);
1263 disk_num_bytes =
1264 btrfs_file_extent_disk_num_bytes(leaf, fi);
1233 if (extent_end <= start) { 1265 if (extent_end <= start) {
1234 path->slots[0]++; 1266 path->slots[0]++;
1235 goto next_slot; 1267 goto next_slot;
@@ -1283,9 +1315,9 @@ out_check:
1283 1315
1284 btrfs_release_path(path); 1316 btrfs_release_path(path);
1285 if (cow_start != (u64)-1) { 1317 if (cow_start != (u64)-1) {
1286 ret = cow_file_range(inode, locked_page, cow_start, 1318 ret = __cow_file_range(trans, inode, root, locked_page,
1287 found_key.offset - 1, page_started, 1319 cow_start, found_key.offset - 1,
1288 nr_written, 1); 1320 page_started, nr_written, 1);
1289 if (ret) { 1321 if (ret) {
1290 btrfs_abort_transaction(trans, root, ret); 1322 btrfs_abort_transaction(trans, root, ret);
1291 goto error; 1323 goto error;
@@ -1300,16 +1332,21 @@ out_check:
1300 em = alloc_extent_map(); 1332 em = alloc_extent_map();
1301 BUG_ON(!em); /* -ENOMEM */ 1333 BUG_ON(!em); /* -ENOMEM */
1302 em->start = cur_offset; 1334 em->start = cur_offset;
1303 em->orig_start = em->start; 1335 em->orig_start = found_key.offset - extent_offset;
1304 em->len = num_bytes; 1336 em->len = num_bytes;
1305 em->block_len = num_bytes; 1337 em->block_len = num_bytes;
1306 em->block_start = disk_bytenr; 1338 em->block_start = disk_bytenr;
1339 em->orig_block_len = disk_num_bytes;
1307 em->bdev = root->fs_info->fs_devices->latest_bdev; 1340 em->bdev = root->fs_info->fs_devices->latest_bdev;
1308 set_bit(EXTENT_FLAG_PINNED, &em->flags); 1341 set_bit(EXTENT_FLAG_PINNED, &em->flags);
1309 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 1342 set_bit(EXTENT_FLAG_FILLING, &em->flags);
1343 em->generation = -1;
1310 while (1) { 1344 while (1) {
1311 write_lock(&em_tree->lock); 1345 write_lock(&em_tree->lock);
1312 ret = add_extent_mapping(em_tree, em); 1346 ret = add_extent_mapping(em_tree, em);
1347 if (!ret)
1348 list_move(&em->list,
1349 &em_tree->modified_extents);
1313 write_unlock(&em_tree->lock); 1350 write_unlock(&em_tree->lock);
1314 if (ret != -EEXIST) { 1351 if (ret != -EEXIST) {
1315 free_extent_map(em); 1352 free_extent_map(em);
@@ -1354,8 +1391,9 @@ out_check:
1354 } 1391 }
1355 1392
1356 if (cow_start != (u64)-1) { 1393 if (cow_start != (u64)-1) {
1357 ret = cow_file_range(inode, locked_page, cow_start, end, 1394 ret = __cow_file_range(trans, inode, root, locked_page,
1358 page_started, nr_written, 1); 1395 cow_start, end,
1396 page_started, nr_written, 1);
1359 if (ret) { 1397 if (ret) {
1360 btrfs_abort_transaction(trans, root, ret); 1398 btrfs_abort_transaction(trans, root, ret);
1361 goto error; 1399 goto error;
@@ -1533,7 +1571,6 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
1533 unsigned long bio_flags) 1571 unsigned long bio_flags)
1534{ 1572{
1535 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root; 1573 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1536 struct btrfs_mapping_tree *map_tree;
1537 u64 logical = (u64)bio->bi_sector << 9; 1574 u64 logical = (u64)bio->bi_sector << 9;
1538 u64 length = 0; 1575 u64 length = 0;
1539 u64 map_length; 1576 u64 map_length;
@@ -1543,11 +1580,10 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
1543 return 0; 1580 return 0;
1544 1581
1545 length = bio->bi_size; 1582 length = bio->bi_size;
1546 map_tree = &root->fs_info->mapping_tree;
1547 map_length = length; 1583 map_length = length;
1548 ret = btrfs_map_block(map_tree, READ, logical, 1584 ret = btrfs_map_block(root->fs_info, READ, logical,
1549 &map_length, NULL, 0); 1585 &map_length, NULL, 0);
1550 /* Will always return 0 or 1 with map_multi == NULL */ 1586 /* Will always return 0 with map_multi == NULL */
1551 BUG_ON(ret < 0); 1587 BUG_ON(ret < 0);
1552 if (map_length < length + size) 1588 if (map_length < length + size)
1553 return 1; 1589 return 1;
@@ -1588,7 +1624,12 @@ static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1588 u64 bio_offset) 1624 u64 bio_offset)
1589{ 1625{
1590 struct btrfs_root *root = BTRFS_I(inode)->root; 1626 struct btrfs_root *root = BTRFS_I(inode)->root;
1591 return btrfs_map_bio(root, rw, bio, mirror_num, 1); 1627 int ret;
1628
1629 ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
1630 if (ret)
1631 bio_endio(bio, ret);
1632 return ret;
1592} 1633}
1593 1634
1594/* 1635/*
@@ -1603,6 +1644,7 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1603 int ret = 0; 1644 int ret = 0;
1604 int skip_sum; 1645 int skip_sum;
1605 int metadata = 0; 1646 int metadata = 0;
1647 int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
1606 1648
1607 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; 1649 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1608 1650
@@ -1612,31 +1654,43 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1612 if (!(rw & REQ_WRITE)) { 1654 if (!(rw & REQ_WRITE)) {
1613 ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata); 1655 ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
1614 if (ret) 1656 if (ret)
1615 return ret; 1657 goto out;
1616 1658
1617 if (bio_flags & EXTENT_BIO_COMPRESSED) { 1659 if (bio_flags & EXTENT_BIO_COMPRESSED) {
1618 return btrfs_submit_compressed_read(inode, bio, 1660 ret = btrfs_submit_compressed_read(inode, bio,
1619 mirror_num, bio_flags); 1661 mirror_num,
1662 bio_flags);
1663 goto out;
1620 } else if (!skip_sum) { 1664 } else if (!skip_sum) {
1621 ret = btrfs_lookup_bio_sums(root, inode, bio, NULL); 1665 ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
1622 if (ret) 1666 if (ret)
1623 return ret; 1667 goto out;
1624 } 1668 }
1625 goto mapit; 1669 goto mapit;
1626 } else if (!skip_sum) { 1670 } else if (async && !skip_sum) {
1627 /* csum items have already been cloned */ 1671 /* csum items have already been cloned */
1628 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID) 1672 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
1629 goto mapit; 1673 goto mapit;
1630 /* we're doing a write, do the async checksumming */ 1674 /* we're doing a write, do the async checksumming */
1631 return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info, 1675 ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1632 inode, rw, bio, mirror_num, 1676 inode, rw, bio, mirror_num,
1633 bio_flags, bio_offset, 1677 bio_flags, bio_offset,
1634 __btrfs_submit_bio_start, 1678 __btrfs_submit_bio_start,
1635 __btrfs_submit_bio_done); 1679 __btrfs_submit_bio_done);
1680 goto out;
1681 } else if (!skip_sum) {
1682 ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1683 if (ret)
1684 goto out;
1636 } 1685 }
1637 1686
1638mapit: 1687mapit:
1639 return btrfs_map_bio(root, rw, bio, mirror_num, 0); 1688 ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
1689
1690out:
1691 if (ret < 0)
1692 bio_endio(bio, ret);
1693 return ret;
1640} 1694}
1641 1695
1642/* 1696/*
@@ -1659,8 +1713,7 @@ static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1659int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end, 1713int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
1660 struct extent_state **cached_state) 1714 struct extent_state **cached_state)
1661{ 1715{
1662 if ((end & (PAGE_CACHE_SIZE - 1)) == 0) 1716 WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
1663 WARN_ON(1);
1664 return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end, 1717 return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1665 cached_state, GFP_NOFS); 1718 cached_state, GFP_NOFS);
1666} 1719}
@@ -1869,22 +1922,20 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
1869 1922
1870 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { 1923 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
1871 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */ 1924 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
1872 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); 1925 btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1873 if (!ret) { 1926 if (nolock)
1874 if (nolock) 1927 trans = btrfs_join_transaction_nolock(root);
1875 trans = btrfs_join_transaction_nolock(root); 1928 else
1876 else 1929 trans = btrfs_join_transaction(root);
1877 trans = btrfs_join_transaction(root); 1930 if (IS_ERR(trans)) {
1878 if (IS_ERR(trans)) { 1931 ret = PTR_ERR(trans);
1879 ret = PTR_ERR(trans); 1932 trans = NULL;
1880 trans = NULL; 1933 goto out;
1881 goto out;
1882 }
1883 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1884 ret = btrfs_update_inode_fallback(trans, root, inode);
1885 if (ret) /* -ENOMEM or corruption */
1886 btrfs_abort_transaction(trans, root, ret);
1887 } 1934 }
1935 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1936 ret = btrfs_update_inode_fallback(trans, root, inode);
1937 if (ret) /* -ENOMEM or corruption */
1938 btrfs_abort_transaction(trans, root, ret);
1888 goto out; 1939 goto out;
1889 } 1940 }
1890 1941
@@ -1933,15 +1984,11 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
1933 add_pending_csums(trans, inode, ordered_extent->file_offset, 1984 add_pending_csums(trans, inode, ordered_extent->file_offset,
1934 &ordered_extent->list); 1985 &ordered_extent->list);
1935 1986
1936 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); 1987 btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1937 if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { 1988 ret = btrfs_update_inode_fallback(trans, root, inode);
1938 ret = btrfs_update_inode_fallback(trans, root, inode); 1989 if (ret) { /* -ENOMEM or corruption */
1939 if (ret) { /* -ENOMEM or corruption */ 1990 btrfs_abort_transaction(trans, root, ret);
1940 btrfs_abort_transaction(trans, root, ret); 1991 goto out_unlock;
1941 goto out_unlock;
1942 }
1943 } else {
1944 btrfs_set_inode_last_trans(trans, inode);
1945 } 1992 }
1946 ret = 0; 1993 ret = 0;
1947out_unlock: 1994out_unlock:
@@ -2746,8 +2793,9 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
2746 return btrfs_update_inode_item(trans, root, inode); 2793 return btrfs_update_inode_item(trans, root, inode);
2747} 2794}
2748 2795
2749static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans, 2796noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
2750 struct btrfs_root *root, struct inode *inode) 2797 struct btrfs_root *root,
2798 struct inode *inode)
2751{ 2799{
2752 int ret; 2800 int ret;
2753 2801
@@ -3075,7 +3123,6 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
3075 struct btrfs_trans_handle *trans; 3123 struct btrfs_trans_handle *trans;
3076 struct inode *inode = dentry->d_inode; 3124 struct inode *inode = dentry->d_inode;
3077 int ret; 3125 int ret;
3078 unsigned long nr = 0;
3079 3126
3080 trans = __unlink_start_trans(dir, dentry); 3127 trans = __unlink_start_trans(dir, dentry);
3081 if (IS_ERR(trans)) 3128 if (IS_ERR(trans))
@@ -3095,9 +3142,8 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
3095 } 3142 }
3096 3143
3097out: 3144out:
3098 nr = trans->blocks_used;
3099 __unlink_end_trans(trans, root); 3145 __unlink_end_trans(trans, root);
3100 btrfs_btree_balance_dirty(root, nr); 3146 btrfs_btree_balance_dirty(root);
3101 return ret; 3147 return ret;
3102} 3148}
3103 3149
@@ -3187,7 +3233,6 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
3187 int err = 0; 3233 int err = 0;
3188 struct btrfs_root *root = BTRFS_I(dir)->root; 3234 struct btrfs_root *root = BTRFS_I(dir)->root;
3189 struct btrfs_trans_handle *trans; 3235 struct btrfs_trans_handle *trans;
3190 unsigned long nr = 0;
3191 3236
3192 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE) 3237 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
3193 return -ENOTEMPTY; 3238 return -ENOTEMPTY;
@@ -3216,9 +3261,8 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
3216 if (!err) 3261 if (!err)
3217 btrfs_i_size_write(inode, 0); 3262 btrfs_i_size_write(inode, 0);
3218out: 3263out:
3219 nr = trans->blocks_used;
3220 __unlink_end_trans(trans, root); 3264 __unlink_end_trans(trans, root);
3221 btrfs_btree_balance_dirty(root, nr); 3265 btrfs_btree_balance_dirty(root);
3222 3266
3223 return err; 3267 return err;
3224} 3268}
@@ -3498,11 +3542,11 @@ int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
3498 if (ret) 3542 if (ret)
3499 goto out; 3543 goto out;
3500 3544
3501 ret = -ENOMEM;
3502again: 3545again:
3503 page = find_or_create_page(mapping, index, mask); 3546 page = find_or_create_page(mapping, index, mask);
3504 if (!page) { 3547 if (!page) {
3505 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE); 3548 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
3549 ret = -ENOMEM;
3506 goto out; 3550 goto out;
3507 } 3551 }
3508 3552
@@ -3551,7 +3595,6 @@ again:
3551 goto out_unlock; 3595 goto out_unlock;
3552 } 3596 }
3553 3597
3554 ret = 0;
3555 if (offset != PAGE_CACHE_SIZE) { 3598 if (offset != PAGE_CACHE_SIZE) {
3556 if (!len) 3599 if (!len)
3557 len = PAGE_CACHE_SIZE - offset; 3600 len = PAGE_CACHE_SIZE - offset;
@@ -3669,6 +3712,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
3669 3712
3670 hole_em->block_start = EXTENT_MAP_HOLE; 3713 hole_em->block_start = EXTENT_MAP_HOLE;
3671 hole_em->block_len = 0; 3714 hole_em->block_len = 0;
3715 hole_em->orig_block_len = 0;
3672 hole_em->bdev = root->fs_info->fs_devices->latest_bdev; 3716 hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
3673 hole_em->compress_type = BTRFS_COMPRESS_NONE; 3717 hole_em->compress_type = BTRFS_COMPRESS_NONE;
3674 hole_em->generation = trans->transid; 3718 hole_em->generation = trans->transid;
@@ -3784,7 +3828,6 @@ void btrfs_evict_inode(struct inode *inode)
3784 struct btrfs_root *root = BTRFS_I(inode)->root; 3828 struct btrfs_root *root = BTRFS_I(inode)->root;
3785 struct btrfs_block_rsv *rsv, *global_rsv; 3829 struct btrfs_block_rsv *rsv, *global_rsv;
3786 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1); 3830 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
3787 unsigned long nr;
3788 int ret; 3831 int ret;
3789 3832
3790 trace_btrfs_inode_evict(inode); 3833 trace_btrfs_inode_evict(inode);
@@ -3830,7 +3873,8 @@ void btrfs_evict_inode(struct inode *inode)
3830 * inode item when doing the truncate. 3873 * inode item when doing the truncate.
3831 */ 3874 */
3832 while (1) { 3875 while (1) {
3833 ret = btrfs_block_rsv_refill_noflush(root, rsv, min_size); 3876 ret = btrfs_block_rsv_refill(root, rsv, min_size,
3877 BTRFS_RESERVE_FLUSH_LIMIT);
3834 3878
3835 /* 3879 /*
3836 * Try and steal from the global reserve since we will 3880 * Try and steal from the global reserve since we will
@@ -3848,7 +3892,7 @@ void btrfs_evict_inode(struct inode *inode)
3848 goto no_delete; 3892 goto no_delete;
3849 } 3893 }
3850 3894
3851 trans = btrfs_start_transaction_noflush(root, 1); 3895 trans = btrfs_start_transaction_lflush(root, 1);
3852 if (IS_ERR(trans)) { 3896 if (IS_ERR(trans)) {
3853 btrfs_orphan_del(NULL, inode); 3897 btrfs_orphan_del(NULL, inode);
3854 btrfs_free_block_rsv(root, rsv); 3898 btrfs_free_block_rsv(root, rsv);
@@ -3865,10 +3909,9 @@ void btrfs_evict_inode(struct inode *inode)
3865 ret = btrfs_update_inode(trans, root, inode); 3909 ret = btrfs_update_inode(trans, root, inode);
3866 BUG_ON(ret); 3910 BUG_ON(ret);
3867 3911
3868 nr = trans->blocks_used;
3869 btrfs_end_transaction(trans, root); 3912 btrfs_end_transaction(trans, root);
3870 trans = NULL; 3913 trans = NULL;
3871 btrfs_btree_balance_dirty(root, nr); 3914 btrfs_btree_balance_dirty(root);
3872 } 3915 }
3873 3916
3874 btrfs_free_block_rsv(root, rsv); 3917 btrfs_free_block_rsv(root, rsv);
@@ -3884,9 +3927,8 @@ void btrfs_evict_inode(struct inode *inode)
3884 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)) 3927 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
3885 btrfs_return_ino(root, btrfs_ino(inode)); 3928 btrfs_return_ino(root, btrfs_ino(inode));
3886 3929
3887 nr = trans->blocks_used;
3888 btrfs_end_transaction(trans, root); 3930 btrfs_end_transaction(trans, root);
3889 btrfs_btree_balance_dirty(root, nr); 3931 btrfs_btree_balance_dirty(root);
3890no_delete: 3932no_delete:
3891 clear_inode(inode); 3933 clear_inode(inode);
3892 return; 3934 return;
@@ -4220,16 +4262,7 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
4220 if (dentry->d_name.len > BTRFS_NAME_LEN) 4262 if (dentry->d_name.len > BTRFS_NAME_LEN)
4221 return ERR_PTR(-ENAMETOOLONG); 4263 return ERR_PTR(-ENAMETOOLONG);
4222 4264
4223 if (unlikely(d_need_lookup(dentry))) { 4265 ret = btrfs_inode_by_name(dir, dentry, &location);
4224 memcpy(&location, dentry->d_fsdata, sizeof(struct btrfs_key));
4225 kfree(dentry->d_fsdata);
4226 dentry->d_fsdata = NULL;
4227 /* This thing is hashed, drop it for now */
4228 d_drop(dentry);
4229 } else {
4230 ret = btrfs_inode_by_name(dir, dentry, &location);
4231 }
4232
4233 if (ret < 0) 4266 if (ret < 0)
4234 return ERR_PTR(ret); 4267 return ERR_PTR(ret);
4235 4268
@@ -4299,11 +4332,6 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
4299 struct dentry *ret; 4332 struct dentry *ret;
4300 4333
4301 ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry); 4334 ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry);
4302 if (unlikely(d_need_lookup(dentry))) {
4303 spin_lock(&dentry->d_lock);
4304 dentry->d_flags &= ~DCACHE_NEED_LOOKUP;
4305 spin_unlock(&dentry->d_lock);
4306 }
4307 return ret; 4335 return ret;
4308} 4336}
4309 4337
@@ -4776,8 +4804,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
4776 if (S_ISREG(mode)) { 4804 if (S_ISREG(mode)) {
4777 if (btrfs_test_opt(root, NODATASUM)) 4805 if (btrfs_test_opt(root, NODATASUM))
4778 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; 4806 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
4779 if (btrfs_test_opt(root, NODATACOW) || 4807 if (btrfs_test_opt(root, NODATACOW))
4780 (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
4781 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW; 4808 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
4782 } 4809 }
4783 4810
@@ -4843,7 +4870,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
4843 ret = btrfs_insert_dir_item(trans, root, name, name_len, 4870 ret = btrfs_insert_dir_item(trans, root, name, name_len,
4844 parent_inode, &key, 4871 parent_inode, &key,
4845 btrfs_inode_type(inode), index); 4872 btrfs_inode_type(inode), index);
4846 if (ret == -EEXIST) 4873 if (ret == -EEXIST || ret == -EOVERFLOW)
4847 goto fail_dir_item; 4874 goto fail_dir_item;
4848 else if (ret) { 4875 else if (ret) {
4849 btrfs_abort_transaction(trans, root, ret); 4876 btrfs_abort_transaction(trans, root, ret);
@@ -4898,7 +4925,6 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
4898 int err; 4925 int err;
4899 int drop_inode = 0; 4926 int drop_inode = 0;
4900 u64 objectid; 4927 u64 objectid;
4901 unsigned long nr = 0;
4902 u64 index = 0; 4928 u64 index = 0;
4903 4929
4904 if (!new_valid_dev(rdev)) 4930 if (!new_valid_dev(rdev))
@@ -4931,6 +4957,12 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
4931 goto out_unlock; 4957 goto out_unlock;
4932 } 4958 }
4933 4959
4960 err = btrfs_update_inode(trans, root, inode);
4961 if (err) {
4962 drop_inode = 1;
4963 goto out_unlock;
4964 }
4965
4934 /* 4966 /*
4935 * If the active LSM wants to access the inode during 4967 * If the active LSM wants to access the inode during
4936 * d_instantiate it needs these. Smack checks to see 4968 * d_instantiate it needs these. Smack checks to see
@@ -4948,9 +4980,8 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
4948 d_instantiate(dentry, inode); 4980 d_instantiate(dentry, inode);
4949 } 4981 }
4950out_unlock: 4982out_unlock:
4951 nr = trans->blocks_used;
4952 btrfs_end_transaction(trans, root); 4983 btrfs_end_transaction(trans, root);
4953 btrfs_btree_balance_dirty(root, nr); 4984 btrfs_btree_balance_dirty(root);
4954 if (drop_inode) { 4985 if (drop_inode) {
4955 inode_dec_link_count(inode); 4986 inode_dec_link_count(inode);
4956 iput(inode); 4987 iput(inode);
@@ -4964,9 +4995,8 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
4964 struct btrfs_trans_handle *trans; 4995 struct btrfs_trans_handle *trans;
4965 struct btrfs_root *root = BTRFS_I(dir)->root; 4996 struct btrfs_root *root = BTRFS_I(dir)->root;
4966 struct inode *inode = NULL; 4997 struct inode *inode = NULL;
4967 int drop_inode = 0; 4998 int drop_inode_on_err = 0;
4968 int err; 4999 int err;
4969 unsigned long nr = 0;
4970 u64 objectid; 5000 u64 objectid;
4971 u64 index = 0; 5001 u64 index = 0;
4972 5002
@@ -4990,12 +5020,15 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
4990 err = PTR_ERR(inode); 5020 err = PTR_ERR(inode);
4991 goto out_unlock; 5021 goto out_unlock;
4992 } 5022 }
5023 drop_inode_on_err = 1;
4993 5024
4994 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); 5025 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
4995 if (err) { 5026 if (err)
4996 drop_inode = 1; 5027 goto out_unlock;
5028
5029 err = btrfs_update_inode(trans, root, inode);
5030 if (err)
4997 goto out_unlock; 5031 goto out_unlock;
4998 }
4999 5032
5000 /* 5033 /*
5001 * If the active LSM wants to access the inode during 5034 * If the active LSM wants to access the inode during
@@ -5008,21 +5041,20 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
5008 5041
5009 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 5042 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
5010 if (err) 5043 if (err)
5011 drop_inode = 1; 5044 goto out_unlock;
5012 else { 5045
5013 inode->i_mapping->a_ops = &btrfs_aops; 5046 inode->i_mapping->a_ops = &btrfs_aops;
5014 inode->i_mapping->backing_dev_info = &root->fs_info->bdi; 5047 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
5015 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops; 5048 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
5016 d_instantiate(dentry, inode); 5049 d_instantiate(dentry, inode);
5017 } 5050
5018out_unlock: 5051out_unlock:
5019 nr = trans->blocks_used;
5020 btrfs_end_transaction(trans, root); 5052 btrfs_end_transaction(trans, root);
5021 if (drop_inode) { 5053 if (err && drop_inode_on_err) {
5022 inode_dec_link_count(inode); 5054 inode_dec_link_count(inode);
5023 iput(inode); 5055 iput(inode);
5024 } 5056 }
5025 btrfs_btree_balance_dirty(root, nr); 5057 btrfs_btree_balance_dirty(root);
5026 return err; 5058 return err;
5027} 5059}
5028 5060
@@ -5033,7 +5065,6 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
5033 struct btrfs_root *root = BTRFS_I(dir)->root; 5065 struct btrfs_root *root = BTRFS_I(dir)->root;
5034 struct inode *inode = old_dentry->d_inode; 5066 struct inode *inode = old_dentry->d_inode;
5035 u64 index; 5067 u64 index;
5036 unsigned long nr = 0;
5037 int err; 5068 int err;
5038 int drop_inode = 0; 5069 int drop_inode = 0;
5039 5070
@@ -5063,6 +5094,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
5063 inode_inc_iversion(inode); 5094 inode_inc_iversion(inode);
5064 inode->i_ctime = CURRENT_TIME; 5095 inode->i_ctime = CURRENT_TIME;
5065 ihold(inode); 5096 ihold(inode);
5097 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
5066 5098
5067 err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index); 5099 err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
5068 5100
@@ -5077,14 +5109,13 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
5077 btrfs_log_new_name(trans, inode, NULL, parent); 5109 btrfs_log_new_name(trans, inode, NULL, parent);
5078 } 5110 }
5079 5111
5080 nr = trans->blocks_used;
5081 btrfs_end_transaction(trans, root); 5112 btrfs_end_transaction(trans, root);
5082fail: 5113fail:
5083 if (drop_inode) { 5114 if (drop_inode) {
5084 inode_dec_link_count(inode); 5115 inode_dec_link_count(inode);
5085 iput(inode); 5116 iput(inode);
5086 } 5117 }
5087 btrfs_btree_balance_dirty(root, nr); 5118 btrfs_btree_balance_dirty(root);
5088 return err; 5119 return err;
5089} 5120}
5090 5121
@@ -5097,7 +5128,6 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
5097 int drop_on_err = 0; 5128 int drop_on_err = 0;
5098 u64 objectid = 0; 5129 u64 objectid = 0;
5099 u64 index = 0; 5130 u64 index = 0;
5100 unsigned long nr = 1;
5101 5131
5102 /* 5132 /*
5103 * 2 items for inode and ref 5133 * 2 items for inode and ref
@@ -5143,11 +5173,10 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
5143 drop_on_err = 0; 5173 drop_on_err = 0;
5144 5174
5145out_fail: 5175out_fail:
5146 nr = trans->blocks_used;
5147 btrfs_end_transaction(trans, root); 5176 btrfs_end_transaction(trans, root);
5148 if (drop_on_err) 5177 if (drop_on_err)
5149 iput(inode); 5178 iput(inode);
5150 btrfs_btree_balance_dirty(root, nr); 5179 btrfs_btree_balance_dirty(root);
5151 return err; 5180 return err;
5152} 5181}
5153 5182
@@ -5341,6 +5370,7 @@ again:
5341 if (start + len <= found_key.offset) 5370 if (start + len <= found_key.offset)
5342 goto not_found; 5371 goto not_found;
5343 em->start = start; 5372 em->start = start;
5373 em->orig_start = start;
5344 em->len = found_key.offset - start; 5374 em->len = found_key.offset - start;
5345 goto not_found_em; 5375 goto not_found_em;
5346 } 5376 }
@@ -5351,6 +5381,8 @@ again:
5351 em->len = extent_end - extent_start; 5381 em->len = extent_end - extent_start;
5352 em->orig_start = extent_start - 5382 em->orig_start = extent_start -
5353 btrfs_file_extent_offset(leaf, item); 5383 btrfs_file_extent_offset(leaf, item);
5384 em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
5385 item);
5354 bytenr = btrfs_file_extent_disk_bytenr(leaf, item); 5386 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
5355 if (bytenr == 0) { 5387 if (bytenr == 0) {
5356 em->block_start = EXTENT_MAP_HOLE; 5388 em->block_start = EXTENT_MAP_HOLE;
@@ -5360,8 +5392,7 @@ again:
5360 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 5392 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5361 em->compress_type = compress_type; 5393 em->compress_type = compress_type;
5362 em->block_start = bytenr; 5394 em->block_start = bytenr;
5363 em->block_len = btrfs_file_extent_disk_num_bytes(leaf, 5395 em->block_len = em->orig_block_len;
5364 item);
5365 } else { 5396 } else {
5366 bytenr += btrfs_file_extent_offset(leaf, item); 5397 bytenr += btrfs_file_extent_offset(leaf, item);
5367 em->block_start = bytenr; 5398 em->block_start = bytenr;
@@ -5391,7 +5422,8 @@ again:
5391 em->start = extent_start + extent_offset; 5422 em->start = extent_start + extent_offset;
5392 em->len = (copy_size + root->sectorsize - 1) & 5423 em->len = (copy_size + root->sectorsize - 1) &
5393 ~((u64)root->sectorsize - 1); 5424 ~((u64)root->sectorsize - 1);
5394 em->orig_start = EXTENT_MAP_INLINE; 5425 em->orig_block_len = em->len;
5426 em->orig_start = em->start;
5395 if (compress_type) { 5427 if (compress_type) {
5396 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 5428 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5397 em->compress_type = compress_type; 5429 em->compress_type = compress_type;
@@ -5440,11 +5472,11 @@ again:
5440 extent_map_end(em) - 1, NULL, GFP_NOFS); 5472 extent_map_end(em) - 1, NULL, GFP_NOFS);
5441 goto insert; 5473 goto insert;
5442 } else { 5474 } else {
5443 printk(KERN_ERR "btrfs unknown found_type %d\n", found_type); 5475 WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
5444 WARN_ON(1);
5445 } 5476 }
5446not_found: 5477not_found:
5447 em->start = start; 5478 em->start = start;
5479 em->orig_start = start;
5448 em->len = len; 5480 em->len = len;
5449not_found_em: 5481not_found_em:
5450 em->block_start = EXTENT_MAP_HOLE; 5482 em->block_start = EXTENT_MAP_HOLE;
@@ -5646,38 +5678,19 @@ out:
5646} 5678}
5647 5679
5648static struct extent_map *btrfs_new_extent_direct(struct inode *inode, 5680static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5649 struct extent_map *em,
5650 u64 start, u64 len) 5681 u64 start, u64 len)
5651{ 5682{
5652 struct btrfs_root *root = BTRFS_I(inode)->root; 5683 struct btrfs_root *root = BTRFS_I(inode)->root;
5653 struct btrfs_trans_handle *trans; 5684 struct btrfs_trans_handle *trans;
5654 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 5685 struct extent_map *em;
5655 struct btrfs_key ins; 5686 struct btrfs_key ins;
5656 u64 alloc_hint; 5687 u64 alloc_hint;
5657 int ret; 5688 int ret;
5658 bool insert = false;
5659
5660 /*
5661 * Ok if the extent map we looked up is a hole and is for the exact
5662 * range we want, there is no reason to allocate a new one, however if
5663 * it is not right then we need to free this one and drop the cache for
5664 * our range.
5665 */
5666 if (em->block_start != EXTENT_MAP_HOLE || em->start != start ||
5667 em->len != len) {
5668 free_extent_map(em);
5669 em = NULL;
5670 insert = true;
5671 btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
5672 }
5673 5689
5674 trans = btrfs_join_transaction(root); 5690 trans = btrfs_join_transaction(root);
5675 if (IS_ERR(trans)) 5691 if (IS_ERR(trans))
5676 return ERR_CAST(trans); 5692 return ERR_CAST(trans);
5677 5693
5678 if (start <= BTRFS_I(inode)->disk_i_size && len < 64 * 1024)
5679 btrfs_add_inode_defrag(trans, inode);
5680
5681 trans->block_rsv = &root->fs_info->delalloc_block_rsv; 5694 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
5682 5695
5683 alloc_hint = get_extent_allocation_hint(inode, start, len); 5696 alloc_hint = get_extent_allocation_hint(inode, start, len);
@@ -5688,37 +5701,10 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5688 goto out; 5701 goto out;
5689 } 5702 }
5690 5703
5691 if (!em) { 5704 em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
5692 em = alloc_extent_map(); 5705 ins.offset, ins.offset, 0);
5693 if (!em) { 5706 if (IS_ERR(em))
5694 em = ERR_PTR(-ENOMEM); 5707 goto out;
5695 goto out;
5696 }
5697 }
5698
5699 em->start = start;
5700 em->orig_start = em->start;
5701 em->len = ins.offset;
5702
5703 em->block_start = ins.objectid;
5704 em->block_len = ins.offset;
5705 em->bdev = root->fs_info->fs_devices->latest_bdev;
5706
5707 /*
5708 * We need to do this because if we're using the original em we searched
5709 * for, we could have EXTENT_FLAG_VACANCY set, and we don't want that.
5710 */
5711 em->flags = 0;
5712 set_bit(EXTENT_FLAG_PINNED, &em->flags);
5713
5714 while (insert) {
5715 write_lock(&em_tree->lock);
5716 ret = add_extent_mapping(em_tree, em);
5717 write_unlock(&em_tree->lock);
5718 if (ret != -EEXIST)
5719 break;
5720 btrfs_drop_extent_cache(inode, start, start + em->len - 1, 0);
5721 }
5722 5708
5723 ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid, 5709 ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
5724 ins.offset, ins.offset, 0); 5710 ins.offset, ins.offset, 0);
@@ -5895,7 +5881,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
5895static struct extent_map *create_pinned_em(struct inode *inode, u64 start, 5881static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
5896 u64 len, u64 orig_start, 5882 u64 len, u64 orig_start,
5897 u64 block_start, u64 block_len, 5883 u64 block_start, u64 block_len,
5898 int type) 5884 u64 orig_block_len, int type)
5899{ 5885{
5900 struct extent_map_tree *em_tree; 5886 struct extent_map_tree *em_tree;
5901 struct extent_map *em; 5887 struct extent_map *em;
@@ -5913,15 +5899,20 @@ static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
5913 em->block_len = block_len; 5899 em->block_len = block_len;
5914 em->block_start = block_start; 5900 em->block_start = block_start;
5915 em->bdev = root->fs_info->fs_devices->latest_bdev; 5901 em->bdev = root->fs_info->fs_devices->latest_bdev;
5902 em->orig_block_len = orig_block_len;
5903 em->generation = -1;
5916 set_bit(EXTENT_FLAG_PINNED, &em->flags); 5904 set_bit(EXTENT_FLAG_PINNED, &em->flags);
5917 if (type == BTRFS_ORDERED_PREALLOC) 5905 if (type == BTRFS_ORDERED_PREALLOC)
5918 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 5906 set_bit(EXTENT_FLAG_FILLING, &em->flags);
5919 5907
5920 do { 5908 do {
5921 btrfs_drop_extent_cache(inode, em->start, 5909 btrfs_drop_extent_cache(inode, em->start,
5922 em->start + em->len - 1, 0); 5910 em->start + em->len - 1, 0);
5923 write_lock(&em_tree->lock); 5911 write_lock(&em_tree->lock);
5924 ret = add_extent_mapping(em_tree, em); 5912 ret = add_extent_mapping(em_tree, em);
5913 if (!ret)
5914 list_move(&em->list,
5915 &em_tree->modified_extents);
5925 write_unlock(&em_tree->lock); 5916 write_unlock(&em_tree->lock);
5926 } while (ret == -EEXIST); 5917 } while (ret == -EEXIST);
5927 5918
@@ -6048,13 +6039,15 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
6048 goto must_cow; 6039 goto must_cow;
6049 6040
6050 if (can_nocow_odirect(trans, inode, start, len) == 1) { 6041 if (can_nocow_odirect(trans, inode, start, len) == 1) {
6051 u64 orig_start = em->start; 6042 u64 orig_start = em->orig_start;
6043 u64 orig_block_len = em->orig_block_len;
6052 6044
6053 if (type == BTRFS_ORDERED_PREALLOC) { 6045 if (type == BTRFS_ORDERED_PREALLOC) {
6054 free_extent_map(em); 6046 free_extent_map(em);
6055 em = create_pinned_em(inode, start, len, 6047 em = create_pinned_em(inode, start, len,
6056 orig_start, 6048 orig_start,
6057 block_start, len, type); 6049 block_start, len,
6050 orig_block_len, type);
6058 if (IS_ERR(em)) { 6051 if (IS_ERR(em)) {
6059 btrfs_end_transaction(trans, root); 6052 btrfs_end_transaction(trans, root);
6060 goto unlock_err; 6053 goto unlock_err;
@@ -6078,7 +6071,8 @@ must_cow:
6078 * it above 6071 * it above
6079 */ 6072 */
6080 len = bh_result->b_size; 6073 len = bh_result->b_size;
6081 em = btrfs_new_extent_direct(inode, em, start, len); 6074 free_extent_map(em);
6075 em = btrfs_new_extent_direct(inode, start, len);
6082 if (IS_ERR(em)) { 6076 if (IS_ERR(em)) {
6083 ret = PTR_ERR(em); 6077 ret = PTR_ERR(em);
6084 goto unlock_err; 6078 goto unlock_err;
@@ -6319,6 +6313,9 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
6319 struct btrfs_root *root = BTRFS_I(inode)->root; 6313 struct btrfs_root *root = BTRFS_I(inode)->root;
6320 int ret; 6314 int ret;
6321 6315
6316 if (async_submit)
6317 async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
6318
6322 bio_get(bio); 6319 bio_get(bio);
6323 6320
6324 if (!write) { 6321 if (!write) {
@@ -6363,7 +6360,6 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
6363{ 6360{
6364 struct inode *inode = dip->inode; 6361 struct inode *inode = dip->inode;
6365 struct btrfs_root *root = BTRFS_I(inode)->root; 6362 struct btrfs_root *root = BTRFS_I(inode)->root;
6366 struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
6367 struct bio *bio; 6363 struct bio *bio;
6368 struct bio *orig_bio = dip->orig_bio; 6364 struct bio *orig_bio = dip->orig_bio;
6369 struct bio_vec *bvec = orig_bio->bi_io_vec; 6365 struct bio_vec *bvec = orig_bio->bi_io_vec;
@@ -6376,7 +6372,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
6376 int async_submit = 0; 6372 int async_submit = 0;
6377 6373
6378 map_length = orig_bio->bi_size; 6374 map_length = orig_bio->bi_size;
6379 ret = btrfs_map_block(map_tree, READ, start_sector << 9, 6375 ret = btrfs_map_block(root->fs_info, READ, start_sector << 9,
6380 &map_length, NULL, 0); 6376 &map_length, NULL, 0);
6381 if (ret) { 6377 if (ret) {
6382 bio_put(orig_bio); 6378 bio_put(orig_bio);
@@ -6430,7 +6426,8 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
6430 bio->bi_end_io = btrfs_end_dio_bio; 6426 bio->bi_end_io = btrfs_end_dio_bio;
6431 6427
6432 map_length = orig_bio->bi_size; 6428 map_length = orig_bio->bi_size;
6433 ret = btrfs_map_block(map_tree, READ, start_sector << 9, 6429 ret = btrfs_map_block(root->fs_info, READ,
6430 start_sector << 9,
6434 &map_length, NULL, 0); 6431 &map_length, NULL, 0);
6435 if (ret) { 6432 if (ret) {
6436 bio_put(bio); 6433 bio_put(bio);
@@ -6583,9 +6580,17 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
6583 btrfs_submit_direct, 0); 6580 btrfs_submit_direct, 0);
6584} 6581}
6585 6582
6583#define BTRFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC)
6584
6586static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 6585static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
6587 __u64 start, __u64 len) 6586 __u64 start, __u64 len)
6588{ 6587{
6588 int ret;
6589
6590 ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
6591 if (ret)
6592 return ret;
6593
6589 return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap); 6594 return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
6590} 6595}
6591 6596
@@ -6856,7 +6861,6 @@ static int btrfs_truncate(struct inode *inode)
6856 int ret; 6861 int ret;
6857 int err = 0; 6862 int err = 0;
6858 struct btrfs_trans_handle *trans; 6863 struct btrfs_trans_handle *trans;
6859 unsigned long nr;
6860 u64 mask = root->sectorsize - 1; 6864 u64 mask = root->sectorsize - 1;
6861 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1); 6865 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
6862 6866
@@ -6979,9 +6983,8 @@ static int btrfs_truncate(struct inode *inode)
6979 break; 6983 break;
6980 } 6984 }
6981 6985
6982 nr = trans->blocks_used;
6983 btrfs_end_transaction(trans, root); 6986 btrfs_end_transaction(trans, root);
6984 btrfs_btree_balance_dirty(root, nr); 6987 btrfs_btree_balance_dirty(root);
6985 6988
6986 trans = btrfs_start_transaction(root, 2); 6989 trans = btrfs_start_transaction(root, 2);
6987 if (IS_ERR(trans)) { 6990 if (IS_ERR(trans)) {
@@ -7015,9 +7018,8 @@ static int btrfs_truncate(struct inode *inode)
7015 if (ret && !err) 7018 if (ret && !err)
7016 err = ret; 7019 err = ret;
7017 7020
7018 nr = trans->blocks_used;
7019 ret = btrfs_end_transaction(trans, root); 7021 ret = btrfs_end_transaction(trans, root);
7020 btrfs_btree_balance_dirty(root, nr); 7022 btrfs_btree_balance_dirty(root);
7021 } 7023 }
7022 7024
7023out: 7025out:
@@ -7094,6 +7096,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
7094 extent_io_tree_init(&ei->io_failure_tree, &inode->i_data); 7096 extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
7095 ei->io_tree.track_uptodate = 1; 7097 ei->io_tree.track_uptodate = 1;
7096 ei->io_failure_tree.track_uptodate = 1; 7098 ei->io_failure_tree.track_uptodate = 1;
7099 atomic_set(&ei->sync_writers, 0);
7097 mutex_init(&ei->log_mutex); 7100 mutex_init(&ei->log_mutex);
7098 mutex_init(&ei->delalloc_mutex); 7101 mutex_init(&ei->delalloc_mutex);
7099 btrfs_ordered_inode_tree_init(&ei->ordered_tree); 7102 btrfs_ordered_inode_tree_init(&ei->ordered_tree);
@@ -7204,6 +7207,8 @@ void btrfs_destroy_cachep(void)
7204 kmem_cache_destroy(btrfs_path_cachep); 7207 kmem_cache_destroy(btrfs_path_cachep);
7205 if (btrfs_free_space_cachep) 7208 if (btrfs_free_space_cachep)
7206 kmem_cache_destroy(btrfs_free_space_cachep); 7209 kmem_cache_destroy(btrfs_free_space_cachep);
7210 if (btrfs_delalloc_work_cachep)
7211 kmem_cache_destroy(btrfs_delalloc_work_cachep);
7207} 7212}
7208 7213
7209int btrfs_init_cachep(void) 7214int btrfs_init_cachep(void)
@@ -7238,6 +7243,13 @@ int btrfs_init_cachep(void)
7238 if (!btrfs_free_space_cachep) 7243 if (!btrfs_free_space_cachep)
7239 goto fail; 7244 goto fail;
7240 7245
7246 btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work",
7247 sizeof(struct btrfs_delalloc_work), 0,
7248 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
7249 NULL);
7250 if (!btrfs_delalloc_work_cachep)
7251 goto fail;
7252
7241 return 0; 7253 return 0;
7242fail: 7254fail:
7243 btrfs_destroy_cachep(); 7255 btrfs_destroy_cachep();
@@ -7309,6 +7321,28 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
7309 if (S_ISDIR(old_inode->i_mode) && new_inode && 7321 if (S_ISDIR(old_inode->i_mode) && new_inode &&
7310 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) 7322 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
7311 return -ENOTEMPTY; 7323 return -ENOTEMPTY;
7324
7325
7326 /* check for collisions, even if the name isn't there */
7327 ret = btrfs_check_dir_item_collision(root, new_dir->i_ino,
7328 new_dentry->d_name.name,
7329 new_dentry->d_name.len);
7330
7331 if (ret) {
7332 if (ret == -EEXIST) {
7333 /* we shouldn't get
7334 * eexist without a new_inode */
7335 if (!new_inode) {
7336 WARN_ON(1);
7337 return ret;
7338 }
7339 } else {
7340 /* maybe -EOVERFLOW */
7341 return ret;
7342 }
7343 }
7344 ret = 0;
7345
7312 /* 7346 /*
7313 * we're using rename to replace one file with another. 7347 * we're using rename to replace one file with another.
7314 * and the replacement file is large. Start IO on it now so 7348 * and the replacement file is large. Start IO on it now so
@@ -7448,6 +7482,49 @@ out_notrans:
7448 return ret; 7482 return ret;
7449} 7483}
7450 7484
7485static void btrfs_run_delalloc_work(struct btrfs_work *work)
7486{
7487 struct btrfs_delalloc_work *delalloc_work;
7488
7489 delalloc_work = container_of(work, struct btrfs_delalloc_work,
7490 work);
7491 if (delalloc_work->wait)
7492 btrfs_wait_ordered_range(delalloc_work->inode, 0, (u64)-1);
7493 else
7494 filemap_flush(delalloc_work->inode->i_mapping);
7495
7496 if (delalloc_work->delay_iput)
7497 btrfs_add_delayed_iput(delalloc_work->inode);
7498 else
7499 iput(delalloc_work->inode);
7500 complete(&delalloc_work->completion);
7501}
7502
7503struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
7504 int wait, int delay_iput)
7505{
7506 struct btrfs_delalloc_work *work;
7507
7508 work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS);
7509 if (!work)
7510 return NULL;
7511
7512 init_completion(&work->completion);
7513 INIT_LIST_HEAD(&work->list);
7514 work->inode = inode;
7515 work->wait = wait;
7516 work->delay_iput = delay_iput;
7517 work->work.func = btrfs_run_delalloc_work;
7518
7519 return work;
7520}
7521
7522void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work)
7523{
7524 wait_for_completion(&work->completion);
7525 kmem_cache_free(btrfs_delalloc_work_cachep, work);
7526}
7527
7451/* 7528/*
7452 * some fairly slow code that needs optimization. This walks the list 7529 * some fairly slow code that needs optimization. This walks the list
7453 * of all the inodes with pending delalloc and forces them to disk. 7530 * of all the inodes with pending delalloc and forces them to disk.
@@ -7457,10 +7534,15 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
7457 struct list_head *head = &root->fs_info->delalloc_inodes; 7534 struct list_head *head = &root->fs_info->delalloc_inodes;
7458 struct btrfs_inode *binode; 7535 struct btrfs_inode *binode;
7459 struct inode *inode; 7536 struct inode *inode;
7537 struct btrfs_delalloc_work *work, *next;
7538 struct list_head works;
7539 int ret = 0;
7460 7540
7461 if (root->fs_info->sb->s_flags & MS_RDONLY) 7541 if (root->fs_info->sb->s_flags & MS_RDONLY)
7462 return -EROFS; 7542 return -EROFS;
7463 7543
7544 INIT_LIST_HEAD(&works);
7545
7464 spin_lock(&root->fs_info->delalloc_lock); 7546 spin_lock(&root->fs_info->delalloc_lock);
7465 while (!list_empty(head)) { 7547 while (!list_empty(head)) {
7466 binode = list_entry(head->next, struct btrfs_inode, 7548 binode = list_entry(head->next, struct btrfs_inode,
@@ -7470,11 +7552,14 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
7470 list_del_init(&binode->delalloc_inodes); 7552 list_del_init(&binode->delalloc_inodes);
7471 spin_unlock(&root->fs_info->delalloc_lock); 7553 spin_unlock(&root->fs_info->delalloc_lock);
7472 if (inode) { 7554 if (inode) {
7473 filemap_flush(inode->i_mapping); 7555 work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
7474 if (delay_iput) 7556 if (!work) {
7475 btrfs_add_delayed_iput(inode); 7557 ret = -ENOMEM;
7476 else 7558 goto out;
7477 iput(inode); 7559 }
7560 list_add_tail(&work->list, &works);
7561 btrfs_queue_worker(&root->fs_info->flush_workers,
7562 &work->work);
7478 } 7563 }
7479 cond_resched(); 7564 cond_resched();
7480 spin_lock(&root->fs_info->delalloc_lock); 7565 spin_lock(&root->fs_info->delalloc_lock);
@@ -7493,7 +7578,12 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
7493 atomic_read(&root->fs_info->async_delalloc_pages) == 0)); 7578 atomic_read(&root->fs_info->async_delalloc_pages) == 0));
7494 } 7579 }
7495 atomic_dec(&root->fs_info->async_submit_draining); 7580 atomic_dec(&root->fs_info->async_submit_draining);
7496 return 0; 7581out:
7582 list_for_each_entry_safe(work, next, &works, list) {
7583 list_del_init(&work->list);
7584 btrfs_wait_and_free_delalloc_work(work);
7585 }
7586 return ret;
7497} 7587}
7498 7588
7499static int btrfs_symlink(struct inode *dir, struct dentry *dentry, 7589static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
@@ -7513,7 +7603,6 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
7513 unsigned long ptr; 7603 unsigned long ptr;
7514 struct btrfs_file_extent_item *ei; 7604 struct btrfs_file_extent_item *ei;
7515 struct extent_buffer *leaf; 7605 struct extent_buffer *leaf;
7516 unsigned long nr = 0;
7517 7606
7518 name_len = strlen(symname) + 1; 7607 name_len = strlen(symname) + 1;
7519 if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root)) 7608 if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
@@ -7611,13 +7700,12 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
7611out_unlock: 7700out_unlock:
7612 if (!err) 7701 if (!err)
7613 d_instantiate(dentry, inode); 7702 d_instantiate(dentry, inode);
7614 nr = trans->blocks_used;
7615 btrfs_end_transaction(trans, root); 7703 btrfs_end_transaction(trans, root);
7616 if (drop_inode) { 7704 if (drop_inode) {
7617 inode_dec_link_count(inode); 7705 inode_dec_link_count(inode);
7618 iput(inode); 7706 iput(inode);
7619 } 7707 }
7620 btrfs_btree_balance_dirty(root, nr); 7708 btrfs_btree_balance_dirty(root);
7621 return err; 7709 return err;
7622} 7710}
7623 7711
@@ -7680,6 +7768,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
7680 em->len = ins.offset; 7768 em->len = ins.offset;
7681 em->block_start = ins.objectid; 7769 em->block_start = ins.objectid;
7682 em->block_len = ins.offset; 7770 em->block_len = ins.offset;
7771 em->orig_block_len = ins.offset;
7683 em->bdev = root->fs_info->fs_devices->latest_bdev; 7772 em->bdev = root->fs_info->fs_devices->latest_bdev;
7684 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 7773 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
7685 em->generation = trans->transid; 7774 em->generation = trans->transid;
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-03 04:45:27 -0400