diff options
Diffstat (limited to 'fs/btrfs/extent-tree.c')
-rw-r--r-- | fs/btrfs/extent-tree.c | 530 |
1 files changed, 403 insertions, 127 deletions
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index a5aca3997d42..72a2b9c28e9f 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c | |||
@@ -21,6 +21,7 @@ | |||
21 | #include <linux/blkdev.h> | 21 | #include <linux/blkdev.h> |
22 | #include <linux/sort.h> | 22 | #include <linux/sort.h> |
23 | #include <linux/rcupdate.h> | 23 | #include <linux/rcupdate.h> |
24 | #include <linux/kthread.h> | ||
24 | #include "compat.h" | 25 | #include "compat.h" |
25 | #include "hash.h" | 26 | #include "hash.h" |
26 | #include "ctree.h" | 27 | #include "ctree.h" |
@@ -61,6 +62,13 @@ static int do_chunk_alloc(struct btrfs_trans_handle *trans, | |||
61 | struct btrfs_root *extent_root, u64 alloc_bytes, | 62 | struct btrfs_root *extent_root, u64 alloc_bytes, |
62 | u64 flags, int force); | 63 | u64 flags, int force); |
63 | 64 | ||
65 | static noinline int | ||
66 | block_group_cache_done(struct btrfs_block_group_cache *cache) | ||
67 | { | ||
68 | smp_mb(); | ||
69 | return cache->cached == BTRFS_CACHE_FINISHED; | ||
70 | } | ||
71 | |||
64 | static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits) | 72 | static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits) |
65 | { | 73 | { |
66 | return (cache->flags & bits) == bits; | 74 | return (cache->flags & bits) == bits; |
@@ -146,20 +154,70 @@ block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr, | |||
146 | } | 154 | } |
147 | 155 | ||
148 | /* | 156 | /* |
157 | * We always set EXTENT_LOCKED for the super mirror extents so we don't | ||
158 | * overwrite them, so those bits need to be unset. Also, if we are unmounting | ||
159 | * with pinned extents still sitting there because we had a block group caching, | ||
160 | * we need to clear those now, since we are done. | ||
161 | */ | ||
162 | void btrfs_free_pinned_extents(struct btrfs_fs_info *info) | ||
163 | { | ||
164 | u64 start, end, last = 0; | ||
165 | int ret; | ||
166 | |||
167 | while (1) { | ||
168 | ret = find_first_extent_bit(&info->pinned_extents, last, | ||
169 | &start, &end, | ||
170 | EXTENT_LOCKED|EXTENT_DIRTY); | ||
171 | if (ret) | ||
172 | break; | ||
173 | |||
174 | clear_extent_bits(&info->pinned_extents, start, end, | ||
175 | EXTENT_LOCKED|EXTENT_DIRTY, GFP_NOFS); | ||
176 | last = end+1; | ||
177 | } | ||
178 | } | ||
179 | |||
180 | static int remove_sb_from_cache(struct btrfs_root *root, | ||
181 | struct btrfs_block_group_cache *cache) | ||
182 | { | ||
183 | struct btrfs_fs_info *fs_info = root->fs_info; | ||
184 | u64 bytenr; | ||
185 | u64 *logical; | ||
186 | int stripe_len; | ||
187 | int i, nr, ret; | ||
188 | |||
189 | for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { | ||
190 | bytenr = btrfs_sb_offset(i); | ||
191 | ret = btrfs_rmap_block(&root->fs_info->mapping_tree, | ||
192 | cache->key.objectid, bytenr, | ||
193 | 0, &logical, &nr, &stripe_len); | ||
194 | BUG_ON(ret); | ||
195 | while (nr--) { | ||
196 | try_lock_extent(&fs_info->pinned_extents, | ||
197 | logical[nr], | ||
198 | logical[nr] + stripe_len - 1, GFP_NOFS); | ||
199 | } | ||
200 | kfree(logical); | ||
201 | } | ||
202 | |||
203 | return 0; | ||
204 | } | ||
205 | |||
206 | /* | ||
149 | * this is only called by cache_block_group, since we could have freed extents | 207 | * this is only called by cache_block_group, since we could have freed extents |
150 | * we need to check the pinned_extents for any extents that can't be used yet | 208 | * we need to check the pinned_extents for any extents that can't be used yet |
151 | * since their free space will be released as soon as the transaction commits. | 209 | * since their free space will be released as soon as the transaction commits. |
152 | */ | 210 | */ |
153 | static int add_new_free_space(struct btrfs_block_group_cache *block_group, | 211 | static u64 add_new_free_space(struct btrfs_block_group_cache *block_group, |
154 | struct btrfs_fs_info *info, u64 start, u64 end) | 212 | struct btrfs_fs_info *info, u64 start, u64 end) |
155 | { | 213 | { |
156 | u64 extent_start, extent_end, size; | 214 | u64 extent_start, extent_end, size, total_added = 0; |
157 | int ret; | 215 | int ret; |
158 | 216 | ||
159 | while (start < end) { | 217 | while (start < end) { |
160 | ret = find_first_extent_bit(&info->pinned_extents, start, | 218 | ret = find_first_extent_bit(&info->pinned_extents, start, |
161 | &extent_start, &extent_end, | 219 | &extent_start, &extent_end, |
162 | EXTENT_DIRTY); | 220 | EXTENT_DIRTY|EXTENT_LOCKED); |
163 | if (ret) | 221 | if (ret) |
164 | break; | 222 | break; |
165 | 223 | ||
@@ -167,6 +225,7 @@ static int add_new_free_space(struct btrfs_block_group_cache *block_group, | |||
167 | start = extent_end + 1; | 225 | start = extent_end + 1; |
168 | } else if (extent_start > start && extent_start < end) { | 226 | } else if (extent_start > start && extent_start < end) { |
169 | size = extent_start - start; | 227 | size = extent_start - start; |
228 | total_added += size; | ||
170 | ret = btrfs_add_free_space(block_group, start, | 229 | ret = btrfs_add_free_space(block_group, start, |
171 | size); | 230 | size); |
172 | BUG_ON(ret); | 231 | BUG_ON(ret); |
@@ -178,84 +237,93 @@ static int add_new_free_space(struct btrfs_block_group_cache *block_group, | |||
178 | 237 | ||
179 | if (start < end) { | 238 | if (start < end) { |
180 | size = end - start; | 239 | size = end - start; |
240 | total_added += size; | ||
181 | ret = btrfs_add_free_space(block_group, start, size); | 241 | ret = btrfs_add_free_space(block_group, start, size); |
182 | BUG_ON(ret); | 242 | BUG_ON(ret); |
183 | } | 243 | } |
184 | 244 | ||
185 | return 0; | 245 | return total_added; |
186 | } | ||
187 | |||
188 | static int remove_sb_from_cache(struct btrfs_root *root, | ||
189 | struct btrfs_block_group_cache *cache) | ||
190 | { | ||
191 | u64 bytenr; | ||
192 | u64 *logical; | ||
193 | int stripe_len; | ||
194 | int i, nr, ret; | ||
195 | |||
196 | for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { | ||
197 | bytenr = btrfs_sb_offset(i); | ||
198 | ret = btrfs_rmap_block(&root->fs_info->mapping_tree, | ||
199 | cache->key.objectid, bytenr, 0, | ||
200 | &logical, &nr, &stripe_len); | ||
201 | BUG_ON(ret); | ||
202 | while (nr--) { | ||
203 | btrfs_remove_free_space(cache, logical[nr], | ||
204 | stripe_len); | ||
205 | } | ||
206 | kfree(logical); | ||
207 | } | ||
208 | return 0; | ||
209 | } | 246 | } |
210 | 247 | ||
211 | static int cache_block_group(struct btrfs_root *root, | 248 | static int caching_kthread(void *data) |
212 | struct btrfs_block_group_cache *block_group) | ||
213 | { | 249 | { |
250 | struct btrfs_block_group_cache *block_group = data; | ||
251 | struct btrfs_fs_info *fs_info = block_group->fs_info; | ||
252 | u64 last = 0; | ||
214 | struct btrfs_path *path; | 253 | struct btrfs_path *path; |
215 | int ret = 0; | 254 | int ret = 0; |
216 | struct btrfs_key key; | 255 | struct btrfs_key key; |
217 | struct extent_buffer *leaf; | 256 | struct extent_buffer *leaf; |
218 | int slot; | 257 | int slot; |
219 | u64 last; | 258 | u64 total_found = 0; |
220 | |||
221 | if (!block_group) | ||
222 | return 0; | ||
223 | |||
224 | root = root->fs_info->extent_root; | ||
225 | 259 | ||
226 | if (block_group->cached) | 260 | BUG_ON(!fs_info); |
227 | return 0; | ||
228 | 261 | ||
229 | path = btrfs_alloc_path(); | 262 | path = btrfs_alloc_path(); |
230 | if (!path) | 263 | if (!path) |
231 | return -ENOMEM; | 264 | return -ENOMEM; |
232 | 265 | ||
233 | path->reada = 2; | 266 | atomic_inc(&block_group->space_info->caching_threads); |
267 | last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET); | ||
234 | /* | 268 | /* |
235 | * we get into deadlocks with paths held by callers of this function. | 269 | * We don't want to deadlock with somebody trying to allocate a new |
236 | * since the alloc_mutex is protecting things right now, just | 270 | * extent for the extent root while also trying to search the extent |
237 | * skip the locking here | 271 | * root to add free space. So we skip locking and search the commit |
272 | * root, since its read-only | ||
238 | */ | 273 | */ |
239 | path->skip_locking = 1; | 274 | path->skip_locking = 1; |
240 | last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET); | 275 | path->search_commit_root = 1; |
276 | path->reada = 2; | ||
277 | |||
241 | key.objectid = last; | 278 | key.objectid = last; |
242 | key.offset = 0; | 279 | key.offset = 0; |
243 | btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY); | 280 | btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY); |
244 | ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); | 281 | again: |
282 | /* need to make sure the commit_root doesn't disappear */ | ||
283 | down_read(&fs_info->extent_commit_sem); | ||
284 | |||
285 | ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0); | ||
245 | if (ret < 0) | 286 | if (ret < 0) |
246 | goto err; | 287 | goto err; |
247 | 288 | ||
248 | while (1) { | 289 | while (1) { |
290 | smp_mb(); | ||
291 | if (block_group->fs_info->closing > 1) { | ||
292 | last = (u64)-1; | ||
293 | break; | ||
294 | } | ||
295 | |||
249 | leaf = path->nodes[0]; | 296 | leaf = path->nodes[0]; |
250 | slot = path->slots[0]; | 297 | slot = path->slots[0]; |
251 | if (slot >= btrfs_header_nritems(leaf)) { | 298 | if (slot >= btrfs_header_nritems(leaf)) { |
252 | ret = btrfs_next_leaf(root, path); | 299 | ret = btrfs_next_leaf(fs_info->extent_root, path); |
253 | if (ret < 0) | 300 | if (ret < 0) |
254 | goto err; | 301 | goto err; |
255 | if (ret == 0) | 302 | else if (ret) |
256 | continue; | ||
257 | else | ||
258 | break; | 303 | break; |
304 | |||
305 | if (need_resched() || | ||
306 | btrfs_transaction_in_commit(fs_info)) { | ||
307 | leaf = path->nodes[0]; | ||
308 | |||
309 | /* this shouldn't happen, but if the | ||
310 | * leaf is empty just move on. | ||
311 | */ | ||
312 | if (btrfs_header_nritems(leaf) == 0) | ||
313 | break; | ||
314 | /* | ||
315 | * we need to copy the key out so that | ||
316 | * we are sure the next search advances | ||
317 | * us forward in the btree. | ||
318 | */ | ||
319 | btrfs_item_key_to_cpu(leaf, &key, 0); | ||
320 | btrfs_release_path(fs_info->extent_root, path); | ||
321 | up_read(&fs_info->extent_commit_sem); | ||
322 | schedule_timeout(1); | ||
323 | goto again; | ||
324 | } | ||
325 | |||
326 | continue; | ||
259 | } | 327 | } |
260 | btrfs_item_key_to_cpu(leaf, &key, slot); | 328 | btrfs_item_key_to_cpu(leaf, &key, slot); |
261 | if (key.objectid < block_group->key.objectid) | 329 | if (key.objectid < block_group->key.objectid) |
@@ -266,24 +334,59 @@ static int cache_block_group(struct btrfs_root *root, | |||
266 | break; | 334 | break; |
267 | 335 | ||
268 | if (btrfs_key_type(&key) == BTRFS_EXTENT_ITEM_KEY) { | 336 | if (btrfs_key_type(&key) == BTRFS_EXTENT_ITEM_KEY) { |
269 | add_new_free_space(block_group, root->fs_info, last, | 337 | total_found += add_new_free_space(block_group, |
270 | key.objectid); | 338 | fs_info, last, |
271 | 339 | key.objectid); | |
272 | last = key.objectid + key.offset; | 340 | last = key.objectid + key.offset; |
273 | } | 341 | } |
342 | |||
343 | if (total_found > (1024 * 1024 * 2)) { | ||
344 | total_found = 0; | ||
345 | wake_up(&block_group->caching_q); | ||
346 | } | ||
274 | next: | 347 | next: |
275 | path->slots[0]++; | 348 | path->slots[0]++; |
276 | } | 349 | } |
350 | ret = 0; | ||
277 | 351 | ||
278 | add_new_free_space(block_group, root->fs_info, last, | 352 | total_found += add_new_free_space(block_group, fs_info, last, |
279 | block_group->key.objectid + | 353 | block_group->key.objectid + |
280 | block_group->key.offset); | 354 | block_group->key.offset); |
355 | |||
356 | spin_lock(&block_group->lock); | ||
357 | block_group->cached = BTRFS_CACHE_FINISHED; | ||
358 | spin_unlock(&block_group->lock); | ||
281 | 359 | ||
282 | block_group->cached = 1; | ||
283 | remove_sb_from_cache(root, block_group); | ||
284 | ret = 0; | ||
285 | err: | 360 | err: |
286 | btrfs_free_path(path); | 361 | btrfs_free_path(path); |
362 | up_read(&fs_info->extent_commit_sem); | ||
363 | atomic_dec(&block_group->space_info->caching_threads); | ||
364 | wake_up(&block_group->caching_q); | ||
365 | |||
366 | return 0; | ||
367 | } | ||
368 | |||
369 | static int cache_block_group(struct btrfs_block_group_cache *cache) | ||
370 | { | ||
371 | struct task_struct *tsk; | ||
372 | int ret = 0; | ||
373 | |||
374 | spin_lock(&cache->lock); | ||
375 | if (cache->cached != BTRFS_CACHE_NO) { | ||
376 | spin_unlock(&cache->lock); | ||
377 | return ret; | ||
378 | } | ||
379 | cache->cached = BTRFS_CACHE_STARTED; | ||
380 | spin_unlock(&cache->lock); | ||
381 | |||
382 | tsk = kthread_run(caching_kthread, cache, "btrfs-cache-%llu\n", | ||
383 | cache->key.objectid); | ||
384 | if (IS_ERR(tsk)) { | ||
385 | ret = PTR_ERR(tsk); | ||
386 | printk(KERN_ERR "error running thread %d\n", ret); | ||
387 | BUG(); | ||
388 | } | ||
389 | |||
287 | return ret; | 390 | return ret; |
288 | } | 391 | } |
289 | 392 | ||
@@ -2387,13 +2490,29 @@ fail: | |||
2387 | 2490 | ||
2388 | } | 2491 | } |
2389 | 2492 | ||
2493 | static struct btrfs_block_group_cache * | ||
2494 | next_block_group(struct btrfs_root *root, | ||
2495 | struct btrfs_block_group_cache *cache) | ||
2496 | { | ||
2497 | struct rb_node *node; | ||
2498 | spin_lock(&root->fs_info->block_group_cache_lock); | ||
2499 | node = rb_next(&cache->cache_node); | ||
2500 | btrfs_put_block_group(cache); | ||
2501 | if (node) { | ||
2502 | cache = rb_entry(node, struct btrfs_block_group_cache, | ||
2503 | cache_node); | ||
2504 | atomic_inc(&cache->count); | ||
2505 | } else | ||
2506 | cache = NULL; | ||
2507 | spin_unlock(&root->fs_info->block_group_cache_lock); | ||
2508 | return cache; | ||
2509 | } | ||
2510 | |||
2390 | int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, | 2511 | int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, |
2391 | struct btrfs_root *root) | 2512 | struct btrfs_root *root) |
2392 | { | 2513 | { |
2393 | struct btrfs_block_group_cache *cache, *entry; | 2514 | struct btrfs_block_group_cache *cache; |
2394 | struct rb_node *n; | ||
2395 | int err = 0; | 2515 | int err = 0; |
2396 | int werr = 0; | ||
2397 | struct btrfs_path *path; | 2516 | struct btrfs_path *path; |
2398 | u64 last = 0; | 2517 | u64 last = 0; |
2399 | 2518 | ||
@@ -2402,39 +2521,35 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, | |||
2402 | return -ENOMEM; | 2521 | return -ENOMEM; |
2403 | 2522 | ||
2404 | while (1) { | 2523 | while (1) { |
2405 | cache = NULL; | 2524 | if (last == 0) { |
2406 | spin_lock(&root->fs_info->block_group_cache_lock); | 2525 | err = btrfs_run_delayed_refs(trans, root, |
2407 | for (n = rb_first(&root->fs_info->block_group_cache_tree); | 2526 | (unsigned long)-1); |
2408 | n; n = rb_next(n)) { | 2527 | BUG_ON(err); |
2409 | entry = rb_entry(n, struct btrfs_block_group_cache, | ||
2410 | cache_node); | ||
2411 | if (entry->dirty) { | ||
2412 | cache = entry; | ||
2413 | break; | ||
2414 | } | ||
2415 | } | 2528 | } |
2416 | spin_unlock(&root->fs_info->block_group_cache_lock); | ||
2417 | 2529 | ||
2418 | if (!cache) | 2530 | cache = btrfs_lookup_first_block_group(root->fs_info, last); |
2419 | break; | 2531 | while (cache) { |
2532 | if (cache->dirty) | ||
2533 | break; | ||
2534 | cache = next_block_group(root, cache); | ||
2535 | } | ||
2536 | if (!cache) { | ||
2537 | if (last == 0) | ||
2538 | break; | ||
2539 | last = 0; | ||
2540 | continue; | ||
2541 | } | ||
2420 | 2542 | ||
2421 | cache->dirty = 0; | 2543 | cache->dirty = 0; |
2422 | last += cache->key.offset; | 2544 | last = cache->key.objectid + cache->key.offset; |
2423 | 2545 | ||
2424 | err = write_one_cache_group(trans, root, | 2546 | err = write_one_cache_group(trans, root, path, cache); |
2425 | path, cache); | 2547 | BUG_ON(err); |
2426 | /* | 2548 | btrfs_put_block_group(cache); |
2427 | * if we fail to write the cache group, we want | ||
2428 | * to keep it marked dirty in hopes that a later | ||
2429 | * write will work | ||
2430 | */ | ||
2431 | if (err) { | ||
2432 | werr = err; | ||
2433 | continue; | ||
2434 | } | ||
2435 | } | 2549 | } |
2550 | |||
2436 | btrfs_free_path(path); | 2551 | btrfs_free_path(path); |
2437 | return werr; | 2552 | return 0; |
2438 | } | 2553 | } |
2439 | 2554 | ||
2440 | int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr) | 2555 | int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr) |
@@ -2484,6 +2599,7 @@ static int update_space_info(struct btrfs_fs_info *info, u64 flags, | |||
2484 | found->force_alloc = 0; | 2599 | found->force_alloc = 0; |
2485 | *space_info = found; | 2600 | *space_info = found; |
2486 | list_add_rcu(&found->list, &info->space_info); | 2601 | list_add_rcu(&found->list, &info->space_info); |
2602 | atomic_set(&found->caching_threads, 0); | ||
2487 | return 0; | 2603 | return 0; |
2488 | } | 2604 | } |
2489 | 2605 | ||
@@ -2947,13 +3063,9 @@ int btrfs_update_pinned_extents(struct btrfs_root *root, | |||
2947 | struct btrfs_block_group_cache *cache; | 3063 | struct btrfs_block_group_cache *cache; |
2948 | struct btrfs_fs_info *fs_info = root->fs_info; | 3064 | struct btrfs_fs_info *fs_info = root->fs_info; |
2949 | 3065 | ||
2950 | if (pin) { | 3066 | if (pin) |
2951 | set_extent_dirty(&fs_info->pinned_extents, | 3067 | set_extent_dirty(&fs_info->pinned_extents, |
2952 | bytenr, bytenr + num - 1, GFP_NOFS); | 3068 | bytenr, bytenr + num - 1, GFP_NOFS); |
2953 | } else { | ||
2954 | clear_extent_dirty(&fs_info->pinned_extents, | ||
2955 | bytenr, bytenr + num - 1, GFP_NOFS); | ||
2956 | } | ||
2957 | 3069 | ||
2958 | while (num > 0) { | 3070 | while (num > 0) { |
2959 | cache = btrfs_lookup_block_group(fs_info, bytenr); | 3071 | cache = btrfs_lookup_block_group(fs_info, bytenr); |
@@ -2969,14 +3081,34 @@ int btrfs_update_pinned_extents(struct btrfs_root *root, | |||
2969 | spin_unlock(&cache->space_info->lock); | 3081 | spin_unlock(&cache->space_info->lock); |
2970 | fs_info->total_pinned += len; | 3082 | fs_info->total_pinned += len; |
2971 | } else { | 3083 | } else { |
3084 | int unpin = 0; | ||
3085 | |||
3086 | /* | ||
3087 | * in order to not race with the block group caching, we | ||
3088 | * only want to unpin the extent if we are cached. If | ||
3089 | * we aren't cached, we want to start async caching this | ||
3090 | * block group so we can free the extent the next time | ||
3091 | * around. | ||
3092 | */ | ||
2972 | spin_lock(&cache->space_info->lock); | 3093 | spin_lock(&cache->space_info->lock); |
2973 | spin_lock(&cache->lock); | 3094 | spin_lock(&cache->lock); |
2974 | cache->pinned -= len; | 3095 | unpin = (cache->cached == BTRFS_CACHE_FINISHED); |
2975 | cache->space_info->bytes_pinned -= len; | 3096 | if (likely(unpin)) { |
3097 | cache->pinned -= len; | ||
3098 | cache->space_info->bytes_pinned -= len; | ||
3099 | fs_info->total_pinned -= len; | ||
3100 | } | ||
2976 | spin_unlock(&cache->lock); | 3101 | spin_unlock(&cache->lock); |
2977 | spin_unlock(&cache->space_info->lock); | 3102 | spin_unlock(&cache->space_info->lock); |
2978 | fs_info->total_pinned -= len; | 3103 | |
2979 | if (cache->cached) | 3104 | if (likely(unpin)) |
3105 | clear_extent_dirty(&fs_info->pinned_extents, | ||
3106 | bytenr, bytenr + len -1, | ||
3107 | GFP_NOFS); | ||
3108 | else | ||
3109 | cache_block_group(cache); | ||
3110 | |||
3111 | if (unpin) | ||
2980 | btrfs_add_free_space(cache, bytenr, len); | 3112 | btrfs_add_free_space(cache, bytenr, len); |
2981 | } | 3113 | } |
2982 | btrfs_put_block_group(cache); | 3114 | btrfs_put_block_group(cache); |
@@ -3030,6 +3162,7 @@ int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy) | |||
3030 | &start, &end, EXTENT_DIRTY); | 3162 | &start, &end, EXTENT_DIRTY); |
3031 | if (ret) | 3163 | if (ret) |
3032 | break; | 3164 | break; |
3165 | |||
3033 | set_extent_dirty(copy, start, end, GFP_NOFS); | 3166 | set_extent_dirty(copy, start, end, GFP_NOFS); |
3034 | last = end + 1; | 3167 | last = end + 1; |
3035 | } | 3168 | } |
@@ -3058,6 +3191,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, | |||
3058 | 3191 | ||
3059 | cond_resched(); | 3192 | cond_resched(); |
3060 | } | 3193 | } |
3194 | |||
3061 | return ret; | 3195 | return ret; |
3062 | } | 3196 | } |
3063 | 3197 | ||
@@ -3436,6 +3570,45 @@ static u64 stripe_align(struct btrfs_root *root, u64 val) | |||
3436 | } | 3570 | } |
3437 | 3571 | ||
3438 | /* | 3572 | /* |
3573 | * when we wait for progress in the block group caching, its because | ||
3574 | * our allocation attempt failed at least once. So, we must sleep | ||
3575 | * and let some progress happen before we try again. | ||
3576 | * | ||
3577 | * This function will sleep at least once waiting for new free space to | ||
3578 | * show up, and then it will check the block group free space numbers | ||
3579 | * for our min num_bytes. Another option is to have it go ahead | ||
3580 | * and look in the rbtree for a free extent of a given size, but this | ||
3581 | * is a good start. | ||
3582 | */ | ||
3583 | static noinline int | ||
3584 | wait_block_group_cache_progress(struct btrfs_block_group_cache *cache, | ||
3585 | u64 num_bytes) | ||
3586 | { | ||
3587 | DEFINE_WAIT(wait); | ||
3588 | |||
3589 | prepare_to_wait(&cache->caching_q, &wait, TASK_UNINTERRUPTIBLE); | ||
3590 | |||
3591 | if (block_group_cache_done(cache)) { | ||
3592 | finish_wait(&cache->caching_q, &wait); | ||
3593 | return 0; | ||
3594 | } | ||
3595 | schedule(); | ||
3596 | finish_wait(&cache->caching_q, &wait); | ||
3597 | |||
3598 | wait_event(cache->caching_q, block_group_cache_done(cache) || | ||
3599 | (cache->free_space >= num_bytes)); | ||
3600 | return 0; | ||
3601 | } | ||
3602 | |||
3603 | enum btrfs_loop_type { | ||
3604 | LOOP_CACHED_ONLY = 0, | ||
3605 | LOOP_CACHING_NOWAIT = 1, | ||
3606 | LOOP_CACHING_WAIT = 2, | ||
3607 | LOOP_ALLOC_CHUNK = 3, | ||
3608 | LOOP_NO_EMPTY_SIZE = 4, | ||
3609 | }; | ||
3610 | |||
3611 | /* | ||
3439 | * walks the btree of allocated extents and find a hole of a given size. | 3612 | * walks the btree of allocated extents and find a hole of a given size. |
3440 | * The key ins is changed to record the hole: | 3613 | * The key ins is changed to record the hole: |
3441 | * ins->objectid == block start | 3614 | * ins->objectid == block start |
@@ -3460,6 +3633,7 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans, | |||
3460 | struct btrfs_space_info *space_info; | 3633 | struct btrfs_space_info *space_info; |
3461 | int last_ptr_loop = 0; | 3634 | int last_ptr_loop = 0; |
3462 | int loop = 0; | 3635 | int loop = 0; |
3636 | bool found_uncached_bg = false; | ||
3463 | 3637 | ||
3464 | WARN_ON(num_bytes < root->sectorsize); | 3638 | WARN_ON(num_bytes < root->sectorsize); |
3465 | btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY); | 3639 | btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY); |
@@ -3491,15 +3665,18 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans, | |||
3491 | search_start = max(search_start, first_logical_byte(root, 0)); | 3665 | search_start = max(search_start, first_logical_byte(root, 0)); |
3492 | search_start = max(search_start, hint_byte); | 3666 | search_start = max(search_start, hint_byte); |
3493 | 3667 | ||
3494 | if (!last_ptr) { | 3668 | if (!last_ptr) |
3495 | empty_cluster = 0; | 3669 | empty_cluster = 0; |
3496 | loop = 1; | ||
3497 | } | ||
3498 | 3670 | ||
3499 | if (search_start == hint_byte) { | 3671 | if (search_start == hint_byte) { |
3500 | block_group = btrfs_lookup_block_group(root->fs_info, | 3672 | block_group = btrfs_lookup_block_group(root->fs_info, |
3501 | search_start); | 3673 | search_start); |
3502 | if (block_group && block_group_bits(block_group, data)) { | 3674 | /* |
3675 | * we don't want to use the block group if it doesn't match our | ||
3676 | * allocation bits, or if its not cached. | ||
3677 | */ | ||
3678 | if (block_group && block_group_bits(block_group, data) && | ||
3679 | block_group_cache_done(block_group)) { | ||
3503 | down_read(&space_info->groups_sem); | 3680 | down_read(&space_info->groups_sem); |
3504 | if (list_empty(&block_group->list) || | 3681 | if (list_empty(&block_group->list) || |
3505 | block_group->ro) { | 3682 | block_group->ro) { |
@@ -3522,21 +3699,35 @@ search: | |||
3522 | down_read(&space_info->groups_sem); | 3699 | down_read(&space_info->groups_sem); |
3523 | list_for_each_entry(block_group, &space_info->block_groups, list) { | 3700 | list_for_each_entry(block_group, &space_info->block_groups, list) { |
3524 | u64 offset; | 3701 | u64 offset; |
3702 | int cached; | ||
3525 | 3703 | ||
3526 | atomic_inc(&block_group->count); | 3704 | atomic_inc(&block_group->count); |
3527 | search_start = block_group->key.objectid; | 3705 | search_start = block_group->key.objectid; |
3528 | 3706 | ||
3529 | have_block_group: | 3707 | have_block_group: |
3530 | if (unlikely(!block_group->cached)) { | 3708 | if (unlikely(block_group->cached == BTRFS_CACHE_NO)) { |
3531 | mutex_lock(&block_group->cache_mutex); | 3709 | /* |
3532 | ret = cache_block_group(root, block_group); | 3710 | * we want to start caching kthreads, but not too many |
3533 | mutex_unlock(&block_group->cache_mutex); | 3711 | * right off the bat so we don't overwhelm the system, |
3534 | if (ret) { | 3712 | * so only start them if there are less than 2 and we're |
3535 | btrfs_put_block_group(block_group); | 3713 | * in the initial allocation phase. |
3536 | break; | 3714 | */ |
3715 | if (loop > LOOP_CACHING_NOWAIT || | ||
3716 | atomic_read(&space_info->caching_threads) < 2) { | ||
3717 | ret = cache_block_group(block_group); | ||
3718 | BUG_ON(ret); | ||
3537 | } | 3719 | } |
3538 | } | 3720 | } |
3539 | 3721 | ||
3722 | cached = block_group_cache_done(block_group); | ||
3723 | if (unlikely(!cached)) { | ||
3724 | found_uncached_bg = true; | ||
3725 | |||
3726 | /* if we only want cached bgs, loop */ | ||
3727 | if (loop == LOOP_CACHED_ONLY) | ||
3728 | goto loop; | ||
3729 | } | ||
3730 | |||
3540 | if (unlikely(block_group->ro)) | 3731 | if (unlikely(block_group->ro)) |
3541 | goto loop; | 3732 | goto loop; |
3542 | 3733 | ||
@@ -3615,14 +3806,21 @@ refill_cluster: | |||
3615 | spin_unlock(&last_ptr->refill_lock); | 3806 | spin_unlock(&last_ptr->refill_lock); |
3616 | goto checks; | 3807 | goto checks; |
3617 | } | 3808 | } |
3809 | } else if (!cached && loop > LOOP_CACHING_NOWAIT) { | ||
3810 | spin_unlock(&last_ptr->refill_lock); | ||
3811 | |||
3812 | wait_block_group_cache_progress(block_group, | ||
3813 | num_bytes + empty_cluster + empty_size); | ||
3814 | goto have_block_group; | ||
3618 | } | 3815 | } |
3816 | |||
3619 | /* | 3817 | /* |
3620 | * at this point we either didn't find a cluster | 3818 | * at this point we either didn't find a cluster |
3621 | * or we weren't able to allocate a block from our | 3819 | * or we weren't able to allocate a block from our |
3622 | * cluster. Free the cluster we've been trying | 3820 | * cluster. Free the cluster we've been trying |
3623 | * to use, and go to the next block group | 3821 | * to use, and go to the next block group |
3624 | */ | 3822 | */ |
3625 | if (loop < 2) { | 3823 | if (loop < LOOP_NO_EMPTY_SIZE) { |
3626 | btrfs_return_cluster_to_free_space(NULL, | 3824 | btrfs_return_cluster_to_free_space(NULL, |
3627 | last_ptr); | 3825 | last_ptr); |
3628 | spin_unlock(&last_ptr->refill_lock); | 3826 | spin_unlock(&last_ptr->refill_lock); |
@@ -3633,11 +3831,17 @@ refill_cluster: | |||
3633 | 3831 | ||
3634 | offset = btrfs_find_space_for_alloc(block_group, search_start, | 3832 | offset = btrfs_find_space_for_alloc(block_group, search_start, |
3635 | num_bytes, empty_size); | 3833 | num_bytes, empty_size); |
3636 | if (!offset) | 3834 | if (!offset && (cached || (!cached && |
3835 | loop == LOOP_CACHING_NOWAIT))) { | ||
3637 | goto loop; | 3836 | goto loop; |
3837 | } else if (!offset && (!cached && | ||
3838 | loop > LOOP_CACHING_NOWAIT)) { | ||
3839 | wait_block_group_cache_progress(block_group, | ||
3840 | num_bytes + empty_size); | ||
3841 | goto have_block_group; | ||
3842 | } | ||
3638 | checks: | 3843 | checks: |
3639 | search_start = stripe_align(root, offset); | 3844 | search_start = stripe_align(root, offset); |
3640 | |||
3641 | /* move on to the next group */ | 3845 | /* move on to the next group */ |
3642 | if (search_start + num_bytes >= search_end) { | 3846 | if (search_start + num_bytes >= search_end) { |
3643 | btrfs_add_free_space(block_group, offset, num_bytes); | 3847 | btrfs_add_free_space(block_group, offset, num_bytes); |
@@ -3683,13 +3887,26 @@ loop: | |||
3683 | } | 3887 | } |
3684 | up_read(&space_info->groups_sem); | 3888 | up_read(&space_info->groups_sem); |
3685 | 3889 | ||
3686 | /* loop == 0, try to find a clustered alloc in every block group | 3890 | /* LOOP_CACHED_ONLY, only search fully cached block groups |
3687 | * loop == 1, try again after forcing a chunk allocation | 3891 | * LOOP_CACHING_NOWAIT, search partially cached block groups, but |
3688 | * loop == 2, set empty_size and empty_cluster to 0 and try again | 3892 | * dont wait foR them to finish caching |
3893 | * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching | ||
3894 | * LOOP_ALLOC_CHUNK, force a chunk allocation and try again | ||
3895 | * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try | ||
3896 | * again | ||
3689 | */ | 3897 | */ |
3690 | if (!ins->objectid && loop < 3 && | 3898 | if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE && |
3691 | (empty_size || empty_cluster || allowed_chunk_alloc)) { | 3899 | (found_uncached_bg || empty_size || empty_cluster || |
3692 | if (loop >= 2) { | 3900 | allowed_chunk_alloc)) { |
3901 | if (found_uncached_bg) { | ||
3902 | found_uncached_bg = false; | ||
3903 | if (loop < LOOP_CACHING_WAIT) { | ||
3904 | loop++; | ||
3905 | goto search; | ||
3906 | } | ||
3907 | } | ||
3908 | |||
3909 | if (loop == LOOP_ALLOC_CHUNK) { | ||
3693 | empty_size = 0; | 3910 | empty_size = 0; |
3694 | empty_cluster = 0; | 3911 | empty_cluster = 0; |
3695 | } | 3912 | } |
@@ -3702,7 +3919,7 @@ loop: | |||
3702 | space_info->force_alloc = 1; | 3919 | space_info->force_alloc = 1; |
3703 | } | 3920 | } |
3704 | 3921 | ||
3705 | if (loop < 3) { | 3922 | if (loop < LOOP_NO_EMPTY_SIZE) { |
3706 | loop++; | 3923 | loop++; |
3707 | goto search; | 3924 | goto search; |
3708 | } | 3925 | } |
@@ -3798,7 +4015,7 @@ again: | |||
3798 | num_bytes, data, 1); | 4015 | num_bytes, data, 1); |
3799 | goto again; | 4016 | goto again; |
3800 | } | 4017 | } |
3801 | if (ret) { | 4018 | if (ret == -ENOSPC) { |
3802 | struct btrfs_space_info *sinfo; | 4019 | struct btrfs_space_info *sinfo; |
3803 | 4020 | ||
3804 | sinfo = __find_space_info(root->fs_info, data); | 4021 | sinfo = __find_space_info(root->fs_info, data); |
@@ -3806,7 +4023,6 @@ again: | |||
3806 | "wanted %llu\n", (unsigned long long)data, | 4023 | "wanted %llu\n", (unsigned long long)data, |
3807 | (unsigned long long)num_bytes); | 4024 | (unsigned long long)num_bytes); |
3808 | dump_space_info(sinfo, num_bytes); | 4025 | dump_space_info(sinfo, num_bytes); |
3809 | BUG(); | ||
3810 | } | 4026 | } |
3811 | 4027 | ||
3812 | return ret; | 4028 | return ret; |
@@ -3844,7 +4060,9 @@ int btrfs_reserve_extent(struct btrfs_trans_handle *trans, | |||
3844 | ret = __btrfs_reserve_extent(trans, root, num_bytes, min_alloc_size, | 4060 | ret = __btrfs_reserve_extent(trans, root, num_bytes, min_alloc_size, |
3845 | empty_size, hint_byte, search_end, ins, | 4061 | empty_size, hint_byte, search_end, ins, |
3846 | data); | 4062 | data); |
3847 | update_reserved_extents(root, ins->objectid, ins->offset, 1); | 4063 | if (!ret) |
4064 | update_reserved_extents(root, ins->objectid, ins->offset, 1); | ||
4065 | |||
3848 | return ret; | 4066 | return ret; |
3849 | } | 4067 | } |
3850 | 4068 | ||
@@ -4006,9 +4224,9 @@ int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans, | |||
4006 | struct btrfs_block_group_cache *block_group; | 4224 | struct btrfs_block_group_cache *block_group; |
4007 | 4225 | ||
4008 | block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid); | 4226 | block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid); |
4009 | mutex_lock(&block_group->cache_mutex); | 4227 | cache_block_group(block_group); |
4010 | cache_block_group(root, block_group); | 4228 | wait_event(block_group->caching_q, |
4011 | mutex_unlock(&block_group->cache_mutex); | 4229 | block_group_cache_done(block_group)); |
4012 | 4230 | ||
4013 | ret = btrfs_remove_free_space(block_group, ins->objectid, | 4231 | ret = btrfs_remove_free_space(block_group, ins->objectid, |
4014 | ins->offset); | 4232 | ins->offset); |
@@ -4039,7 +4257,8 @@ static int alloc_tree_block(struct btrfs_trans_handle *trans, | |||
4039 | ret = __btrfs_reserve_extent(trans, root, num_bytes, num_bytes, | 4257 | ret = __btrfs_reserve_extent(trans, root, num_bytes, num_bytes, |
4040 | empty_size, hint_byte, search_end, | 4258 | empty_size, hint_byte, search_end, |
4041 | ins, 0); | 4259 | ins, 0); |
4042 | BUG_ON(ret); | 4260 | if (ret) |
4261 | return ret; | ||
4043 | 4262 | ||
4044 | if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) { | 4263 | if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) { |
4045 | if (parent == 0) | 4264 | if (parent == 0) |
@@ -6955,11 +7174,16 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info) | |||
6955 | &info->block_group_cache_tree); | 7174 | &info->block_group_cache_tree); |
6956 | spin_unlock(&info->block_group_cache_lock); | 7175 | spin_unlock(&info->block_group_cache_lock); |
6957 | 7176 | ||
6958 | btrfs_remove_free_space_cache(block_group); | ||
6959 | down_write(&block_group->space_info->groups_sem); | 7177 | down_write(&block_group->space_info->groups_sem); |
6960 | list_del(&block_group->list); | 7178 | list_del(&block_group->list); |
6961 | up_write(&block_group->space_info->groups_sem); | 7179 | up_write(&block_group->space_info->groups_sem); |
6962 | 7180 | ||
7181 | if (block_group->cached == BTRFS_CACHE_STARTED) | ||
7182 | wait_event(block_group->caching_q, | ||
7183 | block_group_cache_done(block_group)); | ||
7184 | |||
7185 | btrfs_remove_free_space_cache(block_group); | ||
7186 | |||
6963 | WARN_ON(atomic_read(&block_group->count) != 1); | 7187 | WARN_ON(atomic_read(&block_group->count) != 1); |
6964 | kfree(block_group); | 7188 | kfree(block_group); |
6965 | 7189 | ||
@@ -7025,9 +7249,19 @@ int btrfs_read_block_groups(struct btrfs_root *root) | |||
7025 | atomic_set(&cache->count, 1); | 7249 | atomic_set(&cache->count, 1); |
7026 | spin_lock_init(&cache->lock); | 7250 | spin_lock_init(&cache->lock); |
7027 | spin_lock_init(&cache->tree_lock); | 7251 | spin_lock_init(&cache->tree_lock); |
7028 | mutex_init(&cache->cache_mutex); | 7252 | cache->fs_info = info; |
7253 | init_waitqueue_head(&cache->caching_q); | ||
7029 | INIT_LIST_HEAD(&cache->list); | 7254 | INIT_LIST_HEAD(&cache->list); |
7030 | INIT_LIST_HEAD(&cache->cluster_list); | 7255 | INIT_LIST_HEAD(&cache->cluster_list); |
7256 | |||
7257 | /* | ||
7258 | * we only want to have 32k of ram per block group for keeping | ||
7259 | * track of free space, and if we pass 1/2 of that we want to | ||
7260 | * start converting things over to using bitmaps | ||
7261 | */ | ||
7262 | cache->extents_thresh = ((1024 * 32) / 2) / | ||
7263 | sizeof(struct btrfs_free_space); | ||
7264 | |||
7031 | read_extent_buffer(leaf, &cache->item, | 7265 | read_extent_buffer(leaf, &cache->item, |
7032 | btrfs_item_ptr_offset(leaf, path->slots[0]), | 7266 | btrfs_item_ptr_offset(leaf, path->slots[0]), |
7033 | sizeof(cache->item)); | 7267 | sizeof(cache->item)); |
@@ -7036,6 +7270,26 @@ int btrfs_read_block_groups(struct btrfs_root *root) | |||
7036 | key.objectid = found_key.objectid + found_key.offset; | 7270 | key.objectid = found_key.objectid + found_key.offset; |
7037 | btrfs_release_path(root, path); | 7271 | btrfs_release_path(root, path); |
7038 | cache->flags = btrfs_block_group_flags(&cache->item); | 7272 | cache->flags = btrfs_block_group_flags(&cache->item); |
7273 | cache->sectorsize = root->sectorsize; | ||
7274 | |||
7275 | remove_sb_from_cache(root, cache); | ||
7276 | |||
7277 | /* | ||
7278 | * check for two cases, either we are full, and therefore | ||
7279 | * don't need to bother with the caching work since we won't | ||
7280 | * find any space, or we are empty, and we can just add all | ||
7281 | * the space in and be done with it. This saves us _alot_ of | ||
7282 | * time, particularly in the full case. | ||
7283 | */ | ||
7284 | if (found_key.offset == btrfs_block_group_used(&cache->item)) { | ||
7285 | cache->cached = BTRFS_CACHE_FINISHED; | ||
7286 | } else if (btrfs_block_group_used(&cache->item) == 0) { | ||
7287 | cache->cached = BTRFS_CACHE_FINISHED; | ||
7288 | add_new_free_space(cache, root->fs_info, | ||
7289 | found_key.objectid, | ||
7290 | found_key.objectid + | ||
7291 | found_key.offset); | ||
7292 | } | ||
7039 | 7293 | ||
7040 | ret = update_space_info(info, cache->flags, found_key.offset, | 7294 | ret = update_space_info(info, cache->flags, found_key.offset, |
7041 | btrfs_block_group_used(&cache->item), | 7295 | btrfs_block_group_used(&cache->item), |
@@ -7079,10 +7333,19 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, | |||
7079 | cache->key.objectid = chunk_offset; | 7333 | cache->key.objectid = chunk_offset; |
7080 | cache->key.offset = size; | 7334 | cache->key.offset = size; |
7081 | cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; | 7335 | cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; |
7336 | cache->sectorsize = root->sectorsize; | ||
7337 | |||
7338 | /* | ||
7339 | * we only want to have 32k of ram per block group for keeping track | ||
7340 | * of free space, and if we pass 1/2 of that we want to start | ||
7341 | * converting things over to using bitmaps | ||
7342 | */ | ||
7343 | cache->extents_thresh = ((1024 * 32) / 2) / | ||
7344 | sizeof(struct btrfs_free_space); | ||
7082 | atomic_set(&cache->count, 1); | 7345 | atomic_set(&cache->count, 1); |
7083 | spin_lock_init(&cache->lock); | 7346 | spin_lock_init(&cache->lock); |
7084 | spin_lock_init(&cache->tree_lock); | 7347 | spin_lock_init(&cache->tree_lock); |
7085 | mutex_init(&cache->cache_mutex); | 7348 | init_waitqueue_head(&cache->caching_q); |
7086 | INIT_LIST_HEAD(&cache->list); | 7349 | INIT_LIST_HEAD(&cache->list); |
7087 | INIT_LIST_HEAD(&cache->cluster_list); | 7350 | INIT_LIST_HEAD(&cache->cluster_list); |
7088 | 7351 | ||
@@ -7091,6 +7354,12 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, | |||
7091 | cache->flags = type; | 7354 | cache->flags = type; |
7092 | btrfs_set_block_group_flags(&cache->item, type); | 7355 | btrfs_set_block_group_flags(&cache->item, type); |
7093 | 7356 | ||
7357 | cache->cached = BTRFS_CACHE_FINISHED; | ||
7358 | remove_sb_from_cache(root, cache); | ||
7359 | |||
7360 | add_new_free_space(cache, root->fs_info, chunk_offset, | ||
7361 | chunk_offset + size); | ||
7362 | |||
7094 | ret = update_space_info(root->fs_info, cache->flags, size, bytes_used, | 7363 | ret = update_space_info(root->fs_info, cache->flags, size, bytes_used, |
7095 | &cache->space_info); | 7364 | &cache->space_info); |
7096 | BUG_ON(ret); | 7365 | BUG_ON(ret); |
@@ -7149,7 +7418,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, | |||
7149 | rb_erase(&block_group->cache_node, | 7418 | rb_erase(&block_group->cache_node, |
7150 | &root->fs_info->block_group_cache_tree); | 7419 | &root->fs_info->block_group_cache_tree); |
7151 | spin_unlock(&root->fs_info->block_group_cache_lock); | 7420 | spin_unlock(&root->fs_info->block_group_cache_lock); |
7152 | btrfs_remove_free_space_cache(block_group); | 7421 | |
7153 | down_write(&block_group->space_info->groups_sem); | 7422 | down_write(&block_group->space_info->groups_sem); |
7154 | /* | 7423 | /* |
7155 | * we must use list_del_init so people can check to see if they | 7424 | * we must use list_del_init so people can check to see if they |
@@ -7158,11 +7427,18 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, | |||
7158 | list_del_init(&block_group->list); | 7427 | list_del_init(&block_group->list); |
7159 | up_write(&block_group->space_info->groups_sem); | 7428 | up_write(&block_group->space_info->groups_sem); |
7160 | 7429 | ||
7430 | if (block_group->cached == BTRFS_CACHE_STARTED) | ||
7431 | wait_event(block_group->caching_q, | ||
7432 | block_group_cache_done(block_group)); | ||
7433 | |||
7434 | btrfs_remove_free_space_cache(block_group); | ||
7435 | |||
7161 | spin_lock(&block_group->space_info->lock); | 7436 | spin_lock(&block_group->space_info->lock); |
7162 | block_group->space_info->total_bytes -= block_group->key.offset; | 7437 | block_group->space_info->total_bytes -= block_group->key.offset; |
7163 | block_group->space_info->bytes_readonly -= block_group->key.offset; | 7438 | block_group->space_info->bytes_readonly -= block_group->key.offset; |
7164 | spin_unlock(&block_group->space_info->lock); | 7439 | spin_unlock(&block_group->space_info->lock); |
7165 | block_group->space_info->full = 0; | 7440 | |
7441 | btrfs_clear_space_info_full(root->fs_info); | ||
7166 | 7442 | ||
7167 | btrfs_put_block_group(block_group); | 7443 | btrfs_put_block_group(block_group); |
7168 | btrfs_put_block_group(block_group); | 7444 | btrfs_put_block_group(block_group); |