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