diff options
author | Chris Mason <chris.mason@oracle.com> | 2007-10-15 16:17:34 -0400 |
---|---|---|
committer | Chris Mason <chris.mason@oracle.com> | 2008-09-25 11:03:56 -0400 |
commit | 6b80053d02be41886344b5007d04e345311ec0b5 (patch) | |
tree | c935b3f2f4a582697167c52f57b0985137a95206 | |
parent | 09e71a326341f40111400c88aaf0498ef622824b (diff) |
Btrfs: Add back the online defragging code
Signed-off-by: Chris Mason <chris.mason@oracle.com>
-rw-r--r-- | fs/btrfs/ctree.c | 177 | ||||
-rw-r--r-- | fs/btrfs/disk-io.c | 60 | ||||
-rw-r--r-- | fs/btrfs/disk-io.h | 7 | ||||
-rw-r--r-- | fs/btrfs/extent-tree.c | 8 | ||||
-rw-r--r-- | fs/btrfs/extent_map.h | 2 | ||||
-rw-r--r-- | fs/btrfs/transaction.c | 4 | ||||
-rw-r--r-- | fs/btrfs/tree-defrag.c | 14 |
7 files changed, 166 insertions, 106 deletions
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c index 34de83630ae9..08ddf1873ab1 100644 --- a/fs/btrfs/ctree.c +++ b/fs/btrfs/ctree.c | |||
@@ -155,55 +155,49 @@ int btrfs_cow_block(struct btrfs_trans_handle *trans, | |||
155 | return ret; | 155 | return ret; |
156 | } | 156 | } |
157 | 157 | ||
158 | #if 0 | 158 | static int close_blocks(u64 blocknr, u64 other, u32 blocksize) |
159 | static int close_blocks(u64 blocknr, u64 other) | ||
160 | { | 159 | { |
161 | if (blocknr < other && other - blocknr < 8) | 160 | if (blocknr < other && other - (blocknr + blocksize) < 32768) |
162 | return 1; | 161 | return 1; |
163 | if (blocknr > other && blocknr - other < 8) | 162 | if (blocknr > other && blocknr - (other + blocksize) < 32768) |
164 | return 1; | 163 | return 1; |
165 | return 0; | 164 | return 0; |
166 | } | 165 | } |
167 | 166 | ||
168 | static int should_defrag_leaf(struct extent_buffer *eb) | 167 | static int should_defrag_leaf(struct extent_buffer *leaf) |
169 | { | 168 | { |
170 | return 0; | 169 | struct btrfs_key key; |
171 | struct btrfs_leaf *leaf = btrfs_buffer_leaf(eb); | ||
172 | struct btrfs_disk_key *key; | ||
173 | u32 nritems; | 170 | u32 nritems; |
174 | 171 | ||
175 | if (buffer_defrag(bh)) | 172 | if (btrfs_buffer_defrag(leaf)) |
176 | return 1; | 173 | return 1; |
177 | 174 | ||
178 | nritems = btrfs_header_nritems(&leaf->header); | 175 | nritems = btrfs_header_nritems(leaf); |
179 | if (nritems == 0) | 176 | if (nritems == 0) |
180 | return 0; | 177 | return 0; |
181 | 178 | ||
182 | key = &leaf->items[0].key; | 179 | btrfs_item_key_to_cpu(leaf, &key, 0); |
183 | if (btrfs_disk_key_type(key) == BTRFS_DIR_ITEM_KEY) | 180 | if (key.type == BTRFS_DIR_ITEM_KEY) |
184 | return 1; | 181 | return 1; |
185 | 182 | ||
186 | key = &leaf->items[nritems-1].key; | 183 | |
187 | if (btrfs_disk_key_type(key) == BTRFS_DIR_ITEM_KEY) | 184 | btrfs_item_key_to_cpu(leaf, &key, nritems - 1); |
185 | if (key.type == BTRFS_DIR_ITEM_KEY) | ||
188 | return 1; | 186 | return 1; |
189 | if (nritems > 4) { | 187 | if (nritems > 4) { |
190 | key = &leaf->items[nritems/2].key; | 188 | btrfs_item_key_to_cpu(leaf, &key, nritems / 2); |
191 | if (btrfs_disk_key_type(key) == BTRFS_DIR_ITEM_KEY) | 189 | if (key.type == BTRFS_DIR_ITEM_KEY) |
192 | return 1; | 190 | return 1; |
193 | } | 191 | } |
194 | return 0; | 192 | return 0; |
195 | } | 193 | } |
196 | #endif | ||
197 | 194 | ||
198 | int btrfs_realloc_node(struct btrfs_trans_handle *trans, | 195 | int btrfs_realloc_node(struct btrfs_trans_handle *trans, |
199 | struct btrfs_root *root, struct extent_buffer *parent, | 196 | struct btrfs_root *root, struct extent_buffer *parent, |
200 | int cache_only, u64 *last_ret) | 197 | int cache_only, u64 *last_ret) |
201 | { | 198 | { |
202 | return 0; | 199 | struct extent_buffer *cur; |
203 | #if 0 | 200 | struct extent_buffer *tmp; |
204 | struct btrfs_node *parent_node; | ||
205 | struct extent_buffer *cur_eb; | ||
206 | struct extent_buffer *tmp_eb; | ||
207 | u64 blocknr; | 201 | u64 blocknr; |
208 | u64 search_start = *last_ret; | 202 | u64 search_start = *last_ret; |
209 | u64 last_block = 0; | 203 | u64 last_block = 0; |
@@ -214,6 +208,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, | |||
214 | int i; | 208 | int i; |
215 | int err = 0; | 209 | int err = 0; |
216 | int parent_level; | 210 | int parent_level; |
211 | int uptodate; | ||
212 | u32 blocksize; | ||
217 | 213 | ||
218 | if (trans->transaction != root->fs_info->running_transaction) { | 214 | if (trans->transaction != root->fs_info->running_transaction) { |
219 | printk(KERN_CRIT "trans %Lu running %Lu\n", trans->transid, | 215 | printk(KERN_CRIT "trans %Lu running %Lu\n", trans->transid, |
@@ -225,12 +221,12 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, | |||
225 | root->fs_info->generation); | 221 | root->fs_info->generation); |
226 | WARN_ON(1); | 222 | WARN_ON(1); |
227 | } | 223 | } |
228 | if (buffer_defrag_done(parent)) | 224 | if (btrfs_buffer_defrag_done(parent)) |
229 | return 0; | 225 | return 0; |
230 | 226 | ||
231 | parent_node = btrfs_buffer_node(parent); | 227 | parent_nritems = btrfs_header_nritems(parent); |
232 | parent_nritems = btrfs_header_nritems(&parent_node->header); | 228 | parent_level = btrfs_header_level(parent); |
233 | parent_level = btrfs_header_level(&parent_node->header); | 229 | blocksize = btrfs_level_size(root, parent_level - 1); |
234 | 230 | ||
235 | start_slot = 0; | 231 | start_slot = 0; |
236 | end_slot = parent_nritems; | 232 | end_slot = parent_nritems; |
@@ -240,56 +236,60 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, | |||
240 | 236 | ||
241 | for (i = start_slot; i < end_slot; i++) { | 237 | for (i = start_slot; i < end_slot; i++) { |
242 | int close = 1; | 238 | int close = 1; |
243 | blocknr = btrfs_node_blockptr(parent_node, i); | 239 | blocknr = btrfs_node_blockptr(parent, i); |
244 | if (last_block == 0) | 240 | if (last_block == 0) |
245 | last_block = blocknr; | 241 | last_block = blocknr; |
246 | if (i > 0) { | 242 | if (i > 0) { |
247 | other = btrfs_node_blockptr(parent_node, i - 1); | 243 | other = btrfs_node_blockptr(parent, i - 1); |
248 | close = close_blocks(blocknr, other); | 244 | close = close_blocks(blocknr, other, blocksize); |
249 | } | 245 | } |
250 | if (close && i < end_slot - 1) { | 246 | if (close && i < end_slot - 1) { |
251 | other = btrfs_node_blockptr(parent_node, i + 1); | 247 | other = btrfs_node_blockptr(parent, i + 1); |
252 | close = close_blocks(blocknr, other); | 248 | close = close_blocks(blocknr, other, blocksize); |
253 | } | 249 | } |
254 | if (close) { | 250 | if (close) { |
255 | last_block = blocknr; | 251 | last_block = blocknr; |
256 | continue; | 252 | continue; |
257 | } | 253 | } |
258 | 254 | ||
259 | cur_bh = btrfs_find_tree_block(root, blocknr); | 255 | cur = btrfs_find_tree_block(root, blocknr, blocksize); |
260 | if (!cur_bh || !buffer_uptodate(cur_bh) || | 256 | if (cur) |
261 | buffer_locked(cur_bh) || | 257 | uptodate = btrfs_buffer_uptodate(cur); |
262 | (parent_level != 1 && !buffer_defrag(cur_bh)) || | 258 | else |
263 | (parent_level == 1 && !should_defrag_leaf(cur_bh))) { | 259 | uptodate = 0; |
260 | if (!cur || !uptodate || | ||
261 | (parent_level != 1 && !btrfs_buffer_defrag(cur)) || | ||
262 | (parent_level == 1 && !should_defrag_leaf(cur))) { | ||
264 | if (cache_only) { | 263 | if (cache_only) { |
265 | brelse(cur_bh); | 264 | free_extent_buffer(cur); |
266 | continue; | 265 | continue; |
267 | } | 266 | } |
268 | if (!cur_bh || !buffer_uptodate(cur_bh) || | 267 | if (!cur) { |
269 | buffer_locked(cur_bh)) { | 268 | cur = read_tree_block(root, blocknr, |
270 | brelse(cur_bh); | 269 | blocksize); |
271 | cur_bh = read_tree_block(root, blocknr); | 270 | } else if (!uptodate) { |
271 | btrfs_read_buffer(cur); | ||
272 | } | 272 | } |
273 | } | 273 | } |
274 | if (search_start == 0) | 274 | if (search_start == 0) |
275 | search_start = last_block & ~((u64)65535); | 275 | search_start = last_block; |
276 | 276 | ||
277 | err = __btrfs_cow_block(trans, root, cur_bh, parent, i, | 277 | err = __btrfs_cow_block(trans, root, cur, parent, i, |
278 | &tmp_bh, search_start, | 278 | &tmp, search_start, |
279 | min(8, end_slot - i)); | 279 | min(16 * blocksize, |
280 | (end_slot - i) * blocksize)); | ||
280 | if (err) { | 281 | if (err) { |
281 | brelse(cur_bh); | 282 | free_extent_buffer(cur); |
282 | break; | 283 | break; |
283 | } | 284 | } |
284 | search_start = bh_blocknr(tmp_bh); | 285 | search_start = tmp->start; |
285 | *last_ret = search_start; | 286 | *last_ret = search_start; |
286 | if (parent_level == 1) | 287 | if (parent_level == 1) |
287 | clear_buffer_defrag(tmp_bh); | 288 | btrfs_clear_buffer_defrag(tmp); |
288 | set_buffer_defrag_done(tmp_bh); | 289 | btrfs_set_buffer_defrag_done(tmp); |
289 | brelse(tmp_bh); | 290 | free_extent_buffer(tmp); |
290 | } | 291 | } |
291 | return err; | 292 | return err; |
292 | #endif | ||
293 | } | 293 | } |
294 | 294 | ||
295 | /* | 295 | /* |
@@ -892,22 +892,17 @@ static int push_nodes_for_insert(struct btrfs_trans_handle *trans, | |||
892 | static void reada_for_search(struct btrfs_root *root, struct btrfs_path *path, | 892 | static void reada_for_search(struct btrfs_root *root, struct btrfs_path *path, |
893 | int level, int slot) | 893 | int level, int slot) |
894 | { | 894 | { |
895 | return; | ||
896 | #if 0 | ||
897 | struct extent_buffer *node; | 895 | struct extent_buffer *node; |
898 | int i; | ||
899 | u32 nritems; | 896 | u32 nritems; |
900 | u64 bytenr; | ||
901 | u64 search; | 897 | u64 search; |
902 | u64 cluster_start; | 898 | u64 lowest_read; |
903 | int ret; | 899 | u64 highest_read; |
904 | int nread = 0; | 900 | u64 nread = 0; |
905 | int direction = path->reada; | 901 | int direction = path->reada; |
906 | int level; | ||
907 | struct radix_tree_root found; | ||
908 | unsigned long gang[8]; | ||
909 | struct extent_buffer *eb; | 902 | struct extent_buffer *eb; |
910 | 903 | u32 nr; | |
904 | u32 blocksize; | ||
905 | u32 nscan = 0; | ||
911 | 906 | ||
912 | if (level == 0) | 907 | if (level == 0) |
913 | return; | 908 | return; |
@@ -917,42 +912,46 @@ static void reada_for_search(struct btrfs_root *root, struct btrfs_path *path, | |||
917 | 912 | ||
918 | node = path->nodes[level]; | 913 | node = path->nodes[level]; |
919 | search = btrfs_node_blockptr(node, slot); | 914 | search = btrfs_node_blockptr(node, slot); |
920 | eb = btrfs_find_tree_block(root, search); | 915 | blocksize = btrfs_level_size(root, level - 1); |
916 | eb = btrfs_find_tree_block(root, search, blocksize); | ||
921 | if (eb) { | 917 | if (eb) { |
922 | free_extent_buffer(eb); | 918 | free_extent_buffer(eb); |
923 | return; | 919 | return; |
924 | } | 920 | } |
925 | 921 | ||
926 | init_bit_radix(&found); | 922 | highest_read = search; |
923 | lowest_read = search; | ||
924 | |||
927 | nritems = btrfs_header_nritems(node); | 925 | nritems = btrfs_header_nritems(node); |
928 | level = btrfs_header_level(node) - 1; | 926 | nr = slot; |
929 | for (i = slot; i < nritems; i++) { | ||
930 | bytenr = btrfs_node_blockptr(node, i); | ||
931 | set_radix_bit(&found, blocknr); | ||
932 | } | ||
933 | if (direction > 0) { | ||
934 | cluster_start = search - 4; | ||
935 | if (cluster_start > search) | ||
936 | cluster_start = 0; | ||
937 | } else | ||
938 | cluster_start = search + 4; | ||
939 | while(1) { | 927 | while(1) { |
940 | ret = find_first_radix_bit(&found, gang, 0, ARRAY_SIZE(gang)); | 928 | if (direction < 0) { |
941 | if (!ret) | 929 | if (nr == 0) |
942 | break; | 930 | break; |
943 | for (i = 0; i < ret; i++) { | 931 | nr--; |
944 | blocknr = gang[i]; | 932 | } else if (direction > 0) { |
945 | clear_radix_bit(&found, blocknr); | 933 | nr++; |
946 | if (path->reada == 1 && nread > 16) | 934 | if (nr >= nritems) |
947 | continue; | 935 | break; |
948 | if (close_blocks(cluster_start, blocknr)) { | ||
949 | readahead_tree_block(root, blocknr); | ||
950 | nread++; | ||
951 | cluster_start = blocknr; | ||
952 | } | ||
953 | } | 936 | } |
937 | search = btrfs_node_blockptr(node, nr); | ||
938 | if ((search >= lowest_read && search <= highest_read) || | ||
939 | (search < lowest_read && lowest_read - search <= 32768) || | ||
940 | (search > highest_read && search - highest_read <= 32768)) { | ||
941 | readahead_tree_block(root, search, blocksize); | ||
942 | nread += blocksize; | ||
943 | } | ||
944 | nscan++; | ||
945 | if (path->reada < 2 && (nread > (256 * 1024) || nscan > 32)) | ||
946 | break; | ||
947 | if(nread > (1024 * 1024) || nscan > 128) | ||
948 | break; | ||
949 | |||
950 | if (search < lowest_read) | ||
951 | lowest_read = search; | ||
952 | if (search > highest_read) | ||
953 | highest_read = search; | ||
954 | } | 954 | } |
955 | #endif | ||
956 | } | 955 | } |
957 | /* | 956 | /* |
958 | * look for key in the tree. path is filled in with nodes along the way | 957 | * look for key in the tree. path is filled in with nodes along the way |
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 0636f79672e9..8e606e6658aa 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c | |||
@@ -678,3 +678,63 @@ void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr) | |||
678 | balance_dirty_pages_ratelimited_nr( | 678 | balance_dirty_pages_ratelimited_nr( |
679 | root->fs_info->btree_inode->i_mapping, nr); | 679 | root->fs_info->btree_inode->i_mapping, nr); |
680 | } | 680 | } |
681 | |||
682 | void btrfs_set_buffer_defrag(struct extent_buffer *buf) | ||
683 | { | ||
684 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
685 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
686 | set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start, | ||
687 | buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS); | ||
688 | } | ||
689 | |||
690 | void btrfs_set_buffer_defrag_done(struct extent_buffer *buf) | ||
691 | { | ||
692 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
693 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
694 | set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start, | ||
695 | buf->start + buf->len - 1, EXTENT_DEFRAG_DONE, | ||
696 | GFP_NOFS); | ||
697 | } | ||
698 | |||
699 | int btrfs_buffer_defrag(struct extent_buffer *buf) | ||
700 | { | ||
701 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
702 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
703 | return test_range_bit(&BTRFS_I(btree_inode)->extent_tree, | ||
704 | buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0); | ||
705 | } | ||
706 | |||
707 | int btrfs_buffer_defrag_done(struct extent_buffer *buf) | ||
708 | { | ||
709 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
710 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
711 | return test_range_bit(&BTRFS_I(btree_inode)->extent_tree, | ||
712 | buf->start, buf->start + buf->len - 1, | ||
713 | EXTENT_DEFRAG_DONE, 0); | ||
714 | } | ||
715 | |||
716 | int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf) | ||
717 | { | ||
718 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
719 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
720 | return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree, | ||
721 | buf->start, buf->start + buf->len - 1, | ||
722 | EXTENT_DEFRAG_DONE, GFP_NOFS); | ||
723 | } | ||
724 | |||
725 | int btrfs_clear_buffer_defrag(struct extent_buffer *buf) | ||
726 | { | ||
727 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
728 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
729 | return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree, | ||
730 | buf->start, buf->start + buf->len - 1, | ||
731 | EXTENT_DEFRAG, GFP_NOFS); | ||
732 | } | ||
733 | |||
734 | int btrfs_read_buffer(struct extent_buffer *buf) | ||
735 | { | ||
736 | struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root; | ||
737 | struct inode *btree_inode = root->fs_info->btree_inode; | ||
738 | return read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree, | ||
739 | buf, 1); | ||
740 | } | ||
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h index fd4db5f810cf..190b07bc642b 100644 --- a/fs/btrfs/disk-io.h +++ b/fs/btrfs/disk-io.h | |||
@@ -51,4 +51,11 @@ int btrfs_buffer_uptodate(struct extent_buffer *buf); | |||
51 | int btrfs_set_buffer_uptodate(struct extent_buffer *buf); | 51 | int btrfs_set_buffer_uptodate(struct extent_buffer *buf); |
52 | int wait_on_tree_block_writeback(struct btrfs_root *root, | 52 | int wait_on_tree_block_writeback(struct btrfs_root *root, |
53 | struct extent_buffer *buf); | 53 | struct extent_buffer *buf); |
54 | void btrfs_set_buffer_defrag(struct extent_buffer *buf); | ||
55 | void btrfs_set_buffer_defrag_done(struct extent_buffer *buf); | ||
56 | int btrfs_buffer_defrag(struct extent_buffer *buf); | ||
57 | int btrfs_buffer_defrag_done(struct extent_buffer *buf); | ||
58 | int btrfs_clear_buffer_defrag(struct extent_buffer *buf); | ||
59 | int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf); | ||
60 | int btrfs_read_buffer(struct extent_buffer *buf); | ||
54 | #endif | 61 | #endif |
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index 1be8f9f04a13..0b0c947194ae 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c | |||
@@ -1173,13 +1173,7 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, | |||
1173 | buf->alloc_addr = (unsigned long)__builtin_return_address(0); | 1173 | buf->alloc_addr = (unsigned long)__builtin_return_address(0); |
1174 | set_extent_dirty(&trans->transaction->dirty_pages, buf->start, | 1174 | set_extent_dirty(&trans->transaction->dirty_pages, buf->start, |
1175 | buf->start + buf->len - 1, GFP_NOFS); | 1175 | buf->start + buf->len - 1, GFP_NOFS); |
1176 | /* | 1176 | btrfs_set_buffer_defrag(buf); |
1177 | set_buffer_checked(buf); | ||
1178 | set_buffer_defrag(buf); | ||
1179 | */ | ||
1180 | /* FIXME!!!!!!!!!!!!!!!! | ||
1181 | set_radix_bit(&trans->transaction->dirty_pages, buf->pages[0]->index); | ||
1182 | */ | ||
1183 | trans->blocks_used++; | 1177 | trans->blocks_used++; |
1184 | return buf; | 1178 | return buf; |
1185 | } | 1179 | } |
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h index d74a2b3e3b5d..8409b5cbeda7 100644 --- a/fs/btrfs/extent_map.h +++ b/fs/btrfs/extent_map.h | |||
@@ -14,6 +14,8 @@ | |||
14 | #define EXTENT_LOCKED (1 << 3) | 14 | #define EXTENT_LOCKED (1 << 3) |
15 | #define EXTENT_NEW (1 << 4) | 15 | #define EXTENT_NEW (1 << 4) |
16 | #define EXTENT_DELALLOC (1 << 5) | 16 | #define EXTENT_DELALLOC (1 << 5) |
17 | #define EXTENT_DEFRAG (1 << 6) | ||
18 | #define EXTENT_DEFRAG_DONE (1 << 7) | ||
17 | #define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_WRITEBACK) | 19 | #define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_WRITEBACK) |
18 | 20 | ||
19 | 21 | ||
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c index 60f61345a8d0..87456ab74275 100644 --- a/fs/btrfs/transaction.c +++ b/fs/btrfs/transaction.c | |||
@@ -355,7 +355,7 @@ int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) | |||
355 | return 0; | 355 | return 0; |
356 | 356 | ||
357 | trans = btrfs_start_transaction(root, 1); | 357 | trans = btrfs_start_transaction(root, 1); |
358 | while (0) { | 358 | while (1) { |
359 | root->defrag_running = 1; | 359 | root->defrag_running = 1; |
360 | ret = btrfs_defrag_leaves(trans, root, cacheonly); | 360 | ret = btrfs_defrag_leaves(trans, root, cacheonly); |
361 | nr = trans->blocks_used; | 361 | nr = trans->blocks_used; |
@@ -400,7 +400,7 @@ int btrfs_defrag_dirty_roots(struct btrfs_fs_info *info) | |||
400 | btrfs_defrag_root(root, 1); | 400 | btrfs_defrag_root(root, 1); |
401 | } | 401 | } |
402 | } | 402 | } |
403 | // btrfs_defrag_root(info->extent_root, 1); | 403 | btrfs_defrag_root(info->extent_root, 1); |
404 | return err; | 404 | return err; |
405 | } | 405 | } |
406 | 406 | ||
diff --git a/fs/btrfs/tree-defrag.c b/fs/btrfs/tree-defrag.c index 3feac2f28628..d23216aa4ab5 100644 --- a/fs/btrfs/tree-defrag.c +++ b/fs/btrfs/tree-defrag.c | |||
@@ -116,10 +116,10 @@ static int defrag_walk_down(struct btrfs_trans_handle *trans, | |||
116 | } | 116 | } |
117 | WARN_ON(*level < 0); | 117 | WARN_ON(*level < 0); |
118 | WARN_ON(*level >= BTRFS_MAX_LEVEL); | 118 | WARN_ON(*level >= BTRFS_MAX_LEVEL); |
119 | #if 0 | 119 | |
120 | clear_buffer_defrag(path->nodes[*level]); | 120 | btrfs_clear_buffer_defrag(path->nodes[*level]); |
121 | clear_buffer_defrag_done(path->nodes[*level]); | 121 | btrfs_clear_buffer_defrag_done(path->nodes[*level]); |
122 | #endif | 122 | |
123 | free_extent_buffer(path->nodes[*level]); | 123 | free_extent_buffer(path->nodes[*level]); |
124 | path->nodes[*level] = NULL; | 124 | path->nodes[*level] = NULL; |
125 | *level += 1; | 125 | *level += 1; |
@@ -148,10 +148,8 @@ static int defrag_walk_up(struct btrfs_trans_handle *trans, | |||
148 | root->defrag_level = i; | 148 | root->defrag_level = i; |
149 | return 0; | 149 | return 0; |
150 | } else { | 150 | } else { |
151 | /* | 151 | btrfs_clear_buffer_defrag(path->nodes[*level]); |
152 | clear_buffer_defrag(path->nodes[*level]); | 152 | btrfs_clear_buffer_defrag_done(path->nodes[*level]); |
153 | clear_buffer_defrag_done(path->nodes[*level]); | ||
154 | */ | ||
155 | free_extent_buffer(path->nodes[*level]); | 153 | free_extent_buffer(path->nodes[*level]); |
156 | path->nodes[*level] = NULL; | 154 | path->nodes[*level] = NULL; |
157 | *level = i + 1; | 155 | *level = i + 1; |