diff options
Diffstat (limited to 'fs/btrfs')
-rw-r--r-- | fs/btrfs/ctree.c | 58 | ||||
-rw-r--r-- | fs/btrfs/ctree.h | 11 | ||||
-rw-r--r-- | fs/btrfs/disk-io.c | 46 | ||||
-rw-r--r-- | fs/btrfs/disk-io.h | 10 | ||||
-rw-r--r-- | fs/btrfs/extent-tree.c | 83 | ||||
-rw-r--r-- | fs/btrfs/extent_io.c | 2 | ||||
-rw-r--r-- | fs/btrfs/file.c | 8 | ||||
-rw-r--r-- | fs/btrfs/inode-map.c | 1 | ||||
-rw-r--r-- | fs/btrfs/inode.c | 4 | ||||
-rw-r--r-- | fs/btrfs/locking.c | 11 | ||||
-rw-r--r-- | fs/btrfs/super.c | 5 | ||||
-rw-r--r-- | fs/btrfs/transaction.c | 2 | ||||
-rw-r--r-- | fs/btrfs/tree-log.c | 2 | ||||
-rw-r--r-- | fs/btrfs/volumes.c | 6 |
14 files changed, 161 insertions, 88 deletions
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c index 35443cc4b9a9..42491d728e99 100644 --- a/fs/btrfs/ctree.c +++ b/fs/btrfs/ctree.c | |||
@@ -38,19 +38,12 @@ static int balance_node_right(struct btrfs_trans_handle *trans, | |||
38 | static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, | 38 | static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
39 | struct btrfs_path *path, int level, int slot); | 39 | struct btrfs_path *path, int level, int slot); |
40 | 40 | ||
41 | inline void btrfs_init_path(struct btrfs_path *p) | ||
42 | { | ||
43 | memset(p, 0, sizeof(*p)); | ||
44 | } | ||
45 | |||
46 | struct btrfs_path *btrfs_alloc_path(void) | 41 | struct btrfs_path *btrfs_alloc_path(void) |
47 | { | 42 | { |
48 | struct btrfs_path *path; | 43 | struct btrfs_path *path; |
49 | path = kmem_cache_alloc(btrfs_path_cachep, GFP_NOFS); | 44 | path = kmem_cache_zalloc(btrfs_path_cachep, GFP_NOFS); |
50 | if (path) { | 45 | if (path) |
51 | btrfs_init_path(path); | ||
52 | path->reada = 1; | 46 | path->reada = 1; |
53 | } | ||
54 | return path; | 47 | return path; |
55 | } | 48 | } |
56 | 49 | ||
@@ -69,14 +62,38 @@ noinline void btrfs_set_path_blocking(struct btrfs_path *p) | |||
69 | 62 | ||
70 | /* | 63 | /* |
71 | * reset all the locked nodes in the patch to spinning locks. | 64 | * reset all the locked nodes in the patch to spinning locks. |
65 | * | ||
66 | * held is used to keep lockdep happy, when lockdep is enabled | ||
67 | * we set held to a blocking lock before we go around and | ||
68 | * retake all the spinlocks in the path. You can safely use NULL | ||
69 | * for held | ||
72 | */ | 70 | */ |
73 | noinline void btrfs_clear_path_blocking(struct btrfs_path *p) | 71 | noinline void btrfs_clear_path_blocking(struct btrfs_path *p, |
72 | struct extent_buffer *held) | ||
74 | { | 73 | { |
75 | int i; | 74 | int i; |
76 | for (i = 0; i < BTRFS_MAX_LEVEL; i++) { | 75 | |
76 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
77 | /* lockdep really cares that we take all of these spinlocks | ||
78 | * in the right order. If any of the locks in the path are not | ||
79 | * currently blocking, it is going to complain. So, make really | ||
80 | * really sure by forcing the path to blocking before we clear | ||
81 | * the path blocking. | ||
82 | */ | ||
83 | if (held) | ||
84 | btrfs_set_lock_blocking(held); | ||
85 | btrfs_set_path_blocking(p); | ||
86 | #endif | ||
87 | |||
88 | for (i = BTRFS_MAX_LEVEL - 1; i >= 0; i--) { | ||
77 | if (p->nodes[i] && p->locks[i]) | 89 | if (p->nodes[i] && p->locks[i]) |
78 | btrfs_clear_lock_blocking(p->nodes[i]); | 90 | btrfs_clear_lock_blocking(p->nodes[i]); |
79 | } | 91 | } |
92 | |||
93 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
94 | if (held) | ||
95 | btrfs_clear_lock_blocking(held); | ||
96 | #endif | ||
80 | } | 97 | } |
81 | 98 | ||
82 | /* this also releases the path */ | 99 | /* this also releases the path */ |
@@ -286,7 +303,7 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, | |||
286 | trans->transid, level, &ins); | 303 | trans->transid, level, &ins); |
287 | BUG_ON(ret); | 304 | BUG_ON(ret); |
288 | cow = btrfs_init_new_buffer(trans, root, prealloc_dest, | 305 | cow = btrfs_init_new_buffer(trans, root, prealloc_dest, |
289 | buf->len); | 306 | buf->len, level); |
290 | } else { | 307 | } else { |
291 | cow = btrfs_alloc_free_block(trans, root, buf->len, | 308 | cow = btrfs_alloc_free_block(trans, root, buf->len, |
292 | parent_start, | 309 | parent_start, |
@@ -917,9 +934,9 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, | |||
917 | 934 | ||
918 | /* promote the child to a root */ | 935 | /* promote the child to a root */ |
919 | child = read_node_slot(root, mid, 0); | 936 | child = read_node_slot(root, mid, 0); |
937 | BUG_ON(!child); | ||
920 | btrfs_tree_lock(child); | 938 | btrfs_tree_lock(child); |
921 | btrfs_set_lock_blocking(child); | 939 | btrfs_set_lock_blocking(child); |
922 | BUG_ON(!child); | ||
923 | ret = btrfs_cow_block(trans, root, child, mid, 0, &child, 0); | 940 | ret = btrfs_cow_block(trans, root, child, mid, 0, &child, 0); |
924 | BUG_ON(ret); | 941 | BUG_ON(ret); |
925 | 942 | ||
@@ -1566,7 +1583,7 @@ cow_done: | |||
1566 | if (!p->skip_locking) | 1583 | if (!p->skip_locking) |
1567 | p->locks[level] = 1; | 1584 | p->locks[level] = 1; |
1568 | 1585 | ||
1569 | btrfs_clear_path_blocking(p); | 1586 | btrfs_clear_path_blocking(p, NULL); |
1570 | 1587 | ||
1571 | /* | 1588 | /* |
1572 | * we have a lock on b and as long as we aren't changing | 1589 | * we have a lock on b and as long as we aren't changing |
@@ -1605,7 +1622,7 @@ cow_done: | |||
1605 | 1622 | ||
1606 | btrfs_set_path_blocking(p); | 1623 | btrfs_set_path_blocking(p); |
1607 | sret = split_node(trans, root, p, level); | 1624 | sret = split_node(trans, root, p, level); |
1608 | btrfs_clear_path_blocking(p); | 1625 | btrfs_clear_path_blocking(p, NULL); |
1609 | 1626 | ||
1610 | BUG_ON(sret > 0); | 1627 | BUG_ON(sret > 0); |
1611 | if (sret) { | 1628 | if (sret) { |
@@ -1625,7 +1642,7 @@ cow_done: | |||
1625 | 1642 | ||
1626 | btrfs_set_path_blocking(p); | 1643 | btrfs_set_path_blocking(p); |
1627 | sret = balance_level(trans, root, p, level); | 1644 | sret = balance_level(trans, root, p, level); |
1628 | btrfs_clear_path_blocking(p); | 1645 | btrfs_clear_path_blocking(p, NULL); |
1629 | 1646 | ||
1630 | if (sret) { | 1647 | if (sret) { |
1631 | ret = sret; | 1648 | ret = sret; |
@@ -1688,13 +1705,13 @@ cow_done: | |||
1688 | if (!p->skip_locking) { | 1705 | if (!p->skip_locking) { |
1689 | int lret; | 1706 | int lret; |
1690 | 1707 | ||
1691 | btrfs_clear_path_blocking(p); | 1708 | btrfs_clear_path_blocking(p, NULL); |
1692 | lret = btrfs_try_spin_lock(b); | 1709 | lret = btrfs_try_spin_lock(b); |
1693 | 1710 | ||
1694 | if (!lret) { | 1711 | if (!lret) { |
1695 | btrfs_set_path_blocking(p); | 1712 | btrfs_set_path_blocking(p); |
1696 | btrfs_tree_lock(b); | 1713 | btrfs_tree_lock(b); |
1697 | btrfs_clear_path_blocking(p); | 1714 | btrfs_clear_path_blocking(p, b); |
1698 | } | 1715 | } |
1699 | } | 1716 | } |
1700 | } else { | 1717 | } else { |
@@ -1706,7 +1723,7 @@ cow_done: | |||
1706 | btrfs_set_path_blocking(p); | 1723 | btrfs_set_path_blocking(p); |
1707 | sret = split_leaf(trans, root, key, | 1724 | sret = split_leaf(trans, root, key, |
1708 | p, ins_len, ret == 0); | 1725 | p, ins_len, ret == 0); |
1709 | btrfs_clear_path_blocking(p); | 1726 | btrfs_clear_path_blocking(p, NULL); |
1710 | 1727 | ||
1711 | BUG_ON(sret > 0); | 1728 | BUG_ON(sret > 0); |
1712 | if (sret) { | 1729 | if (sret) { |
@@ -3926,7 +3943,6 @@ find_next_key: | |||
3926 | btrfs_release_path(root, path); | 3943 | btrfs_release_path(root, path); |
3927 | goto again; | 3944 | goto again; |
3928 | } else { | 3945 | } else { |
3929 | btrfs_clear_path_blocking(path); | ||
3930 | goto out; | 3946 | goto out; |
3931 | } | 3947 | } |
3932 | } | 3948 | } |
@@ -3946,7 +3962,7 @@ find_next_key: | |||
3946 | path->locks[level - 1] = 1; | 3962 | path->locks[level - 1] = 1; |
3947 | path->nodes[level - 1] = cur; | 3963 | path->nodes[level - 1] = cur; |
3948 | unlock_up(path, level, 1); | 3964 | unlock_up(path, level, 1); |
3949 | btrfs_clear_path_blocking(path); | 3965 | btrfs_clear_path_blocking(path, NULL); |
3950 | } | 3966 | } |
3951 | out: | 3967 | out: |
3952 | if (ret == 0) | 3968 | if (ret == 0) |
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h index 531db112c8bd..766b31ae3186 100644 --- a/fs/btrfs/ctree.h +++ b/fs/btrfs/ctree.h | |||
@@ -43,11 +43,7 @@ struct btrfs_ordered_sum; | |||
43 | 43 | ||
44 | #define BTRFS_ACL_NOT_CACHED ((void *)-1) | 44 | #define BTRFS_ACL_NOT_CACHED ((void *)-1) |
45 | 45 | ||
46 | #ifdef CONFIG_LOCKDEP | 46 | #define BTRFS_MAX_LEVEL 8 |
47 | # define BTRFS_MAX_LEVEL 7 | ||
48 | #else | ||
49 | # define BTRFS_MAX_LEVEL 8 | ||
50 | #endif | ||
51 | 47 | ||
52 | /* holds pointers to all of the tree roots */ | 48 | /* holds pointers to all of the tree roots */ |
53 | #define BTRFS_ROOT_TREE_OBJECTID 1ULL | 49 | #define BTRFS_ROOT_TREE_OBJECTID 1ULL |
@@ -1715,7 +1711,8 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, | |||
1715 | u64 empty_size); | 1711 | u64 empty_size); |
1716 | struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans, | 1712 | struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans, |
1717 | struct btrfs_root *root, | 1713 | struct btrfs_root *root, |
1718 | u64 bytenr, u32 blocksize); | 1714 | u64 bytenr, u32 blocksize, |
1715 | int level); | ||
1719 | int btrfs_alloc_extent(struct btrfs_trans_handle *trans, | 1716 | int btrfs_alloc_extent(struct btrfs_trans_handle *trans, |
1720 | struct btrfs_root *root, | 1717 | struct btrfs_root *root, |
1721 | u64 num_bytes, u64 parent, u64 min_bytes, | 1718 | u64 num_bytes, u64 parent, u64 min_bytes, |
@@ -1834,9 +1831,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, | |||
1834 | void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p); | 1831 | void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p); |
1835 | struct btrfs_path *btrfs_alloc_path(void); | 1832 | struct btrfs_path *btrfs_alloc_path(void); |
1836 | void btrfs_free_path(struct btrfs_path *p); | 1833 | void btrfs_free_path(struct btrfs_path *p); |
1837 | void btrfs_init_path(struct btrfs_path *p); | ||
1838 | void btrfs_set_path_blocking(struct btrfs_path *p); | 1834 | void btrfs_set_path_blocking(struct btrfs_path *p); |
1839 | void btrfs_clear_path_blocking(struct btrfs_path *p); | ||
1840 | void btrfs_unlock_up_safe(struct btrfs_path *p, int level); | 1835 | void btrfs_unlock_up_safe(struct btrfs_path *p, int level); |
1841 | 1836 | ||
1842 | int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, | 1837 | int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 5aebddd71193..adda739a0215 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c | |||
@@ -75,6 +75,40 @@ struct async_submit_bio { | |||
75 | struct btrfs_work work; | 75 | struct btrfs_work work; |
76 | }; | 76 | }; |
77 | 77 | ||
78 | /* These are used to set the lockdep class on the extent buffer locks. | ||
79 | * The class is set by the readpage_end_io_hook after the buffer has | ||
80 | * passed csum validation but before the pages are unlocked. | ||
81 | * | ||
82 | * The lockdep class is also set by btrfs_init_new_buffer on freshly | ||
83 | * allocated blocks. | ||
84 | * | ||
85 | * The class is based on the level in the tree block, which allows lockdep | ||
86 | * to know that lower nodes nest inside the locks of higher nodes. | ||
87 | * | ||
88 | * We also add a check to make sure the highest level of the tree is | ||
89 | * the same as our lockdep setup here. If BTRFS_MAX_LEVEL changes, this | ||
90 | * code needs update as well. | ||
91 | */ | ||
92 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
93 | # if BTRFS_MAX_LEVEL != 8 | ||
94 | # error | ||
95 | # endif | ||
96 | static struct lock_class_key btrfs_eb_class[BTRFS_MAX_LEVEL + 1]; | ||
97 | static const char *btrfs_eb_name[BTRFS_MAX_LEVEL + 1] = { | ||
98 | /* leaf */ | ||
99 | "btrfs-extent-00", | ||
100 | "btrfs-extent-01", | ||
101 | "btrfs-extent-02", | ||
102 | "btrfs-extent-03", | ||
103 | "btrfs-extent-04", | ||
104 | "btrfs-extent-05", | ||
105 | "btrfs-extent-06", | ||
106 | "btrfs-extent-07", | ||
107 | /* highest possible level */ | ||
108 | "btrfs-extent-08", | ||
109 | }; | ||
110 | #endif | ||
111 | |||
78 | /* | 112 | /* |
79 | * extents on the btree inode are pretty simple, there's one extent | 113 | * extents on the btree inode are pretty simple, there's one extent |
80 | * that covers the entire device | 114 | * that covers the entire device |
@@ -347,6 +381,15 @@ static int check_tree_block_fsid(struct btrfs_root *root, | |||
347 | return ret; | 381 | return ret; |
348 | } | 382 | } |
349 | 383 | ||
384 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
385 | void btrfs_set_buffer_lockdep_class(struct extent_buffer *eb, int level) | ||
386 | { | ||
387 | lockdep_set_class_and_name(&eb->lock, | ||
388 | &btrfs_eb_class[level], | ||
389 | btrfs_eb_name[level]); | ||
390 | } | ||
391 | #endif | ||
392 | |||
350 | static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end, | 393 | static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end, |
351 | struct extent_state *state) | 394 | struct extent_state *state) |
352 | { | 395 | { |
@@ -392,6 +435,8 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end, | |||
392 | } | 435 | } |
393 | found_level = btrfs_header_level(eb); | 436 | found_level = btrfs_header_level(eb); |
394 | 437 | ||
438 | btrfs_set_buffer_lockdep_class(eb, found_level); | ||
439 | |||
395 | ret = csum_tree_block(root, eb, 1); | 440 | ret = csum_tree_block(root, eb, 1); |
396 | if (ret) | 441 | if (ret) |
397 | ret = -EIO; | 442 | ret = -EIO; |
@@ -1777,7 +1822,6 @@ struct btrfs_root *open_ctree(struct super_block *sb, | |||
1777 | ret = find_and_setup_root(tree_root, fs_info, | 1822 | ret = find_and_setup_root(tree_root, fs_info, |
1778 | BTRFS_DEV_TREE_OBJECTID, dev_root); | 1823 | BTRFS_DEV_TREE_OBJECTID, dev_root); |
1779 | dev_root->track_dirty = 1; | 1824 | dev_root->track_dirty = 1; |
1780 | |||
1781 | if (ret) | 1825 | if (ret) |
1782 | goto fail_extent_root; | 1826 | goto fail_extent_root; |
1783 | 1827 | ||
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h index 494a56eb2986..95029db227be 100644 --- a/fs/btrfs/disk-io.h +++ b/fs/btrfs/disk-io.h | |||
@@ -101,4 +101,14 @@ int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans, | |||
101 | int btrfs_add_log_tree(struct btrfs_trans_handle *trans, | 101 | int btrfs_add_log_tree(struct btrfs_trans_handle *trans, |
102 | struct btrfs_root *root); | 102 | struct btrfs_root *root); |
103 | int btree_lock_page_hook(struct page *page); | 103 | int btree_lock_page_hook(struct page *page); |
104 | |||
105 | |||
106 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
107 | void btrfs_set_buffer_lockdep_class(struct extent_buffer *eb, int level); | ||
108 | #else | ||
109 | static inline void btrfs_set_buffer_lockdep_class(struct extent_buffer *eb, | ||
110 | int level) | ||
111 | { | ||
112 | } | ||
113 | #endif | ||
104 | #endif | 114 | #endif |
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index 7527523c2d2d..0a5d796c9f7e 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c | |||
@@ -1323,8 +1323,25 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, | |||
1323 | int btrfs_extent_post_op(struct btrfs_trans_handle *trans, | 1323 | int btrfs_extent_post_op(struct btrfs_trans_handle *trans, |
1324 | struct btrfs_root *root) | 1324 | struct btrfs_root *root) |
1325 | { | 1325 | { |
1326 | finish_current_insert(trans, root->fs_info->extent_root, 1); | 1326 | u64 start; |
1327 | del_pending_extents(trans, root->fs_info->extent_root, 1); | 1327 | u64 end; |
1328 | int ret; | ||
1329 | |||
1330 | while(1) { | ||
1331 | finish_current_insert(trans, root->fs_info->extent_root, 1); | ||
1332 | del_pending_extents(trans, root->fs_info->extent_root, 1); | ||
1333 | |||
1334 | /* is there more work to do? */ | ||
1335 | ret = find_first_extent_bit(&root->fs_info->pending_del, | ||
1336 | 0, &start, &end, EXTENT_WRITEBACK); | ||
1337 | if (!ret) | ||
1338 | continue; | ||
1339 | ret = find_first_extent_bit(&root->fs_info->extent_ins, | ||
1340 | 0, &start, &end, EXTENT_WRITEBACK); | ||
1341 | if (!ret) | ||
1342 | continue; | ||
1343 | break; | ||
1344 | } | ||
1328 | return 0; | 1345 | return 0; |
1329 | } | 1346 | } |
1330 | 1347 | ||
@@ -2211,13 +2228,12 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, | |||
2211 | u64 end; | 2228 | u64 end; |
2212 | u64 priv; | 2229 | u64 priv; |
2213 | u64 search = 0; | 2230 | u64 search = 0; |
2214 | u64 skipped = 0; | ||
2215 | struct btrfs_fs_info *info = extent_root->fs_info; | 2231 | struct btrfs_fs_info *info = extent_root->fs_info; |
2216 | struct btrfs_path *path; | 2232 | struct btrfs_path *path; |
2217 | struct pending_extent_op *extent_op, *tmp; | 2233 | struct pending_extent_op *extent_op, *tmp; |
2218 | struct list_head insert_list, update_list; | 2234 | struct list_head insert_list, update_list; |
2219 | int ret; | 2235 | int ret; |
2220 | int num_inserts = 0, max_inserts; | 2236 | int num_inserts = 0, max_inserts, restart = 0; |
2221 | 2237 | ||
2222 | path = btrfs_alloc_path(); | 2238 | path = btrfs_alloc_path(); |
2223 | INIT_LIST_HEAD(&insert_list); | 2239 | INIT_LIST_HEAD(&insert_list); |
@@ -2233,19 +2249,19 @@ again: | |||
2233 | ret = find_first_extent_bit(&info->extent_ins, search, &start, | 2249 | ret = find_first_extent_bit(&info->extent_ins, search, &start, |
2234 | &end, EXTENT_WRITEBACK); | 2250 | &end, EXTENT_WRITEBACK); |
2235 | if (ret) { | 2251 | if (ret) { |
2236 | if (skipped && all && !num_inserts && | 2252 | if (restart && !num_inserts && |
2237 | list_empty(&update_list)) { | 2253 | list_empty(&update_list)) { |
2238 | skipped = 0; | 2254 | restart = 0; |
2239 | search = 0; | 2255 | search = 0; |
2240 | continue; | 2256 | continue; |
2241 | } | 2257 | } |
2242 | mutex_unlock(&info->extent_ins_mutex); | ||
2243 | break; | 2258 | break; |
2244 | } | 2259 | } |
2245 | 2260 | ||
2246 | ret = try_lock_extent(&info->extent_ins, start, end, GFP_NOFS); | 2261 | ret = try_lock_extent(&info->extent_ins, start, end, GFP_NOFS); |
2247 | if (!ret) { | 2262 | if (!ret) { |
2248 | skipped = 1; | 2263 | if (all) |
2264 | restart = 1; | ||
2249 | search = end + 1; | 2265 | search = end + 1; |
2250 | if (need_resched()) { | 2266 | if (need_resched()) { |
2251 | mutex_unlock(&info->extent_ins_mutex); | 2267 | mutex_unlock(&info->extent_ins_mutex); |
@@ -2264,7 +2280,7 @@ again: | |||
2264 | list_add_tail(&extent_op->list, &insert_list); | 2280 | list_add_tail(&extent_op->list, &insert_list); |
2265 | search = end + 1; | 2281 | search = end + 1; |
2266 | if (num_inserts == max_inserts) { | 2282 | if (num_inserts == max_inserts) { |
2267 | mutex_unlock(&info->extent_ins_mutex); | 2283 | restart = 1; |
2268 | break; | 2284 | break; |
2269 | } | 2285 | } |
2270 | } else if (extent_op->type == PENDING_BACKREF_UPDATE) { | 2286 | } else if (extent_op->type == PENDING_BACKREF_UPDATE) { |
@@ -2280,7 +2296,6 @@ again: | |||
2280 | * somebody marked this thing for deletion then just unlock it and be | 2296 | * somebody marked this thing for deletion then just unlock it and be |
2281 | * done, the free_extents will handle it | 2297 | * done, the free_extents will handle it |
2282 | */ | 2298 | */ |
2283 | mutex_lock(&info->extent_ins_mutex); | ||
2284 | list_for_each_entry_safe(extent_op, tmp, &update_list, list) { | 2299 | list_for_each_entry_safe(extent_op, tmp, &update_list, list) { |
2285 | clear_extent_bits(&info->extent_ins, extent_op->bytenr, | 2300 | clear_extent_bits(&info->extent_ins, extent_op->bytenr, |
2286 | extent_op->bytenr + extent_op->num_bytes - 1, | 2301 | extent_op->bytenr + extent_op->num_bytes - 1, |
@@ -2302,6 +2317,10 @@ again: | |||
2302 | if (!list_empty(&update_list)) { | 2317 | if (!list_empty(&update_list)) { |
2303 | ret = update_backrefs(trans, extent_root, path, &update_list); | 2318 | ret = update_backrefs(trans, extent_root, path, &update_list); |
2304 | BUG_ON(ret); | 2319 | BUG_ON(ret); |
2320 | |||
2321 | /* we may have COW'ed new blocks, so lets start over */ | ||
2322 | if (all) | ||
2323 | restart = 1; | ||
2305 | } | 2324 | } |
2306 | 2325 | ||
2307 | /* | 2326 | /* |
@@ -2309,9 +2328,9 @@ again: | |||
2309 | * need to make sure everything is cleaned then reset everything and | 2328 | * need to make sure everything is cleaned then reset everything and |
2310 | * go back to the beginning | 2329 | * go back to the beginning |
2311 | */ | 2330 | */ |
2312 | if (!num_inserts && all && skipped) { | 2331 | if (!num_inserts && restart) { |
2313 | search = 0; | 2332 | search = 0; |
2314 | skipped = 0; | 2333 | restart = 0; |
2315 | INIT_LIST_HEAD(&update_list); | 2334 | INIT_LIST_HEAD(&update_list); |
2316 | INIT_LIST_HEAD(&insert_list); | 2335 | INIT_LIST_HEAD(&insert_list); |
2317 | goto again; | 2336 | goto again; |
@@ -2368,27 +2387,19 @@ again: | |||
2368 | BUG_ON(ret); | 2387 | BUG_ON(ret); |
2369 | 2388 | ||
2370 | /* | 2389 | /* |
2371 | * if we broke out of the loop in order to insert stuff because we hit | 2390 | * if restart is set for whatever reason we need to go back and start |
2372 | * the maximum number of inserts at a time we can handle, then loop | 2391 | * searching through the pending list again. |
2373 | * back and pick up where we left off | 2392 | * |
2393 | * We just inserted some extents, which could have resulted in new | ||
2394 | * blocks being allocated, which would result in new blocks needing | ||
2395 | * updates, so if all is set we _must_ restart to get the updated | ||
2396 | * blocks. | ||
2374 | */ | 2397 | */ |
2375 | if (num_inserts == max_inserts) { | 2398 | if (restart || all) { |
2376 | INIT_LIST_HEAD(&insert_list); | ||
2377 | INIT_LIST_HEAD(&update_list); | ||
2378 | num_inserts = 0; | ||
2379 | goto again; | ||
2380 | } | ||
2381 | |||
2382 | /* | ||
2383 | * again, if we need to make absolutely sure there are no more pending | ||
2384 | * extent operations left and we know that we skipped some, go back to | ||
2385 | * the beginning and do it all again | ||
2386 | */ | ||
2387 | if (all && skipped) { | ||
2388 | INIT_LIST_HEAD(&insert_list); | 2399 | INIT_LIST_HEAD(&insert_list); |
2389 | INIT_LIST_HEAD(&update_list); | 2400 | INIT_LIST_HEAD(&update_list); |
2390 | search = 0; | 2401 | search = 0; |
2391 | skipped = 0; | 2402 | restart = 0; |
2392 | num_inserts = 0; | 2403 | num_inserts = 0; |
2393 | goto again; | 2404 | goto again; |
2394 | } | 2405 | } |
@@ -2709,6 +2720,8 @@ again: | |||
2709 | goto again; | 2720 | goto again; |
2710 | } | 2721 | } |
2711 | 2722 | ||
2723 | if (!err) | ||
2724 | finish_current_insert(trans, extent_root, 0); | ||
2712 | return err; | 2725 | return err; |
2713 | } | 2726 | } |
2714 | 2727 | ||
@@ -2859,7 +2872,8 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans, | |||
2859 | 2872 | ||
2860 | if (data & BTRFS_BLOCK_GROUP_METADATA) { | 2873 | if (data & BTRFS_BLOCK_GROUP_METADATA) { |
2861 | last_ptr = &root->fs_info->last_alloc; | 2874 | last_ptr = &root->fs_info->last_alloc; |
2862 | empty_cluster = 64 * 1024; | 2875 | if (!btrfs_test_opt(root, SSD)) |
2876 | empty_cluster = 64 * 1024; | ||
2863 | } | 2877 | } |
2864 | 2878 | ||
2865 | if ((data & BTRFS_BLOCK_GROUP_DATA) && btrfs_test_opt(root, SSD)) | 2879 | if ((data & BTRFS_BLOCK_GROUP_DATA) && btrfs_test_opt(root, SSD)) |
@@ -3402,7 +3416,8 @@ int btrfs_alloc_extent(struct btrfs_trans_handle *trans, | |||
3402 | 3416 | ||
3403 | struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans, | 3417 | struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans, |
3404 | struct btrfs_root *root, | 3418 | struct btrfs_root *root, |
3405 | u64 bytenr, u32 blocksize) | 3419 | u64 bytenr, u32 blocksize, |
3420 | int level) | ||
3406 | { | 3421 | { |
3407 | struct extent_buffer *buf; | 3422 | struct extent_buffer *buf; |
3408 | 3423 | ||
@@ -3410,6 +3425,7 @@ struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans, | |||
3410 | if (!buf) | 3425 | if (!buf) |
3411 | return ERR_PTR(-ENOMEM); | 3426 | return ERR_PTR(-ENOMEM); |
3412 | btrfs_set_header_generation(buf, trans->transid); | 3427 | btrfs_set_header_generation(buf, trans->transid); |
3428 | btrfs_set_buffer_lockdep_class(buf, level); | ||
3413 | btrfs_tree_lock(buf); | 3429 | btrfs_tree_lock(buf); |
3414 | clean_tree_block(trans, root, buf); | 3430 | clean_tree_block(trans, root, buf); |
3415 | 3431 | ||
@@ -3453,7 +3469,8 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, | |||
3453 | return ERR_PTR(ret); | 3469 | return ERR_PTR(ret); |
3454 | } | 3470 | } |
3455 | 3471 | ||
3456 | buf = btrfs_init_new_buffer(trans, root, ins.objectid, blocksize); | 3472 | buf = btrfs_init_new_buffer(trans, root, ins.objectid, |
3473 | blocksize, level); | ||
3457 | return buf; | 3474 | return buf; |
3458 | } | 3475 | } |
3459 | 3476 | ||
@@ -5641,7 +5658,9 @@ static noinline int relocate_one_extent(struct btrfs_root *extent_root, | |||
5641 | prev_block = block_start; | 5658 | prev_block = block_start; |
5642 | } | 5659 | } |
5643 | 5660 | ||
5661 | mutex_lock(&extent_root->fs_info->trans_mutex); | ||
5644 | btrfs_record_root_in_trans(found_root); | 5662 | btrfs_record_root_in_trans(found_root); |
5663 | mutex_unlock(&extent_root->fs_info->trans_mutex); | ||
5645 | if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) { | 5664 | if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) { |
5646 | /* | 5665 | /* |
5647 | * try to update data extent references while | 5666 | * try to update data extent references while |
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 37d43b516b79..ebe6b29e6069 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c | |||
@@ -415,8 +415,6 @@ static int split_state(struct extent_io_tree *tree, struct extent_state *orig, | |||
415 | 415 | ||
416 | node = tree_insert(&tree->state, prealloc->end, &prealloc->rb_node); | 416 | node = tree_insert(&tree->state, prealloc->end, &prealloc->rb_node); |
417 | if (node) { | 417 | if (node) { |
418 | struct extent_state *found; | ||
419 | found = rb_entry(node, struct extent_state, rb_node); | ||
420 | free_extent_state(prealloc); | 418 | free_extent_state(prealloc); |
421 | return -EEXIST; | 419 | return -EEXIST; |
422 | } | 420 | } |
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index 3e8023efaff7..872f104576e5 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c | |||
@@ -1222,7 +1222,7 @@ int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync) | |||
1222 | /* | 1222 | /* |
1223 | * ok we haven't committed the transaction yet, lets do a commit | 1223 | * ok we haven't committed the transaction yet, lets do a commit |
1224 | */ | 1224 | */ |
1225 | if (file->private_data) | 1225 | if (file && file->private_data) |
1226 | btrfs_ioctl_trans_end(file); | 1226 | btrfs_ioctl_trans_end(file); |
1227 | 1227 | ||
1228 | trans = btrfs_start_transaction(root, 1); | 1228 | trans = btrfs_start_transaction(root, 1); |
@@ -1231,7 +1231,7 @@ int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync) | |||
1231 | goto out; | 1231 | goto out; |
1232 | } | 1232 | } |
1233 | 1233 | ||
1234 | ret = btrfs_log_dentry_safe(trans, root, file->f_dentry); | 1234 | ret = btrfs_log_dentry_safe(trans, root, dentry); |
1235 | if (ret < 0) | 1235 | if (ret < 0) |
1236 | goto out; | 1236 | goto out; |
1237 | 1237 | ||
@@ -1245,7 +1245,7 @@ int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync) | |||
1245 | * file again, but that will end up using the synchronization | 1245 | * file again, but that will end up using the synchronization |
1246 | * inside btrfs_sync_log to keep things safe. | 1246 | * inside btrfs_sync_log to keep things safe. |
1247 | */ | 1247 | */ |
1248 | mutex_unlock(&file->f_dentry->d_inode->i_mutex); | 1248 | mutex_unlock(&dentry->d_inode->i_mutex); |
1249 | 1249 | ||
1250 | if (ret > 0) { | 1250 | if (ret > 0) { |
1251 | ret = btrfs_commit_transaction(trans, root); | 1251 | ret = btrfs_commit_transaction(trans, root); |
@@ -1253,7 +1253,7 @@ int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync) | |||
1253 | btrfs_sync_log(trans, root); | 1253 | btrfs_sync_log(trans, root); |
1254 | ret = btrfs_end_transaction(trans, root); | 1254 | ret = btrfs_end_transaction(trans, root); |
1255 | } | 1255 | } |
1256 | mutex_lock(&file->f_dentry->d_inode->i_mutex); | 1256 | mutex_lock(&dentry->d_inode->i_mutex); |
1257 | out: | 1257 | out: |
1258 | return ret > 0 ? EIO : ret; | 1258 | return ret > 0 ? EIO : ret; |
1259 | } | 1259 | } |
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c index 2aa79873eb46..cc7334d833c9 100644 --- a/fs/btrfs/inode-map.c +++ b/fs/btrfs/inode-map.c | |||
@@ -84,7 +84,6 @@ int btrfs_find_free_objectid(struct btrfs_trans_handle *trans, | |||
84 | search_key.type = 0; | 84 | search_key.type = 0; |
85 | search_key.offset = 0; | 85 | search_key.offset = 0; |
86 | 86 | ||
87 | btrfs_init_path(path); | ||
88 | start_found = 0; | 87 | start_found = 0; |
89 | ret = btrfs_search_slot(trans, root, &search_key, path, 0, 0); | 88 | ret = btrfs_search_slot(trans, root, &search_key, path, 0, 0); |
90 | if (ret < 0) | 89 | if (ret < 0) |
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 8f0706210a47..3cee77ae03c8 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c | |||
@@ -2531,8 +2531,6 @@ noinline int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, | |||
2531 | key.offset = (u64)-1; | 2531 | key.offset = (u64)-1; |
2532 | key.type = (u8)-1; | 2532 | key.type = (u8)-1; |
2533 | 2533 | ||
2534 | btrfs_init_path(path); | ||
2535 | |||
2536 | search_again: | 2534 | search_again: |
2537 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); | 2535 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); |
2538 | if (ret < 0) | 2536 | if (ret < 0) |
@@ -4263,7 +4261,7 @@ static int btrfs_releasepage(struct page *page, gfp_t gfp_flags) | |||
4263 | { | 4261 | { |
4264 | if (PageWriteback(page) || PageDirty(page)) | 4262 | if (PageWriteback(page) || PageDirty(page)) |
4265 | return 0; | 4263 | return 0; |
4266 | return __btrfs_releasepage(page, gfp_flags); | 4264 | return __btrfs_releasepage(page, gfp_flags & GFP_NOFS); |
4267 | } | 4265 | } |
4268 | 4266 | ||
4269 | static void btrfs_invalidatepage(struct page *page, unsigned long offset) | 4267 | static void btrfs_invalidatepage(struct page *page, unsigned long offset) |
diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c index 9ebe9385129b..85506c4a3af7 100644 --- a/fs/btrfs/locking.c +++ b/fs/btrfs/locking.c | |||
@@ -25,21 +25,10 @@ | |||
25 | #include "extent_io.h" | 25 | #include "extent_io.h" |
26 | #include "locking.h" | 26 | #include "locking.h" |
27 | 27 | ||
28 | /* | ||
29 | * btrfs_header_level() isn't free, so don't call it when lockdep isn't | ||
30 | * on | ||
31 | */ | ||
32 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | ||
33 | static inline void spin_nested(struct extent_buffer *eb) | ||
34 | { | ||
35 | spin_lock_nested(&eb->lock, BTRFS_MAX_LEVEL - btrfs_header_level(eb)); | ||
36 | } | ||
37 | #else | ||
38 | static inline void spin_nested(struct extent_buffer *eb) | 28 | static inline void spin_nested(struct extent_buffer *eb) |
39 | { | 29 | { |
40 | spin_lock(&eb->lock); | 30 | spin_lock(&eb->lock); |
41 | } | 31 | } |
42 | #endif | ||
43 | 32 | ||
44 | /* | 33 | /* |
45 | * Setting a lock to blocking will drop the spinlock and set the | 34 | * Setting a lock to blocking will drop the spinlock and set the |
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c index f3fd7e2cbc38..19a4daf03ccb 100644 --- a/fs/btrfs/super.c +++ b/fs/btrfs/super.c | |||
@@ -379,7 +379,6 @@ int btrfs_sync_fs(struct super_block *sb, int wait) | |||
379 | btrfs_start_delalloc_inodes(root); | 379 | btrfs_start_delalloc_inodes(root); |
380 | btrfs_wait_ordered_extents(root, 0); | 380 | btrfs_wait_ordered_extents(root, 0); |
381 | 381 | ||
382 | btrfs_clean_old_snapshots(root); | ||
383 | trans = btrfs_start_transaction(root, 1); | 382 | trans = btrfs_start_transaction(root, 1); |
384 | ret = btrfs_commit_transaction(trans, root); | 383 | ret = btrfs_commit_transaction(trans, root); |
385 | sb->s_dirt = 0; | 384 | sb->s_dirt = 0; |
@@ -511,6 +510,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) | |||
511 | struct btrfs_root *root = btrfs_sb(sb); | 510 | struct btrfs_root *root = btrfs_sb(sb); |
512 | int ret; | 511 | int ret; |
513 | 512 | ||
513 | ret = btrfs_parse_options(root, data); | ||
514 | if (ret) | ||
515 | return -EINVAL; | ||
516 | |||
514 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) | 517 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) |
515 | return 0; | 518 | return 0; |
516 | 519 | ||
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c index 919172de5c9a..4112d53d4f4d 100644 --- a/fs/btrfs/transaction.c +++ b/fs/btrfs/transaction.c | |||
@@ -688,7 +688,9 @@ static noinline int drop_dirty_roots(struct btrfs_root *tree_root, | |||
688 | num_bytes -= btrfs_root_used(&dirty->root->root_item); | 688 | num_bytes -= btrfs_root_used(&dirty->root->root_item); |
689 | bytes_used = btrfs_root_used(&root->root_item); | 689 | bytes_used = btrfs_root_used(&root->root_item); |
690 | if (num_bytes) { | 690 | if (num_bytes) { |
691 | mutex_lock(&root->fs_info->trans_mutex); | ||
691 | btrfs_record_root_in_trans(root); | 692 | btrfs_record_root_in_trans(root); |
693 | mutex_unlock(&root->fs_info->trans_mutex); | ||
692 | btrfs_set_root_used(&root->root_item, | 694 | btrfs_set_root_used(&root->root_item, |
693 | bytes_used - num_bytes); | 695 | bytes_used - num_bytes); |
694 | } | 696 | } |
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c index 20794290256b..9c462fbd60fa 100644 --- a/fs/btrfs/tree-log.c +++ b/fs/btrfs/tree-log.c | |||
@@ -2832,7 +2832,9 @@ again: | |||
2832 | BUG_ON(!wc.replay_dest); | 2832 | BUG_ON(!wc.replay_dest); |
2833 | 2833 | ||
2834 | wc.replay_dest->log_root = log; | 2834 | wc.replay_dest->log_root = log; |
2835 | mutex_lock(&fs_info->trans_mutex); | ||
2835 | btrfs_record_root_in_trans(wc.replay_dest); | 2836 | btrfs_record_root_in_trans(wc.replay_dest); |
2837 | mutex_unlock(&fs_info->trans_mutex); | ||
2836 | ret = walk_log_tree(trans, log, &wc); | 2838 | ret = walk_log_tree(trans, log, &wc); |
2837 | BUG_ON(ret); | 2839 | BUG_ON(ret); |
2838 | 2840 | ||
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c index bcd14ebccae1..1316139bf9e8 100644 --- a/fs/btrfs/volumes.c +++ b/fs/btrfs/volumes.c | |||
@@ -2894,10 +2894,6 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key, | |||
2894 | free_extent_map(em); | 2894 | free_extent_map(em); |
2895 | } | 2895 | } |
2896 | 2896 | ||
2897 | map = kzalloc(sizeof(*map), GFP_NOFS); | ||
2898 | if (!map) | ||
2899 | return -ENOMEM; | ||
2900 | |||
2901 | em = alloc_extent_map(GFP_NOFS); | 2897 | em = alloc_extent_map(GFP_NOFS); |
2902 | if (!em) | 2898 | if (!em) |
2903 | return -ENOMEM; | 2899 | return -ENOMEM; |
@@ -3106,6 +3102,8 @@ int btrfs_read_sys_array(struct btrfs_root *root) | |||
3106 | if (!sb) | 3102 | if (!sb) |
3107 | return -ENOMEM; | 3103 | return -ENOMEM; |
3108 | btrfs_set_buffer_uptodate(sb); | 3104 | btrfs_set_buffer_uptodate(sb); |
3105 | btrfs_set_buffer_lockdep_class(sb, 0); | ||
3106 | |||
3109 | write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE); | 3107 | write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE); |
3110 | array_size = btrfs_super_sys_array_size(super_copy); | 3108 | array_size = btrfs_super_sys_array_size(super_copy); |
3111 | 3109 | ||