Btrfs: do not set subvolume flags in readonly mode
[deliverable/linux.git] / fs / btrfs / extent-tree.c
CommitLineData
6cbd5570
CM
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
ec6b910f 18#include <linux/sched.h>
edbd8d4e 19#include <linux/pagemap.h>
ec44a35c 20#include <linux/writeback.h>
21af804c 21#include <linux/blkdev.h>
b7a9f29f 22#include <linux/sort.h>
4184ea7f 23#include <linux/rcupdate.h>
817d52f8 24#include <linux/kthread.h>
5a0e3ad6 25#include <linux/slab.h>
dff51cd1 26#include <linux/ratelimit.h>
4b4e25f2 27#include "compat.h"
74493f7a 28#include "hash.h"
fec577fb
CM
29#include "ctree.h"
30#include "disk-io.h"
31#include "print-tree.h"
e089f05c 32#include "transaction.h"
0b86a832 33#include "volumes.h"
925baedd 34#include "locking.h"
fa9c0d79 35#include "free-space-cache.h"
fec577fb 36
9e622d6b
MX
37/*
38 * control flags for do_chunk_alloc's force field
0e4f8f88
CM
39 * CHUNK_ALLOC_NO_FORCE means to only allocate a chunk
40 * if we really need one.
41 *
0e4f8f88
CM
42 * CHUNK_ALLOC_LIMITED means to only try and allocate one
43 * if we have very few chunks already allocated. This is
44 * used as part of the clustering code to help make sure
45 * we have a good pool of storage to cluster in, without
46 * filling the FS with empty chunks
47 *
9e622d6b
MX
48 * CHUNK_ALLOC_FORCE means it must try to allocate one
49 *
0e4f8f88
CM
50 */
51enum {
52 CHUNK_ALLOC_NO_FORCE = 0,
9e622d6b
MX
53 CHUNK_ALLOC_LIMITED = 1,
54 CHUNK_ALLOC_FORCE = 2,
0e4f8f88
CM
55};
56
fb25e914
JB
57/*
58 * Control how reservations are dealt with.
59 *
60 * RESERVE_FREE - freeing a reservation.
61 * RESERVE_ALLOC - allocating space and we need to update bytes_may_use for
62 * ENOSPC accounting
63 * RESERVE_ALLOC_NO_ACCOUNT - allocating space and we should not update
64 * bytes_may_use as the ENOSPC accounting is done elsewhere
65 */
66enum {
67 RESERVE_FREE = 0,
68 RESERVE_ALLOC = 1,
69 RESERVE_ALLOC_NO_ACCOUNT = 2,
70};
71
f3465ca4
JB
72static int update_block_group(struct btrfs_trans_handle *trans,
73 struct btrfs_root *root,
f0486c68 74 u64 bytenr, u64 num_bytes, int alloc);
5d4f98a2
YZ
75static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
76 struct btrfs_root *root,
77 u64 bytenr, u64 num_bytes, u64 parent,
78 u64 root_objectid, u64 owner_objectid,
79 u64 owner_offset, int refs_to_drop,
80 struct btrfs_delayed_extent_op *extra_op);
81static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
82 struct extent_buffer *leaf,
83 struct btrfs_extent_item *ei);
84static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
85 struct btrfs_root *root,
86 u64 parent, u64 root_objectid,
87 u64 flags, u64 owner, u64 offset,
88 struct btrfs_key *ins, int ref_mod);
89static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
90 struct btrfs_root *root,
91 u64 parent, u64 root_objectid,
92 u64 flags, struct btrfs_disk_key *key,
93 int level, struct btrfs_key *ins);
6a63209f
JB
94static int do_chunk_alloc(struct btrfs_trans_handle *trans,
95 struct btrfs_root *extent_root, u64 alloc_bytes,
96 u64 flags, int force);
11833d66
YZ
97static int find_next_key(struct btrfs_path *path, int level,
98 struct btrfs_key *key);
9ed74f2d
JB
99static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
100 int dump_block_groups);
fb25e914
JB
101static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
102 u64 num_bytes, int reserve);
6a63209f 103
817d52f8
JB
104static noinline int
105block_group_cache_done(struct btrfs_block_group_cache *cache)
106{
107 smp_mb();
108 return cache->cached == BTRFS_CACHE_FINISHED;
109}
110
0f9dd46c
JB
111static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
112{
113 return (cache->flags & bits) == bits;
114}
115
62a45b60 116static void btrfs_get_block_group(struct btrfs_block_group_cache *cache)
11dfe35a
JB
117{
118 atomic_inc(&cache->count);
119}
120
121void btrfs_put_block_group(struct btrfs_block_group_cache *cache)
122{
f0486c68
YZ
123 if (atomic_dec_and_test(&cache->count)) {
124 WARN_ON(cache->pinned > 0);
125 WARN_ON(cache->reserved > 0);
34d52cb6 126 kfree(cache->free_space_ctl);
11dfe35a 127 kfree(cache);
f0486c68 128 }
11dfe35a
JB
129}
130
0f9dd46c
JB
131/*
132 * this adds the block group to the fs_info rb tree for the block group
133 * cache
134 */
b2950863 135static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
0f9dd46c
JB
136 struct btrfs_block_group_cache *block_group)
137{
138 struct rb_node **p;
139 struct rb_node *parent = NULL;
140 struct btrfs_block_group_cache *cache;
141
142 spin_lock(&info->block_group_cache_lock);
143 p = &info->block_group_cache_tree.rb_node;
144
145 while (*p) {
146 parent = *p;
147 cache = rb_entry(parent, struct btrfs_block_group_cache,
148 cache_node);
149 if (block_group->key.objectid < cache->key.objectid) {
150 p = &(*p)->rb_left;
151 } else if (block_group->key.objectid > cache->key.objectid) {
152 p = &(*p)->rb_right;
153 } else {
154 spin_unlock(&info->block_group_cache_lock);
155 return -EEXIST;
156 }
157 }
158
159 rb_link_node(&block_group->cache_node, parent, p);
160 rb_insert_color(&block_group->cache_node,
161 &info->block_group_cache_tree);
162 spin_unlock(&info->block_group_cache_lock);
163
164 return 0;
165}
166
167/*
168 * This will return the block group at or after bytenr if contains is 0, else
169 * it will return the block group that contains the bytenr
170 */
171static struct btrfs_block_group_cache *
172block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
173 int contains)
174{
175 struct btrfs_block_group_cache *cache, *ret = NULL;
176 struct rb_node *n;
177 u64 end, start;
178
179 spin_lock(&info->block_group_cache_lock);
180 n = info->block_group_cache_tree.rb_node;
181
182 while (n) {
183 cache = rb_entry(n, struct btrfs_block_group_cache,
184 cache_node);
185 end = cache->key.objectid + cache->key.offset - 1;
186 start = cache->key.objectid;
187
188 if (bytenr < start) {
189 if (!contains && (!ret || start < ret->key.objectid))
190 ret = cache;
191 n = n->rb_left;
192 } else if (bytenr > start) {
193 if (contains && bytenr <= end) {
194 ret = cache;
195 break;
196 }
197 n = n->rb_right;
198 } else {
199 ret = cache;
200 break;
201 }
202 }
d2fb3437 203 if (ret)
11dfe35a 204 btrfs_get_block_group(ret);
0f9dd46c
JB
205 spin_unlock(&info->block_group_cache_lock);
206
207 return ret;
208}
209
11833d66
YZ
210static int add_excluded_extent(struct btrfs_root *root,
211 u64 start, u64 num_bytes)
817d52f8 212{
11833d66
YZ
213 u64 end = start + num_bytes - 1;
214 set_extent_bits(&root->fs_info->freed_extents[0],
215 start, end, EXTENT_UPTODATE, GFP_NOFS);
216 set_extent_bits(&root->fs_info->freed_extents[1],
217 start, end, EXTENT_UPTODATE, GFP_NOFS);
218 return 0;
219}
817d52f8 220
11833d66
YZ
221static void free_excluded_extents(struct btrfs_root *root,
222 struct btrfs_block_group_cache *cache)
223{
224 u64 start, end;
817d52f8 225
11833d66
YZ
226 start = cache->key.objectid;
227 end = start + cache->key.offset - 1;
228
229 clear_extent_bits(&root->fs_info->freed_extents[0],
230 start, end, EXTENT_UPTODATE, GFP_NOFS);
231 clear_extent_bits(&root->fs_info->freed_extents[1],
232 start, end, EXTENT_UPTODATE, GFP_NOFS);
817d52f8
JB
233}
234
11833d66
YZ
235static int exclude_super_stripes(struct btrfs_root *root,
236 struct btrfs_block_group_cache *cache)
817d52f8 237{
817d52f8
JB
238 u64 bytenr;
239 u64 *logical;
240 int stripe_len;
241 int i, nr, ret;
242
06b2331f
YZ
243 if (cache->key.objectid < BTRFS_SUPER_INFO_OFFSET) {
244 stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->key.objectid;
245 cache->bytes_super += stripe_len;
246 ret = add_excluded_extent(root, cache->key.objectid,
247 stripe_len);
79787eaa 248 BUG_ON(ret); /* -ENOMEM */
06b2331f
YZ
249 }
250
817d52f8
JB
251 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
252 bytenr = btrfs_sb_offset(i);
253 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
254 cache->key.objectid, bytenr,
255 0, &logical, &nr, &stripe_len);
79787eaa 256 BUG_ON(ret); /* -ENOMEM */
11833d66 257
817d52f8 258 while (nr--) {
1b2da372 259 cache->bytes_super += stripe_len;
11833d66
YZ
260 ret = add_excluded_extent(root, logical[nr],
261 stripe_len);
79787eaa 262 BUG_ON(ret); /* -ENOMEM */
817d52f8 263 }
11833d66 264
817d52f8
JB
265 kfree(logical);
266 }
817d52f8
JB
267 return 0;
268}
269
11833d66
YZ
270static struct btrfs_caching_control *
271get_caching_control(struct btrfs_block_group_cache *cache)
272{
273 struct btrfs_caching_control *ctl;
274
275 spin_lock(&cache->lock);
276 if (cache->cached != BTRFS_CACHE_STARTED) {
277 spin_unlock(&cache->lock);
278 return NULL;
279 }
280
dde5abee
JB
281 /* We're loading it the fast way, so we don't have a caching_ctl. */
282 if (!cache->caching_ctl) {
283 spin_unlock(&cache->lock);
11833d66
YZ
284 return NULL;
285 }
286
287 ctl = cache->caching_ctl;
288 atomic_inc(&ctl->count);
289 spin_unlock(&cache->lock);
290 return ctl;
291}
292
293static void put_caching_control(struct btrfs_caching_control *ctl)
294{
295 if (atomic_dec_and_test(&ctl->count))
296 kfree(ctl);
297}
298
0f9dd46c
JB
299/*
300 * this is only called by cache_block_group, since we could have freed extents
301 * we need to check the pinned_extents for any extents that can't be used yet
302 * since their free space will be released as soon as the transaction commits.
303 */
817d52f8 304static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
0f9dd46c
JB
305 struct btrfs_fs_info *info, u64 start, u64 end)
306{
817d52f8 307 u64 extent_start, extent_end, size, total_added = 0;
0f9dd46c
JB
308 int ret;
309
310 while (start < end) {
11833d66 311 ret = find_first_extent_bit(info->pinned_extents, start,
0f9dd46c 312 &extent_start, &extent_end,
11833d66 313 EXTENT_DIRTY | EXTENT_UPTODATE);
0f9dd46c
JB
314 if (ret)
315 break;
316
06b2331f 317 if (extent_start <= start) {
0f9dd46c
JB
318 start = extent_end + 1;
319 } else if (extent_start > start && extent_start < end) {
320 size = extent_start - start;
817d52f8 321 total_added += size;
ea6a478e
JB
322 ret = btrfs_add_free_space(block_group, start,
323 size);
79787eaa 324 BUG_ON(ret); /* -ENOMEM or logic error */
0f9dd46c
JB
325 start = extent_end + 1;
326 } else {
327 break;
328 }
329 }
330
331 if (start < end) {
332 size = end - start;
817d52f8 333 total_added += size;
ea6a478e 334 ret = btrfs_add_free_space(block_group, start, size);
79787eaa 335 BUG_ON(ret); /* -ENOMEM or logic error */
0f9dd46c
JB
336 }
337
817d52f8 338 return total_added;
0f9dd46c
JB
339}
340
bab39bf9 341static noinline void caching_thread(struct btrfs_work *work)
e37c9e69 342{
bab39bf9
JB
343 struct btrfs_block_group_cache *block_group;
344 struct btrfs_fs_info *fs_info;
345 struct btrfs_caching_control *caching_ctl;
346 struct btrfs_root *extent_root;
e37c9e69 347 struct btrfs_path *path;
5f39d397 348 struct extent_buffer *leaf;
11833d66 349 struct btrfs_key key;
817d52f8 350 u64 total_found = 0;
11833d66
YZ
351 u64 last = 0;
352 u32 nritems;
353 int ret = 0;
f510cfec 354
bab39bf9
JB
355 caching_ctl = container_of(work, struct btrfs_caching_control, work);
356 block_group = caching_ctl->block_group;
357 fs_info = block_group->fs_info;
358 extent_root = fs_info->extent_root;
359
e37c9e69
CM
360 path = btrfs_alloc_path();
361 if (!path)
bab39bf9 362 goto out;
7d7d6068 363
817d52f8 364 last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
11833d66 365
5cd57b2c 366 /*
817d52f8
JB
367 * We don't want to deadlock with somebody trying to allocate a new
368 * extent for the extent root while also trying to search the extent
369 * root to add free space. So we skip locking and search the commit
370 * root, since its read-only
5cd57b2c
CM
371 */
372 path->skip_locking = 1;
817d52f8 373 path->search_commit_root = 1;
026fd317 374 path->reada = 1;
817d52f8 375
e4404d6e 376 key.objectid = last;
e37c9e69 377 key.offset = 0;
11833d66 378 key.type = BTRFS_EXTENT_ITEM_KEY;
013f1b12 379again:
11833d66 380 mutex_lock(&caching_ctl->mutex);
013f1b12
CM
381 /* need to make sure the commit_root doesn't disappear */
382 down_read(&fs_info->extent_commit_sem);
383
11833d66 384 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
e37c9e69 385 if (ret < 0)
ef8bbdfe 386 goto err;
a512bbf8 387
11833d66
YZ
388 leaf = path->nodes[0];
389 nritems = btrfs_header_nritems(leaf);
390
d397712b 391 while (1) {
7841cb28 392 if (btrfs_fs_closing(fs_info) > 1) {
f25784b3 393 last = (u64)-1;
817d52f8 394 break;
f25784b3 395 }
817d52f8 396
11833d66
YZ
397 if (path->slots[0] < nritems) {
398 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
399 } else {
400 ret = find_next_key(path, 0, &key);
401 if (ret)
e37c9e69 402 break;
817d52f8 403
589d8ade
JB
404 if (need_resched() ||
405 btrfs_next_leaf(extent_root, path)) {
406 caching_ctl->progress = last;
ff5714cc 407 btrfs_release_path(path);
589d8ade
JB
408 up_read(&fs_info->extent_commit_sem);
409 mutex_unlock(&caching_ctl->mutex);
11833d66 410 cond_resched();
589d8ade
JB
411 goto again;
412 }
413 leaf = path->nodes[0];
414 nritems = btrfs_header_nritems(leaf);
415 continue;
11833d66 416 }
817d52f8 417
11833d66
YZ
418 if (key.objectid < block_group->key.objectid) {
419 path->slots[0]++;
817d52f8 420 continue;
e37c9e69 421 }
0f9dd46c 422
e37c9e69 423 if (key.objectid >= block_group->key.objectid +
0f9dd46c 424 block_group->key.offset)
e37c9e69 425 break;
7d7d6068 426
11833d66 427 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
817d52f8
JB
428 total_found += add_new_free_space(block_group,
429 fs_info, last,
430 key.objectid);
7d7d6068 431 last = key.objectid + key.offset;
817d52f8 432
11833d66
YZ
433 if (total_found > (1024 * 1024 * 2)) {
434 total_found = 0;
435 wake_up(&caching_ctl->wait);
436 }
817d52f8 437 }
e37c9e69
CM
438 path->slots[0]++;
439 }
817d52f8 440 ret = 0;
e37c9e69 441
817d52f8
JB
442 total_found += add_new_free_space(block_group, fs_info, last,
443 block_group->key.objectid +
444 block_group->key.offset);
11833d66 445 caching_ctl->progress = (u64)-1;
817d52f8
JB
446
447 spin_lock(&block_group->lock);
11833d66 448 block_group->caching_ctl = NULL;
817d52f8
JB
449 block_group->cached = BTRFS_CACHE_FINISHED;
450 spin_unlock(&block_group->lock);
0f9dd46c 451
54aa1f4d 452err:
e37c9e69 453 btrfs_free_path(path);
276e680d 454 up_read(&fs_info->extent_commit_sem);
817d52f8 455
11833d66
YZ
456 free_excluded_extents(extent_root, block_group);
457
458 mutex_unlock(&caching_ctl->mutex);
bab39bf9 459out:
11833d66
YZ
460 wake_up(&caching_ctl->wait);
461
462 put_caching_control(caching_ctl);
11dfe35a 463 btrfs_put_block_group(block_group);
817d52f8
JB
464}
465
9d66e233
JB
466static int cache_block_group(struct btrfs_block_group_cache *cache,
467 struct btrfs_trans_handle *trans,
b8399dee 468 struct btrfs_root *root,
9d66e233 469 int load_cache_only)
817d52f8 470{
291c7d2f 471 DEFINE_WAIT(wait);
11833d66
YZ
472 struct btrfs_fs_info *fs_info = cache->fs_info;
473 struct btrfs_caching_control *caching_ctl;
817d52f8
JB
474 int ret = 0;
475
291c7d2f 476 caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
79787eaa
JM
477 if (!caching_ctl)
478 return -ENOMEM;
291c7d2f
JB
479
480 INIT_LIST_HEAD(&caching_ctl->list);
481 mutex_init(&caching_ctl->mutex);
482 init_waitqueue_head(&caching_ctl->wait);
483 caching_ctl->block_group = cache;
484 caching_ctl->progress = cache->key.objectid;
485 atomic_set(&caching_ctl->count, 1);
486 caching_ctl->work.func = caching_thread;
487
488 spin_lock(&cache->lock);
489 /*
490 * This should be a rare occasion, but this could happen I think in the
491 * case where one thread starts to load the space cache info, and then
492 * some other thread starts a transaction commit which tries to do an
493 * allocation while the other thread is still loading the space cache
494 * info. The previous loop should have kept us from choosing this block
495 * group, but if we've moved to the state where we will wait on caching
496 * block groups we need to first check if we're doing a fast load here,
497 * so we can wait for it to finish, otherwise we could end up allocating
498 * from a block group who's cache gets evicted for one reason or
499 * another.
500 */
501 while (cache->cached == BTRFS_CACHE_FAST) {
502 struct btrfs_caching_control *ctl;
503
504 ctl = cache->caching_ctl;
505 atomic_inc(&ctl->count);
506 prepare_to_wait(&ctl->wait, &wait, TASK_UNINTERRUPTIBLE);
507 spin_unlock(&cache->lock);
508
509 schedule();
510
511 finish_wait(&ctl->wait, &wait);
512 put_caching_control(ctl);
513 spin_lock(&cache->lock);
514 }
515
516 if (cache->cached != BTRFS_CACHE_NO) {
517 spin_unlock(&cache->lock);
518 kfree(caching_ctl);
11833d66 519 return 0;
291c7d2f
JB
520 }
521 WARN_ON(cache->caching_ctl);
522 cache->caching_ctl = caching_ctl;
523 cache->cached = BTRFS_CACHE_FAST;
524 spin_unlock(&cache->lock);
11833d66 525
9d66e233
JB
526 /*
527 * We can't do the read from on-disk cache during a commit since we need
b8399dee
JB
528 * to have the normal tree locking. Also if we are currently trying to
529 * allocate blocks for the tree root we can't do the fast caching since
530 * we likely hold important locks.
9d66e233 531 */
d53ba474 532 if (fs_info->mount_opt & BTRFS_MOUNT_SPACE_CACHE) {
9d66e233
JB
533 ret = load_free_space_cache(fs_info, cache);
534
535 spin_lock(&cache->lock);
536 if (ret == 1) {
291c7d2f 537 cache->caching_ctl = NULL;
9d66e233
JB
538 cache->cached = BTRFS_CACHE_FINISHED;
539 cache->last_byte_to_unpin = (u64)-1;
540 } else {
291c7d2f
JB
541 if (load_cache_only) {
542 cache->caching_ctl = NULL;
543 cache->cached = BTRFS_CACHE_NO;
544 } else {
545 cache->cached = BTRFS_CACHE_STARTED;
546 }
9d66e233
JB
547 }
548 spin_unlock(&cache->lock);
291c7d2f 549 wake_up(&caching_ctl->wait);
3c14874a 550 if (ret == 1) {
291c7d2f 551 put_caching_control(caching_ctl);
3c14874a 552 free_excluded_extents(fs_info->extent_root, cache);
9d66e233 553 return 0;
3c14874a 554 }
291c7d2f
JB
555 } else {
556 /*
557 * We are not going to do the fast caching, set cached to the
558 * appropriate value and wakeup any waiters.
559 */
560 spin_lock(&cache->lock);
561 if (load_cache_only) {
562 cache->caching_ctl = NULL;
563 cache->cached = BTRFS_CACHE_NO;
564 } else {
565 cache->cached = BTRFS_CACHE_STARTED;
566 }
567 spin_unlock(&cache->lock);
568 wake_up(&caching_ctl->wait);
9d66e233
JB
569 }
570
291c7d2f
JB
571 if (load_cache_only) {
572 put_caching_control(caching_ctl);
11833d66 573 return 0;
817d52f8 574 }
817d52f8 575
11833d66 576 down_write(&fs_info->extent_commit_sem);
291c7d2f 577 atomic_inc(&caching_ctl->count);
11833d66
YZ
578 list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
579 up_write(&fs_info->extent_commit_sem);
580
11dfe35a 581 btrfs_get_block_group(cache);
11833d66 582
bab39bf9 583 btrfs_queue_worker(&fs_info->caching_workers, &caching_ctl->work);
817d52f8 584
ef8bbdfe 585 return ret;
e37c9e69
CM
586}
587
0f9dd46c
JB
588/*
589 * return the block group that starts at or after bytenr
590 */
d397712b
CM
591static struct btrfs_block_group_cache *
592btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
0ef3e66b 593{
0f9dd46c 594 struct btrfs_block_group_cache *cache;
0ef3e66b 595
0f9dd46c 596 cache = block_group_cache_tree_search(info, bytenr, 0);
0ef3e66b 597
0f9dd46c 598 return cache;
0ef3e66b
CM
599}
600
0f9dd46c 601/*
9f55684c 602 * return the block group that contains the given bytenr
0f9dd46c 603 */
d397712b
CM
604struct btrfs_block_group_cache *btrfs_lookup_block_group(
605 struct btrfs_fs_info *info,
606 u64 bytenr)
be744175 607{
0f9dd46c 608 struct btrfs_block_group_cache *cache;
be744175 609
0f9dd46c 610 cache = block_group_cache_tree_search(info, bytenr, 1);
96b5179d 611
0f9dd46c 612 return cache;
be744175 613}
0b86a832 614
0f9dd46c
JB
615static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
616 u64 flags)
6324fbf3 617{
0f9dd46c 618 struct list_head *head = &info->space_info;
0f9dd46c 619 struct btrfs_space_info *found;
4184ea7f 620
52ba6929 621 flags &= BTRFS_BLOCK_GROUP_TYPE_MASK;
b742bb82 622
4184ea7f
CM
623 rcu_read_lock();
624 list_for_each_entry_rcu(found, head, list) {
67377734 625 if (found->flags & flags) {
4184ea7f 626 rcu_read_unlock();
0f9dd46c 627 return found;
4184ea7f 628 }
0f9dd46c 629 }
4184ea7f 630 rcu_read_unlock();
0f9dd46c 631 return NULL;
6324fbf3
CM
632}
633
4184ea7f
CM
634/*
635 * after adding space to the filesystem, we need to clear the full flags
636 * on all the space infos.
637 */
638void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
639{
640 struct list_head *head = &info->space_info;
641 struct btrfs_space_info *found;
642
643 rcu_read_lock();
644 list_for_each_entry_rcu(found, head, list)
645 found->full = 0;
646 rcu_read_unlock();
647}
648
80eb234a
JB
649static u64 div_factor(u64 num, int factor)
650{
651 if (factor == 10)
652 return num;
653 num *= factor;
654 do_div(num, 10);
655 return num;
656}
657
e5bc2458
CM
658static u64 div_factor_fine(u64 num, int factor)
659{
660 if (factor == 100)
661 return num;
662 num *= factor;
663 do_div(num, 100);
664 return num;
665}
666
d2fb3437
YZ
667u64 btrfs_find_block_group(struct btrfs_root *root,
668 u64 search_start, u64 search_hint, int owner)
cd1bc465 669{
96b5179d 670 struct btrfs_block_group_cache *cache;
cd1bc465 671 u64 used;
d2fb3437
YZ
672 u64 last = max(search_hint, search_start);
673 u64 group_start = 0;
31f3c99b 674 int full_search = 0;
d2fb3437 675 int factor = 9;
0ef3e66b 676 int wrapped = 0;
31f3c99b 677again:
e8569813
ZY
678 while (1) {
679 cache = btrfs_lookup_first_block_group(root->fs_info, last);
0f9dd46c
JB
680 if (!cache)
681 break;
96b5179d 682
c286ac48 683 spin_lock(&cache->lock);
96b5179d
CM
684 last = cache->key.objectid + cache->key.offset;
685 used = btrfs_block_group_used(&cache->item);
686
d2fb3437
YZ
687 if ((full_search || !cache->ro) &&
688 block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
e8569813 689 if (used + cache->pinned + cache->reserved <
d2fb3437
YZ
690 div_factor(cache->key.offset, factor)) {
691 group_start = cache->key.objectid;
c286ac48 692 spin_unlock(&cache->lock);
fa9c0d79 693 btrfs_put_block_group(cache);
8790d502
CM
694 goto found;
695 }
6324fbf3 696 }
c286ac48 697 spin_unlock(&cache->lock);
fa9c0d79 698 btrfs_put_block_group(cache);
de428b63 699 cond_resched();
cd1bc465 700 }
0ef3e66b
CM
701 if (!wrapped) {
702 last = search_start;
703 wrapped = 1;
704 goto again;
705 }
706 if (!full_search && factor < 10) {
be744175 707 last = search_start;
31f3c99b 708 full_search = 1;
0ef3e66b 709 factor = 10;
31f3c99b
CM
710 goto again;
711 }
be744175 712found:
d2fb3437 713 return group_start;
925baedd 714}
0f9dd46c 715
e02119d5 716/* simple helper to search for an existing extent at a given offset */
31840ae1 717int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
e02119d5
CM
718{
719 int ret;
720 struct btrfs_key key;
31840ae1 721 struct btrfs_path *path;
e02119d5 722
31840ae1 723 path = btrfs_alloc_path();
d8926bb3
MF
724 if (!path)
725 return -ENOMEM;
726
e02119d5
CM
727 key.objectid = start;
728 key.offset = len;
729 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
730 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
731 0, 0);
31840ae1 732 btrfs_free_path(path);
7bb86316
CM
733 return ret;
734}
735
a22285a6
YZ
736/*
737 * helper function to lookup reference count and flags of extent.
738 *
739 * the head node for delayed ref is used to store the sum of all the
740 * reference count modifications queued up in the rbtree. the head
741 * node may also store the extent flags to set. This way you can check
742 * to see what the reference count and extent flags would be if all of
743 * the delayed refs are not processed.
744 */
745int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
746 struct btrfs_root *root, u64 bytenr,
747 u64 num_bytes, u64 *refs, u64 *flags)
748{
749 struct btrfs_delayed_ref_head *head;
750 struct btrfs_delayed_ref_root *delayed_refs;
751 struct btrfs_path *path;
752 struct btrfs_extent_item *ei;
753 struct extent_buffer *leaf;
754 struct btrfs_key key;
755 u32 item_size;
756 u64 num_refs;
757 u64 extent_flags;
758 int ret;
759
760 path = btrfs_alloc_path();
761 if (!path)
762 return -ENOMEM;
763
764 key.objectid = bytenr;
765 key.type = BTRFS_EXTENT_ITEM_KEY;
766 key.offset = num_bytes;
767 if (!trans) {
768 path->skip_locking = 1;
769 path->search_commit_root = 1;
770 }
771again:
772 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
773 &key, path, 0, 0);
774 if (ret < 0)
775 goto out_free;
776
777 if (ret == 0) {
778 leaf = path->nodes[0];
779 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
780 if (item_size >= sizeof(*ei)) {
781 ei = btrfs_item_ptr(leaf, path->slots[0],
782 struct btrfs_extent_item);
783 num_refs = btrfs_extent_refs(leaf, ei);
784 extent_flags = btrfs_extent_flags(leaf, ei);
785 } else {
786#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
787 struct btrfs_extent_item_v0 *ei0;
788 BUG_ON(item_size != sizeof(*ei0));
789 ei0 = btrfs_item_ptr(leaf, path->slots[0],
790 struct btrfs_extent_item_v0);
791 num_refs = btrfs_extent_refs_v0(leaf, ei0);
792 /* FIXME: this isn't correct for data */
793 extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
794#else
795 BUG();
796#endif
797 }
798 BUG_ON(num_refs == 0);
799 } else {
800 num_refs = 0;
801 extent_flags = 0;
802 ret = 0;
803 }
804
805 if (!trans)
806 goto out;
807
808 delayed_refs = &trans->transaction->delayed_refs;
809 spin_lock(&delayed_refs->lock);
810 head = btrfs_find_delayed_ref_head(trans, bytenr);
811 if (head) {
812 if (!mutex_trylock(&head->mutex)) {
813 atomic_inc(&head->node.refs);
814 spin_unlock(&delayed_refs->lock);
815
b3b4aa74 816 btrfs_release_path(path);
a22285a6 817
8cc33e5c
DS
818 /*
819 * Mutex was contended, block until it's released and try
820 * again
821 */
a22285a6
YZ
822 mutex_lock(&head->mutex);
823 mutex_unlock(&head->mutex);
824 btrfs_put_delayed_ref(&head->node);
825 goto again;
826 }
827 if (head->extent_op && head->extent_op->update_flags)
828 extent_flags |= head->extent_op->flags_to_set;
829 else
830 BUG_ON(num_refs == 0);
831
832 num_refs += head->node.ref_mod;
833 mutex_unlock(&head->mutex);
834 }
835 spin_unlock(&delayed_refs->lock);
836out:
837 WARN_ON(num_refs == 0);
838 if (refs)
839 *refs = num_refs;
840 if (flags)
841 *flags = extent_flags;
842out_free:
843 btrfs_free_path(path);
844 return ret;
845}
846
d8d5f3e1
CM
847/*
848 * Back reference rules. Back refs have three main goals:
849 *
850 * 1) differentiate between all holders of references to an extent so that
851 * when a reference is dropped we can make sure it was a valid reference
852 * before freeing the extent.
853 *
854 * 2) Provide enough information to quickly find the holders of an extent
855 * if we notice a given block is corrupted or bad.
856 *
857 * 3) Make it easy to migrate blocks for FS shrinking or storage pool
858 * maintenance. This is actually the same as #2, but with a slightly
859 * different use case.
860 *
5d4f98a2
YZ
861 * There are two kinds of back refs. The implicit back refs is optimized
862 * for pointers in non-shared tree blocks. For a given pointer in a block,
863 * back refs of this kind provide information about the block's owner tree
864 * and the pointer's key. These information allow us to find the block by
865 * b-tree searching. The full back refs is for pointers in tree blocks not
866 * referenced by their owner trees. The location of tree block is recorded
867 * in the back refs. Actually the full back refs is generic, and can be
868 * used in all cases the implicit back refs is used. The major shortcoming
869 * of the full back refs is its overhead. Every time a tree block gets
870 * COWed, we have to update back refs entry for all pointers in it.
871 *
872 * For a newly allocated tree block, we use implicit back refs for
873 * pointers in it. This means most tree related operations only involve
874 * implicit back refs. For a tree block created in old transaction, the
875 * only way to drop a reference to it is COW it. So we can detect the
876 * event that tree block loses its owner tree's reference and do the
877 * back refs conversion.
878 *
879 * When a tree block is COW'd through a tree, there are four cases:
880 *
881 * The reference count of the block is one and the tree is the block's
882 * owner tree. Nothing to do in this case.
883 *
884 * The reference count of the block is one and the tree is not the
885 * block's owner tree. In this case, full back refs is used for pointers
886 * in the block. Remove these full back refs, add implicit back refs for
887 * every pointers in the new block.
888 *
889 * The reference count of the block is greater than one and the tree is
890 * the block's owner tree. In this case, implicit back refs is used for
891 * pointers in the block. Add full back refs for every pointers in the
892 * block, increase lower level extents' reference counts. The original
893 * implicit back refs are entailed to the new block.
894 *
895 * The reference count of the block is greater than one and the tree is
896 * not the block's owner tree. Add implicit back refs for every pointer in
897 * the new block, increase lower level extents' reference count.
898 *
899 * Back Reference Key composing:
900 *
901 * The key objectid corresponds to the first byte in the extent,
902 * The key type is used to differentiate between types of back refs.
903 * There are different meanings of the key offset for different types
904 * of back refs.
905 *
d8d5f3e1
CM
906 * File extents can be referenced by:
907 *
908 * - multiple snapshots, subvolumes, or different generations in one subvol
31840ae1 909 * - different files inside a single subvolume
d8d5f3e1
CM
910 * - different offsets inside a file (bookend extents in file.c)
911 *
5d4f98a2 912 * The extent ref structure for the implicit back refs has fields for:
d8d5f3e1
CM
913 *
914 * - Objectid of the subvolume root
d8d5f3e1 915 * - objectid of the file holding the reference
5d4f98a2
YZ
916 * - original offset in the file
917 * - how many bookend extents
d8d5f3e1 918 *
5d4f98a2
YZ
919 * The key offset for the implicit back refs is hash of the first
920 * three fields.
d8d5f3e1 921 *
5d4f98a2 922 * The extent ref structure for the full back refs has field for:
d8d5f3e1 923 *
5d4f98a2 924 * - number of pointers in the tree leaf
d8d5f3e1 925 *
5d4f98a2
YZ
926 * The key offset for the implicit back refs is the first byte of
927 * the tree leaf
d8d5f3e1 928 *
5d4f98a2
YZ
929 * When a file extent is allocated, The implicit back refs is used.
930 * the fields are filled in:
d8d5f3e1 931 *
5d4f98a2 932 * (root_key.objectid, inode objectid, offset in file, 1)
d8d5f3e1 933 *
5d4f98a2
YZ
934 * When a file extent is removed file truncation, we find the
935 * corresponding implicit back refs and check the following fields:
d8d5f3e1 936 *
5d4f98a2 937 * (btrfs_header_owner(leaf), inode objectid, offset in file)
d8d5f3e1 938 *
5d4f98a2 939 * Btree extents can be referenced by:
d8d5f3e1 940 *
5d4f98a2 941 * - Different subvolumes
d8d5f3e1 942 *
5d4f98a2
YZ
943 * Both the implicit back refs and the full back refs for tree blocks
944 * only consist of key. The key offset for the implicit back refs is
945 * objectid of block's owner tree. The key offset for the full back refs
946 * is the first byte of parent block.
d8d5f3e1 947 *
5d4f98a2
YZ
948 * When implicit back refs is used, information about the lowest key and
949 * level of the tree block are required. These information are stored in
950 * tree block info structure.
d8d5f3e1 951 */
31840ae1 952
5d4f98a2
YZ
953#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
954static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
955 struct btrfs_root *root,
956 struct btrfs_path *path,
957 u64 owner, u32 extra_size)
7bb86316 958{
5d4f98a2
YZ
959 struct btrfs_extent_item *item;
960 struct btrfs_extent_item_v0 *ei0;
961 struct btrfs_extent_ref_v0 *ref0;
962 struct btrfs_tree_block_info *bi;
963 struct extent_buffer *leaf;
7bb86316 964 struct btrfs_key key;
5d4f98a2
YZ
965 struct btrfs_key found_key;
966 u32 new_size = sizeof(*item);
967 u64 refs;
968 int ret;
969
970 leaf = path->nodes[0];
971 BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));
972
973 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
974 ei0 = btrfs_item_ptr(leaf, path->slots[0],
975 struct btrfs_extent_item_v0);
976 refs = btrfs_extent_refs_v0(leaf, ei0);
977
978 if (owner == (u64)-1) {
979 while (1) {
980 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
981 ret = btrfs_next_leaf(root, path);
982 if (ret < 0)
983 return ret;
79787eaa 984 BUG_ON(ret > 0); /* Corruption */
5d4f98a2
YZ
985 leaf = path->nodes[0];
986 }
987 btrfs_item_key_to_cpu(leaf, &found_key,
988 path->slots[0]);
989 BUG_ON(key.objectid != found_key.objectid);
990 if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
991 path->slots[0]++;
992 continue;
993 }
994 ref0 = btrfs_item_ptr(leaf, path->slots[0],
995 struct btrfs_extent_ref_v0);
996 owner = btrfs_ref_objectid_v0(leaf, ref0);
997 break;
998 }
999 }
b3b4aa74 1000 btrfs_release_path(path);
5d4f98a2
YZ
1001
1002 if (owner < BTRFS_FIRST_FREE_OBJECTID)
1003 new_size += sizeof(*bi);
1004
1005 new_size -= sizeof(*ei0);
1006 ret = btrfs_search_slot(trans, root, &key, path,
1007 new_size + extra_size, 1);
1008 if (ret < 0)
1009 return ret;
79787eaa 1010 BUG_ON(ret); /* Corruption */
5d4f98a2 1011
143bede5 1012 btrfs_extend_item(trans, root, path, new_size);
5d4f98a2
YZ
1013
1014 leaf = path->nodes[0];
1015 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1016 btrfs_set_extent_refs(leaf, item, refs);
1017 /* FIXME: get real generation */
1018 btrfs_set_extent_generation(leaf, item, 0);
1019 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1020 btrfs_set_extent_flags(leaf, item,
1021 BTRFS_EXTENT_FLAG_TREE_BLOCK |
1022 BTRFS_BLOCK_FLAG_FULL_BACKREF);
1023 bi = (struct btrfs_tree_block_info *)(item + 1);
1024 /* FIXME: get first key of the block */
1025 memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
1026 btrfs_set_tree_block_level(leaf, bi, (int)owner);
1027 } else {
1028 btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
1029 }
1030 btrfs_mark_buffer_dirty(leaf);
1031 return 0;
1032}
1033#endif
1034
1035static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
1036{
1037 u32 high_crc = ~(u32)0;
1038 u32 low_crc = ~(u32)0;
1039 __le64 lenum;
1040
1041 lenum = cpu_to_le64(root_objectid);
163e783e 1042 high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
5d4f98a2 1043 lenum = cpu_to_le64(owner);
163e783e 1044 low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
5d4f98a2 1045 lenum = cpu_to_le64(offset);
163e783e 1046 low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
5d4f98a2
YZ
1047
1048 return ((u64)high_crc << 31) ^ (u64)low_crc;
1049}
1050
1051static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
1052 struct btrfs_extent_data_ref *ref)
1053{
1054 return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
1055 btrfs_extent_data_ref_objectid(leaf, ref),
1056 btrfs_extent_data_ref_offset(leaf, ref));
1057}
1058
1059static int match_extent_data_ref(struct extent_buffer *leaf,
1060 struct btrfs_extent_data_ref *ref,
1061 u64 root_objectid, u64 owner, u64 offset)
1062{
1063 if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
1064 btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
1065 btrfs_extent_data_ref_offset(leaf, ref) != offset)
1066 return 0;
1067 return 1;
1068}
1069
1070static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
1071 struct btrfs_root *root,
1072 struct btrfs_path *path,
1073 u64 bytenr, u64 parent,
1074 u64 root_objectid,
1075 u64 owner, u64 offset)
1076{
1077 struct btrfs_key key;
1078 struct btrfs_extent_data_ref *ref;
31840ae1 1079 struct extent_buffer *leaf;
5d4f98a2 1080 u32 nritems;
74493f7a 1081 int ret;
5d4f98a2
YZ
1082 int recow;
1083 int err = -ENOENT;
74493f7a 1084
31840ae1 1085 key.objectid = bytenr;
5d4f98a2
YZ
1086 if (parent) {
1087 key.type = BTRFS_SHARED_DATA_REF_KEY;
1088 key.offset = parent;
1089 } else {
1090 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1091 key.offset = hash_extent_data_ref(root_objectid,
1092 owner, offset);
1093 }
1094again:
1095 recow = 0;
1096 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1097 if (ret < 0) {
1098 err = ret;
1099 goto fail;
1100 }
31840ae1 1101
5d4f98a2
YZ
1102 if (parent) {
1103 if (!ret)
1104 return 0;
1105#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1106 key.type = BTRFS_EXTENT_REF_V0_KEY;
b3b4aa74 1107 btrfs_release_path(path);
5d4f98a2
YZ
1108 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1109 if (ret < 0) {
1110 err = ret;
1111 goto fail;
1112 }
1113 if (!ret)
1114 return 0;
1115#endif
1116 goto fail;
31840ae1
ZY
1117 }
1118
1119 leaf = path->nodes[0];
5d4f98a2
YZ
1120 nritems = btrfs_header_nritems(leaf);
1121 while (1) {
1122 if (path->slots[0] >= nritems) {
1123 ret = btrfs_next_leaf(root, path);
1124 if (ret < 0)
1125 err = ret;
1126 if (ret)
1127 goto fail;
1128
1129 leaf = path->nodes[0];
1130 nritems = btrfs_header_nritems(leaf);
1131 recow = 1;
1132 }
1133
1134 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1135 if (key.objectid != bytenr ||
1136 key.type != BTRFS_EXTENT_DATA_REF_KEY)
1137 goto fail;
1138
1139 ref = btrfs_item_ptr(leaf, path->slots[0],
1140 struct btrfs_extent_data_ref);
1141
1142 if (match_extent_data_ref(leaf, ref, root_objectid,
1143 owner, offset)) {
1144 if (recow) {
b3b4aa74 1145 btrfs_release_path(path);
5d4f98a2
YZ
1146 goto again;
1147 }
1148 err = 0;
1149 break;
1150 }
1151 path->slots[0]++;
31840ae1 1152 }
5d4f98a2
YZ
1153fail:
1154 return err;
31840ae1
ZY
1155}
1156
5d4f98a2
YZ
1157static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
1158 struct btrfs_root *root,
1159 struct btrfs_path *path,
1160 u64 bytenr, u64 parent,
1161 u64 root_objectid, u64 owner,
1162 u64 offset, int refs_to_add)
31840ae1
ZY
1163{
1164 struct btrfs_key key;
1165 struct extent_buffer *leaf;
5d4f98a2 1166 u32 size;
31840ae1
ZY
1167 u32 num_refs;
1168 int ret;
74493f7a 1169
74493f7a 1170 key.objectid = bytenr;
5d4f98a2
YZ
1171 if (parent) {
1172 key.type = BTRFS_SHARED_DATA_REF_KEY;
1173 key.offset = parent;
1174 size = sizeof(struct btrfs_shared_data_ref);
1175 } else {
1176 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1177 key.offset = hash_extent_data_ref(root_objectid,
1178 owner, offset);
1179 size = sizeof(struct btrfs_extent_data_ref);
1180 }
74493f7a 1181
5d4f98a2
YZ
1182 ret = btrfs_insert_empty_item(trans, root, path, &key, size);
1183 if (ret && ret != -EEXIST)
1184 goto fail;
1185
1186 leaf = path->nodes[0];
1187 if (parent) {
1188 struct btrfs_shared_data_ref *ref;
31840ae1 1189 ref = btrfs_item_ptr(leaf, path->slots[0],
5d4f98a2
YZ
1190 struct btrfs_shared_data_ref);
1191 if (ret == 0) {
1192 btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
1193 } else {
1194 num_refs = btrfs_shared_data_ref_count(leaf, ref);
1195 num_refs += refs_to_add;
1196 btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
31840ae1 1197 }
5d4f98a2
YZ
1198 } else {
1199 struct btrfs_extent_data_ref *ref;
1200 while (ret == -EEXIST) {
1201 ref = btrfs_item_ptr(leaf, path->slots[0],
1202 struct btrfs_extent_data_ref);
1203 if (match_extent_data_ref(leaf, ref, root_objectid,
1204 owner, offset))
1205 break;
b3b4aa74 1206 btrfs_release_path(path);
5d4f98a2
YZ
1207 key.offset++;
1208 ret = btrfs_insert_empty_item(trans, root, path, &key,
1209 size);
1210 if (ret && ret != -EEXIST)
1211 goto fail;
31840ae1 1212
5d4f98a2
YZ
1213 leaf = path->nodes[0];
1214 }
1215 ref = btrfs_item_ptr(leaf, path->slots[0],
1216 struct btrfs_extent_data_ref);
1217 if (ret == 0) {
1218 btrfs_set_extent_data_ref_root(leaf, ref,
1219 root_objectid);
1220 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
1221 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
1222 btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
1223 } else {
1224 num_refs = btrfs_extent_data_ref_count(leaf, ref);
1225 num_refs += refs_to_add;
1226 btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
31840ae1 1227 }
31840ae1 1228 }
5d4f98a2
YZ
1229 btrfs_mark_buffer_dirty(leaf);
1230 ret = 0;
1231fail:
b3b4aa74 1232 btrfs_release_path(path);
7bb86316 1233 return ret;
74493f7a
CM
1234}
1235
5d4f98a2
YZ
1236static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
1237 struct btrfs_root *root,
1238 struct btrfs_path *path,
1239 int refs_to_drop)
31840ae1 1240{
5d4f98a2
YZ
1241 struct btrfs_key key;
1242 struct btrfs_extent_data_ref *ref1 = NULL;
1243 struct btrfs_shared_data_ref *ref2 = NULL;
31840ae1 1244 struct extent_buffer *leaf;
5d4f98a2 1245 u32 num_refs = 0;
31840ae1
ZY
1246 int ret = 0;
1247
1248 leaf = path->nodes[0];
5d4f98a2
YZ
1249 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1250
1251 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1252 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1253 struct btrfs_extent_data_ref);
1254 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1255 } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1256 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1257 struct btrfs_shared_data_ref);
1258 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1259#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1260 } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1261 struct btrfs_extent_ref_v0 *ref0;
1262 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1263 struct btrfs_extent_ref_v0);
1264 num_refs = btrfs_ref_count_v0(leaf, ref0);
1265#endif
1266 } else {
1267 BUG();
1268 }
1269
56bec294
CM
1270 BUG_ON(num_refs < refs_to_drop);
1271 num_refs -= refs_to_drop;
5d4f98a2 1272
31840ae1
ZY
1273 if (num_refs == 0) {
1274 ret = btrfs_del_item(trans, root, path);
1275 } else {
5d4f98a2
YZ
1276 if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
1277 btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
1278 else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
1279 btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
1280#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1281 else {
1282 struct btrfs_extent_ref_v0 *ref0;
1283 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1284 struct btrfs_extent_ref_v0);
1285 btrfs_set_ref_count_v0(leaf, ref0, num_refs);
1286 }
1287#endif
31840ae1
ZY
1288 btrfs_mark_buffer_dirty(leaf);
1289 }
31840ae1
ZY
1290 return ret;
1291}
1292
5d4f98a2
YZ
1293static noinline u32 extent_data_ref_count(struct btrfs_root *root,
1294 struct btrfs_path *path,
1295 struct btrfs_extent_inline_ref *iref)
15916de8 1296{
5d4f98a2
YZ
1297 struct btrfs_key key;
1298 struct extent_buffer *leaf;
1299 struct btrfs_extent_data_ref *ref1;
1300 struct btrfs_shared_data_ref *ref2;
1301 u32 num_refs = 0;
1302
1303 leaf = path->nodes[0];
1304 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1305 if (iref) {
1306 if (btrfs_extent_inline_ref_type(leaf, iref) ==
1307 BTRFS_EXTENT_DATA_REF_KEY) {
1308 ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
1309 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1310 } else {
1311 ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
1312 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1313 }
1314 } else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1315 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1316 struct btrfs_extent_data_ref);
1317 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1318 } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1319 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1320 struct btrfs_shared_data_ref);
1321 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1322#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1323 } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1324 struct btrfs_extent_ref_v0 *ref0;
1325 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1326 struct btrfs_extent_ref_v0);
1327 num_refs = btrfs_ref_count_v0(leaf, ref0);
4b4e25f2 1328#endif
5d4f98a2
YZ
1329 } else {
1330 WARN_ON(1);
1331 }
1332 return num_refs;
1333}
15916de8 1334
5d4f98a2
YZ
1335static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
1336 struct btrfs_root *root,
1337 struct btrfs_path *path,
1338 u64 bytenr, u64 parent,
1339 u64 root_objectid)
1f3c79a2 1340{
5d4f98a2 1341 struct btrfs_key key;
1f3c79a2 1342 int ret;
1f3c79a2 1343
5d4f98a2
YZ
1344 key.objectid = bytenr;
1345 if (parent) {
1346 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1347 key.offset = parent;
1348 } else {
1349 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1350 key.offset = root_objectid;
1f3c79a2
LH
1351 }
1352
5d4f98a2
YZ
1353 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1354 if (ret > 0)
1355 ret = -ENOENT;
1356#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1357 if (ret == -ENOENT && parent) {
b3b4aa74 1358 btrfs_release_path(path);
5d4f98a2
YZ
1359 key.type = BTRFS_EXTENT_REF_V0_KEY;
1360 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1361 if (ret > 0)
1362 ret = -ENOENT;
1363 }
1f3c79a2 1364#endif
5d4f98a2 1365 return ret;
1f3c79a2
LH
1366}
1367
5d4f98a2
YZ
1368static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
1369 struct btrfs_root *root,
1370 struct btrfs_path *path,
1371 u64 bytenr, u64 parent,
1372 u64 root_objectid)
31840ae1 1373{
5d4f98a2 1374 struct btrfs_key key;
31840ae1 1375 int ret;
31840ae1 1376
5d4f98a2
YZ
1377 key.objectid = bytenr;
1378 if (parent) {
1379 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1380 key.offset = parent;
1381 } else {
1382 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1383 key.offset = root_objectid;
1384 }
1385
1386 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
b3b4aa74 1387 btrfs_release_path(path);
31840ae1
ZY
1388 return ret;
1389}
1390
5d4f98a2 1391static inline int extent_ref_type(u64 parent, u64 owner)
31840ae1 1392{
5d4f98a2
YZ
1393 int type;
1394 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1395 if (parent > 0)
1396 type = BTRFS_SHARED_BLOCK_REF_KEY;
1397 else
1398 type = BTRFS_TREE_BLOCK_REF_KEY;
1399 } else {
1400 if (parent > 0)
1401 type = BTRFS_SHARED_DATA_REF_KEY;
1402 else
1403 type = BTRFS_EXTENT_DATA_REF_KEY;
1404 }
1405 return type;
31840ae1 1406}
56bec294 1407
2c47e605
YZ
1408static int find_next_key(struct btrfs_path *path, int level,
1409 struct btrfs_key *key)
56bec294 1410
02217ed2 1411{
2c47e605 1412 for (; level < BTRFS_MAX_LEVEL; level++) {
5d4f98a2
YZ
1413 if (!path->nodes[level])
1414 break;
5d4f98a2
YZ
1415 if (path->slots[level] + 1 >=
1416 btrfs_header_nritems(path->nodes[level]))
1417 continue;
1418 if (level == 0)
1419 btrfs_item_key_to_cpu(path->nodes[level], key,
1420 path->slots[level] + 1);
1421 else
1422 btrfs_node_key_to_cpu(path->nodes[level], key,
1423 path->slots[level] + 1);
1424 return 0;
1425 }
1426 return 1;
1427}
037e6390 1428
5d4f98a2
YZ
1429/*
1430 * look for inline back ref. if back ref is found, *ref_ret is set
1431 * to the address of inline back ref, and 0 is returned.
1432 *
1433 * if back ref isn't found, *ref_ret is set to the address where it
1434 * should be inserted, and -ENOENT is returned.
1435 *
1436 * if insert is true and there are too many inline back refs, the path
1437 * points to the extent item, and -EAGAIN is returned.
1438 *
1439 * NOTE: inline back refs are ordered in the same way that back ref
1440 * items in the tree are ordered.
1441 */
1442static noinline_for_stack
1443int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
1444 struct btrfs_root *root,
1445 struct btrfs_path *path,
1446 struct btrfs_extent_inline_ref **ref_ret,
1447 u64 bytenr, u64 num_bytes,
1448 u64 parent, u64 root_objectid,
1449 u64 owner, u64 offset, int insert)
1450{
1451 struct btrfs_key key;
1452 struct extent_buffer *leaf;
1453 struct btrfs_extent_item *ei;
1454 struct btrfs_extent_inline_ref *iref;
1455 u64 flags;
1456 u64 item_size;
1457 unsigned long ptr;
1458 unsigned long end;
1459 int extra_size;
1460 int type;
1461 int want;
1462 int ret;
1463 int err = 0;
26b8003f 1464
db94535d 1465 key.objectid = bytenr;
31840ae1 1466 key.type = BTRFS_EXTENT_ITEM_KEY;
56bec294 1467 key.offset = num_bytes;
31840ae1 1468
5d4f98a2
YZ
1469 want = extent_ref_type(parent, owner);
1470 if (insert) {
1471 extra_size = btrfs_extent_inline_ref_size(want);
85d4198e 1472 path->keep_locks = 1;
5d4f98a2
YZ
1473 } else
1474 extra_size = -1;
1475 ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
b9473439 1476 if (ret < 0) {
5d4f98a2
YZ
1477 err = ret;
1478 goto out;
1479 }
79787eaa
JM
1480 if (ret && !insert) {
1481 err = -ENOENT;
1482 goto out;
1483 }
1484 BUG_ON(ret); /* Corruption */
5d4f98a2
YZ
1485
1486 leaf = path->nodes[0];
1487 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1488#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1489 if (item_size < sizeof(*ei)) {
1490 if (!insert) {
1491 err = -ENOENT;
1492 goto out;
1493 }
1494 ret = convert_extent_item_v0(trans, root, path, owner,
1495 extra_size);
1496 if (ret < 0) {
1497 err = ret;
1498 goto out;
1499 }
1500 leaf = path->nodes[0];
1501 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1502 }
1503#endif
1504 BUG_ON(item_size < sizeof(*ei));
1505
5d4f98a2
YZ
1506 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1507 flags = btrfs_extent_flags(leaf, ei);
1508
1509 ptr = (unsigned long)(ei + 1);
1510 end = (unsigned long)ei + item_size;
1511
1512 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1513 ptr += sizeof(struct btrfs_tree_block_info);
1514 BUG_ON(ptr > end);
1515 } else {
1516 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
1517 }
1518
1519 err = -ENOENT;
1520 while (1) {
1521 if (ptr >= end) {
1522 WARN_ON(ptr > end);
1523 break;
1524 }
1525 iref = (struct btrfs_extent_inline_ref *)ptr;
1526 type = btrfs_extent_inline_ref_type(leaf, iref);
1527 if (want < type)
1528 break;
1529 if (want > type) {
1530 ptr += btrfs_extent_inline_ref_size(type);
1531 continue;
1532 }
1533
1534 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1535 struct btrfs_extent_data_ref *dref;
1536 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1537 if (match_extent_data_ref(leaf, dref, root_objectid,
1538 owner, offset)) {
1539 err = 0;
1540 break;
1541 }
1542 if (hash_extent_data_ref_item(leaf, dref) <
1543 hash_extent_data_ref(root_objectid, owner, offset))
1544 break;
1545 } else {
1546 u64 ref_offset;
1547 ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1548 if (parent > 0) {
1549 if (parent == ref_offset) {
1550 err = 0;
1551 break;
1552 }
1553 if (ref_offset < parent)
1554 break;
1555 } else {
1556 if (root_objectid == ref_offset) {
1557 err = 0;
1558 break;
1559 }
1560 if (ref_offset < root_objectid)
1561 break;
1562 }
1563 }
1564 ptr += btrfs_extent_inline_ref_size(type);
1565 }
1566 if (err == -ENOENT && insert) {
1567 if (item_size + extra_size >=
1568 BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
1569 err = -EAGAIN;
1570 goto out;
1571 }
1572 /*
1573 * To add new inline back ref, we have to make sure
1574 * there is no corresponding back ref item.
1575 * For simplicity, we just do not add new inline back
1576 * ref if there is any kind of item for this block
1577 */
2c47e605
YZ
1578 if (find_next_key(path, 0, &key) == 0 &&
1579 key.objectid == bytenr &&
85d4198e 1580 key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
5d4f98a2
YZ
1581 err = -EAGAIN;
1582 goto out;
1583 }
1584 }
1585 *ref_ret = (struct btrfs_extent_inline_ref *)ptr;
1586out:
85d4198e 1587 if (insert) {
5d4f98a2
YZ
1588 path->keep_locks = 0;
1589 btrfs_unlock_up_safe(path, 1);
1590 }
1591 return err;
1592}
1593
1594/*
1595 * helper to add new inline back ref
1596 */
1597static noinline_for_stack
143bede5
JM
1598void setup_inline_extent_backref(struct btrfs_trans_handle *trans,
1599 struct btrfs_root *root,
1600 struct btrfs_path *path,
1601 struct btrfs_extent_inline_ref *iref,
1602 u64 parent, u64 root_objectid,
1603 u64 owner, u64 offset, int refs_to_add,
1604 struct btrfs_delayed_extent_op *extent_op)
5d4f98a2
YZ
1605{
1606 struct extent_buffer *leaf;
1607 struct btrfs_extent_item *ei;
1608 unsigned long ptr;
1609 unsigned long end;
1610 unsigned long item_offset;
1611 u64 refs;
1612 int size;
1613 int type;
5d4f98a2
YZ
1614
1615 leaf = path->nodes[0];
1616 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1617 item_offset = (unsigned long)iref - (unsigned long)ei;
1618
1619 type = extent_ref_type(parent, owner);
1620 size = btrfs_extent_inline_ref_size(type);
1621
143bede5 1622 btrfs_extend_item(trans, root, path, size);
5d4f98a2
YZ
1623
1624 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1625 refs = btrfs_extent_refs(leaf, ei);
1626 refs += refs_to_add;
1627 btrfs_set_extent_refs(leaf, ei, refs);
1628 if (extent_op)
1629 __run_delayed_extent_op(extent_op, leaf, ei);
1630
1631 ptr = (unsigned long)ei + item_offset;
1632 end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
1633 if (ptr < end - size)
1634 memmove_extent_buffer(leaf, ptr + size, ptr,
1635 end - size - ptr);
1636
1637 iref = (struct btrfs_extent_inline_ref *)ptr;
1638 btrfs_set_extent_inline_ref_type(leaf, iref, type);
1639 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1640 struct btrfs_extent_data_ref *dref;
1641 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1642 btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
1643 btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
1644 btrfs_set_extent_data_ref_offset(leaf, dref, offset);
1645 btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
1646 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1647 struct btrfs_shared_data_ref *sref;
1648 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1649 btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
1650 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1651 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
1652 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1653 } else {
1654 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
1655 }
1656 btrfs_mark_buffer_dirty(leaf);
5d4f98a2
YZ
1657}
1658
1659static int lookup_extent_backref(struct btrfs_trans_handle *trans,
1660 struct btrfs_root *root,
1661 struct btrfs_path *path,
1662 struct btrfs_extent_inline_ref **ref_ret,
1663 u64 bytenr, u64 num_bytes, u64 parent,
1664 u64 root_objectid, u64 owner, u64 offset)
1665{
1666 int ret;
1667
1668 ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
1669 bytenr, num_bytes, parent,
1670 root_objectid, owner, offset, 0);
1671 if (ret != -ENOENT)
54aa1f4d 1672 return ret;
5d4f98a2 1673
b3b4aa74 1674 btrfs_release_path(path);
5d4f98a2
YZ
1675 *ref_ret = NULL;
1676
1677 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1678 ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
1679 root_objectid);
1680 } else {
1681 ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
1682 root_objectid, owner, offset);
b9473439 1683 }
5d4f98a2
YZ
1684 return ret;
1685}
31840ae1 1686
5d4f98a2
YZ
1687/*
1688 * helper to update/remove inline back ref
1689 */
1690static noinline_for_stack
143bede5
JM
1691void update_inline_extent_backref(struct btrfs_trans_handle *trans,
1692 struct btrfs_root *root,
1693 struct btrfs_path *path,
1694 struct btrfs_extent_inline_ref *iref,
1695 int refs_to_mod,
1696 struct btrfs_delayed_extent_op *extent_op)
5d4f98a2
YZ
1697{
1698 struct extent_buffer *leaf;
1699 struct btrfs_extent_item *ei;
1700 struct btrfs_extent_data_ref *dref = NULL;
1701 struct btrfs_shared_data_ref *sref = NULL;
1702 unsigned long ptr;
1703 unsigned long end;
1704 u32 item_size;
1705 int size;
1706 int type;
5d4f98a2
YZ
1707 u64 refs;
1708
1709 leaf = path->nodes[0];
1710 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1711 refs = btrfs_extent_refs(leaf, ei);
1712 WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
1713 refs += refs_to_mod;
1714 btrfs_set_extent_refs(leaf, ei, refs);
1715 if (extent_op)
1716 __run_delayed_extent_op(extent_op, leaf, ei);
1717
1718 type = btrfs_extent_inline_ref_type(leaf, iref);
1719
1720 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1721 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1722 refs = btrfs_extent_data_ref_count(leaf, dref);
1723 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1724 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1725 refs = btrfs_shared_data_ref_count(leaf, sref);
1726 } else {
1727 refs = 1;
1728 BUG_ON(refs_to_mod != -1);
56bec294 1729 }
31840ae1 1730
5d4f98a2
YZ
1731 BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
1732 refs += refs_to_mod;
1733
1734 if (refs > 0) {
1735 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1736 btrfs_set_extent_data_ref_count(leaf, dref, refs);
1737 else
1738 btrfs_set_shared_data_ref_count(leaf, sref, refs);
1739 } else {
1740 size = btrfs_extent_inline_ref_size(type);
1741 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1742 ptr = (unsigned long)iref;
1743 end = (unsigned long)ei + item_size;
1744 if (ptr + size < end)
1745 memmove_extent_buffer(leaf, ptr, ptr + size,
1746 end - ptr - size);
1747 item_size -= size;
143bede5 1748 btrfs_truncate_item(trans, root, path, item_size, 1);
5d4f98a2
YZ
1749 }
1750 btrfs_mark_buffer_dirty(leaf);
5d4f98a2
YZ
1751}
1752
1753static noinline_for_stack
1754int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
1755 struct btrfs_root *root,
1756 struct btrfs_path *path,
1757 u64 bytenr, u64 num_bytes, u64 parent,
1758 u64 root_objectid, u64 owner,
1759 u64 offset, int refs_to_add,
1760 struct btrfs_delayed_extent_op *extent_op)
1761{
1762 struct btrfs_extent_inline_ref *iref;
1763 int ret;
1764
1765 ret = lookup_inline_extent_backref(trans, root, path, &iref,
1766 bytenr, num_bytes, parent,
1767 root_objectid, owner, offset, 1);
1768 if (ret == 0) {
1769 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
143bede5
JM
1770 update_inline_extent_backref(trans, root, path, iref,
1771 refs_to_add, extent_op);
5d4f98a2 1772 } else if (ret == -ENOENT) {
143bede5
JM
1773 setup_inline_extent_backref(trans, root, path, iref, parent,
1774 root_objectid, owner, offset,
1775 refs_to_add, extent_op);
1776 ret = 0;
771ed689 1777 }
5d4f98a2
YZ
1778 return ret;
1779}
31840ae1 1780
5d4f98a2
YZ
1781static int insert_extent_backref(struct btrfs_trans_handle *trans,
1782 struct btrfs_root *root,
1783 struct btrfs_path *path,
1784 u64 bytenr, u64 parent, u64 root_objectid,
1785 u64 owner, u64 offset, int refs_to_add)
1786{
1787 int ret;
1788 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1789 BUG_ON(refs_to_add != 1);
1790 ret = insert_tree_block_ref(trans, root, path, bytenr,
1791 parent, root_objectid);
1792 } else {
1793 ret = insert_extent_data_ref(trans, root, path, bytenr,
1794 parent, root_objectid,
1795 owner, offset, refs_to_add);
1796 }
1797 return ret;
1798}
56bec294 1799
5d4f98a2
YZ
1800static int remove_extent_backref(struct btrfs_trans_handle *trans,
1801 struct btrfs_root *root,
1802 struct btrfs_path *path,
1803 struct btrfs_extent_inline_ref *iref,
1804 int refs_to_drop, int is_data)
1805{
143bede5 1806 int ret = 0;
b9473439 1807
5d4f98a2
YZ
1808 BUG_ON(!is_data && refs_to_drop != 1);
1809 if (iref) {
143bede5
JM
1810 update_inline_extent_backref(trans, root, path, iref,
1811 -refs_to_drop, NULL);
5d4f98a2
YZ
1812 } else if (is_data) {
1813 ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
1814 } else {
1815 ret = btrfs_del_item(trans, root, path);
1816 }
1817 return ret;
1818}
1819
5378e607 1820static int btrfs_issue_discard(struct block_device *bdev,
5d4f98a2
YZ
1821 u64 start, u64 len)
1822{
5378e607 1823 return blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_NOFS, 0);
5d4f98a2 1824}
5d4f98a2
YZ
1825
1826static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
5378e607 1827 u64 num_bytes, u64 *actual_bytes)
5d4f98a2 1828{
5d4f98a2 1829 int ret;
5378e607 1830 u64 discarded_bytes = 0;
a1d3c478 1831 struct btrfs_bio *bbio = NULL;
5d4f98a2 1832
e244a0ae 1833
5d4f98a2 1834 /* Tell the block device(s) that the sectors can be discarded */
5378e607 1835 ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD,
a1d3c478 1836 bytenr, &num_bytes, &bbio, 0);
79787eaa 1837 /* Error condition is -ENOMEM */
5d4f98a2 1838 if (!ret) {
a1d3c478 1839 struct btrfs_bio_stripe *stripe = bbio->stripes;
5d4f98a2
YZ
1840 int i;
1841
5d4f98a2 1842
a1d3c478 1843 for (i = 0; i < bbio->num_stripes; i++, stripe++) {
d5e2003c
JB
1844 if (!stripe->dev->can_discard)
1845 continue;
1846
5378e607
LD
1847 ret = btrfs_issue_discard(stripe->dev->bdev,
1848 stripe->physical,
1849 stripe->length);
1850 if (!ret)
1851 discarded_bytes += stripe->length;
1852 else if (ret != -EOPNOTSUPP)
79787eaa 1853 break; /* Logic errors or -ENOMEM, or -EIO but I don't know how that could happen JDM */
d5e2003c
JB
1854
1855 /*
1856 * Just in case we get back EOPNOTSUPP for some reason,
1857 * just ignore the return value so we don't screw up
1858 * people calling discard_extent.
1859 */
1860 ret = 0;
5d4f98a2 1861 }
a1d3c478 1862 kfree(bbio);
5d4f98a2 1863 }
5378e607
LD
1864
1865 if (actual_bytes)
1866 *actual_bytes = discarded_bytes;
1867
5d4f98a2
YZ
1868
1869 return ret;
5d4f98a2
YZ
1870}
1871
79787eaa 1872/* Can return -ENOMEM */
5d4f98a2
YZ
1873int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1874 struct btrfs_root *root,
1875 u64 bytenr, u64 num_bytes, u64 parent,
66d7e7f0 1876 u64 root_objectid, u64 owner, u64 offset, int for_cow)
5d4f98a2
YZ
1877{
1878 int ret;
66d7e7f0
AJ
1879 struct btrfs_fs_info *fs_info = root->fs_info;
1880
5d4f98a2
YZ
1881 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
1882 root_objectid == BTRFS_TREE_LOG_OBJECTID);
1883
1884 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
66d7e7f0
AJ
1885 ret = btrfs_add_delayed_tree_ref(fs_info, trans, bytenr,
1886 num_bytes,
5d4f98a2 1887 parent, root_objectid, (int)owner,
66d7e7f0 1888 BTRFS_ADD_DELAYED_REF, NULL, for_cow);
5d4f98a2 1889 } else {
66d7e7f0
AJ
1890 ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr,
1891 num_bytes,
5d4f98a2 1892 parent, root_objectid, owner, offset,
66d7e7f0 1893 BTRFS_ADD_DELAYED_REF, NULL, for_cow);
5d4f98a2
YZ
1894 }
1895 return ret;
1896}
1897
1898static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1899 struct btrfs_root *root,
1900 u64 bytenr, u64 num_bytes,
1901 u64 parent, u64 root_objectid,
1902 u64 owner, u64 offset, int refs_to_add,
1903 struct btrfs_delayed_extent_op *extent_op)
1904{
1905 struct btrfs_path *path;
1906 struct extent_buffer *leaf;
1907 struct btrfs_extent_item *item;
1908 u64 refs;
1909 int ret;
1910 int err = 0;
1911
1912 path = btrfs_alloc_path();
1913 if (!path)
1914 return -ENOMEM;
1915
1916 path->reada = 1;
1917 path->leave_spinning = 1;
1918 /* this will setup the path even if it fails to insert the back ref */
1919 ret = insert_inline_extent_backref(trans, root->fs_info->extent_root,
1920 path, bytenr, num_bytes, parent,
1921 root_objectid, owner, offset,
1922 refs_to_add, extent_op);
1923 if (ret == 0)
1924 goto out;
1925
1926 if (ret != -EAGAIN) {
1927 err = ret;
1928 goto out;
1929 }
1930
1931 leaf = path->nodes[0];
1932 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1933 refs = btrfs_extent_refs(leaf, item);
1934 btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
1935 if (extent_op)
1936 __run_delayed_extent_op(extent_op, leaf, item);
56bec294 1937
5d4f98a2 1938 btrfs_mark_buffer_dirty(leaf);
b3b4aa74 1939 btrfs_release_path(path);
56bec294
CM
1940
1941 path->reada = 1;
b9473439
CM
1942 path->leave_spinning = 1;
1943
56bec294
CM
1944 /* now insert the actual backref */
1945 ret = insert_extent_backref(trans, root->fs_info->extent_root,
5d4f98a2
YZ
1946 path, bytenr, parent, root_objectid,
1947 owner, offset, refs_to_add);
79787eaa
JM
1948 if (ret)
1949 btrfs_abort_transaction(trans, root, ret);
5d4f98a2 1950out:
56bec294 1951 btrfs_free_path(path);
5d4f98a2 1952 return err;
56bec294
CM
1953}
1954
5d4f98a2
YZ
1955static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
1956 struct btrfs_root *root,
1957 struct btrfs_delayed_ref_node *node,
1958 struct btrfs_delayed_extent_op *extent_op,
1959 int insert_reserved)
56bec294 1960{
5d4f98a2
YZ
1961 int ret = 0;
1962 struct btrfs_delayed_data_ref *ref;
1963 struct btrfs_key ins;
1964 u64 parent = 0;
1965 u64 ref_root = 0;
1966 u64 flags = 0;
1967
1968 ins.objectid = node->bytenr;
1969 ins.offset = node->num_bytes;
1970 ins.type = BTRFS_EXTENT_ITEM_KEY;
1971
1972 ref = btrfs_delayed_node_to_data_ref(node);
1973 if (node->type == BTRFS_SHARED_DATA_REF_KEY)
1974 parent = ref->parent;
1975 else
1976 ref_root = ref->root;
1977
1978 if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1979 if (extent_op) {
1980 BUG_ON(extent_op->update_key);
1981 flags |= extent_op->flags_to_set;
1982 }
1983 ret = alloc_reserved_file_extent(trans, root,
1984 parent, ref_root, flags,
1985 ref->objectid, ref->offset,
1986 &ins, node->ref_mod);
5d4f98a2
YZ
1987 } else if (node->action == BTRFS_ADD_DELAYED_REF) {
1988 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
1989 node->num_bytes, parent,
1990 ref_root, ref->objectid,
1991 ref->offset, node->ref_mod,
1992 extent_op);
1993 } else if (node->action == BTRFS_DROP_DELAYED_REF) {
1994 ret = __btrfs_free_extent(trans, root, node->bytenr,
1995 node->num_bytes, parent,
1996 ref_root, ref->objectid,
1997 ref->offset, node->ref_mod,
1998 extent_op);
1999 } else {
2000 BUG();
2001 }
2002 return ret;
2003}
2004
2005static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
2006 struct extent_buffer *leaf,
2007 struct btrfs_extent_item *ei)
2008{
2009 u64 flags = btrfs_extent_flags(leaf, ei);
2010 if (extent_op->update_flags) {
2011 flags |= extent_op->flags_to_set;
2012 btrfs_set_extent_flags(leaf, ei, flags);
2013 }
2014
2015 if (extent_op->update_key) {
2016 struct btrfs_tree_block_info *bi;
2017 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
2018 bi = (struct btrfs_tree_block_info *)(ei + 1);
2019 btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
2020 }
2021}
2022
2023static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
2024 struct btrfs_root *root,
2025 struct btrfs_delayed_ref_node *node,
2026 struct btrfs_delayed_extent_op *extent_op)
2027{
2028 struct btrfs_key key;
2029 struct btrfs_path *path;
2030 struct btrfs_extent_item *ei;
2031 struct extent_buffer *leaf;
2032 u32 item_size;
56bec294 2033 int ret;
5d4f98a2
YZ
2034 int err = 0;
2035
79787eaa
JM
2036 if (trans->aborted)
2037 return 0;
2038
5d4f98a2
YZ
2039 path = btrfs_alloc_path();
2040 if (!path)
2041 return -ENOMEM;
2042
2043 key.objectid = node->bytenr;
2044 key.type = BTRFS_EXTENT_ITEM_KEY;
2045 key.offset = node->num_bytes;
2046
2047 path->reada = 1;
2048 path->leave_spinning = 1;
2049 ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key,
2050 path, 0, 1);
2051 if (ret < 0) {
2052 err = ret;
2053 goto out;
2054 }
2055 if (ret > 0) {
2056 err = -EIO;
2057 goto out;
2058 }
2059
2060 leaf = path->nodes[0];
2061 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2062#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2063 if (item_size < sizeof(*ei)) {
2064 ret = convert_extent_item_v0(trans, root->fs_info->extent_root,
2065 path, (u64)-1, 0);
2066 if (ret < 0) {
2067 err = ret;
2068 goto out;
2069 }
2070 leaf = path->nodes[0];
2071 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2072 }
2073#endif
2074 BUG_ON(item_size < sizeof(*ei));
2075 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2076 __run_delayed_extent_op(extent_op, leaf, ei);
56bec294 2077
5d4f98a2
YZ
2078 btrfs_mark_buffer_dirty(leaf);
2079out:
2080 btrfs_free_path(path);
2081 return err;
56bec294
CM
2082}
2083
5d4f98a2
YZ
2084static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
2085 struct btrfs_root *root,
2086 struct btrfs_delayed_ref_node *node,
2087 struct btrfs_delayed_extent_op *extent_op,
2088 int insert_reserved)
56bec294
CM
2089{
2090 int ret = 0;
5d4f98a2
YZ
2091 struct btrfs_delayed_tree_ref *ref;
2092 struct btrfs_key ins;
2093 u64 parent = 0;
2094 u64 ref_root = 0;
56bec294 2095
5d4f98a2
YZ
2096 ins.objectid = node->bytenr;
2097 ins.offset = node->num_bytes;
2098 ins.type = BTRFS_EXTENT_ITEM_KEY;
56bec294 2099
5d4f98a2
YZ
2100 ref = btrfs_delayed_node_to_tree_ref(node);
2101 if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2102 parent = ref->parent;
2103 else
2104 ref_root = ref->root;
2105
2106 BUG_ON(node->ref_mod != 1);
2107 if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
2108 BUG_ON(!extent_op || !extent_op->update_flags ||
2109 !extent_op->update_key);
2110 ret = alloc_reserved_tree_block(trans, root,
2111 parent, ref_root,
2112 extent_op->flags_to_set,
2113 &extent_op->key,
2114 ref->level, &ins);
5d4f98a2
YZ
2115 } else if (node->action == BTRFS_ADD_DELAYED_REF) {
2116 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
2117 node->num_bytes, parent, ref_root,
2118 ref->level, 0, 1, extent_op);
2119 } else if (node->action == BTRFS_DROP_DELAYED_REF) {
2120 ret = __btrfs_free_extent(trans, root, node->bytenr,
2121 node->num_bytes, parent, ref_root,
2122 ref->level, 0, 1, extent_op);
2123 } else {
2124 BUG();
2125 }
56bec294
CM
2126 return ret;
2127}
2128
2129/* helper function to actually process a single delayed ref entry */
5d4f98a2
YZ
2130static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
2131 struct btrfs_root *root,
2132 struct btrfs_delayed_ref_node *node,
2133 struct btrfs_delayed_extent_op *extent_op,
2134 int insert_reserved)
56bec294 2135{
79787eaa
JM
2136 int ret = 0;
2137
2138 if (trans->aborted)
2139 return 0;
2140
5d4f98a2 2141 if (btrfs_delayed_ref_is_head(node)) {
56bec294
CM
2142 struct btrfs_delayed_ref_head *head;
2143 /*
2144 * we've hit the end of the chain and we were supposed
2145 * to insert this extent into the tree. But, it got
2146 * deleted before we ever needed to insert it, so all
2147 * we have to do is clean up the accounting
2148 */
5d4f98a2
YZ
2149 BUG_ON(extent_op);
2150 head = btrfs_delayed_node_to_head(node);
56bec294 2151 if (insert_reserved) {
f0486c68
YZ
2152 btrfs_pin_extent(root, node->bytenr,
2153 node->num_bytes, 1);
5d4f98a2
YZ
2154 if (head->is_data) {
2155 ret = btrfs_del_csums(trans, root,
2156 node->bytenr,
2157 node->num_bytes);
5d4f98a2 2158 }
56bec294 2159 }
56bec294 2160 mutex_unlock(&head->mutex);
79787eaa 2161 return ret;
56bec294
CM
2162 }
2163
5d4f98a2
YZ
2164 if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
2165 node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2166 ret = run_delayed_tree_ref(trans, root, node, extent_op,
2167 insert_reserved);
2168 else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
2169 node->type == BTRFS_SHARED_DATA_REF_KEY)
2170 ret = run_delayed_data_ref(trans, root, node, extent_op,
2171 insert_reserved);
2172 else
2173 BUG();
2174 return ret;
56bec294
CM
2175}
2176
2177static noinline struct btrfs_delayed_ref_node *
2178select_delayed_ref(struct btrfs_delayed_ref_head *head)
2179{
2180 struct rb_node *node;
2181 struct btrfs_delayed_ref_node *ref;
2182 int action = BTRFS_ADD_DELAYED_REF;
2183again:
2184 /*
2185 * select delayed ref of type BTRFS_ADD_DELAYED_REF first.
2186 * this prevents ref count from going down to zero when
2187 * there still are pending delayed ref.
2188 */
2189 node = rb_prev(&head->node.rb_node);
2190 while (1) {
2191 if (!node)
2192 break;
2193 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2194 rb_node);
2195 if (ref->bytenr != head->node.bytenr)
2196 break;
5d4f98a2 2197 if (ref->action == action)
56bec294
CM
2198 return ref;
2199 node = rb_prev(node);
2200 }
2201 if (action == BTRFS_ADD_DELAYED_REF) {
2202 action = BTRFS_DROP_DELAYED_REF;
2203 goto again;
2204 }
2205 return NULL;
2206}
2207
79787eaa
JM
2208/*
2209 * Returns 0 on success or if called with an already aborted transaction.
2210 * Returns -ENOMEM or -EIO on failure and will abort the transaction.
2211 */
c3e69d58
CM
2212static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
2213 struct btrfs_root *root,
2214 struct list_head *cluster)
56bec294 2215{
56bec294
CM
2216 struct btrfs_delayed_ref_root *delayed_refs;
2217 struct btrfs_delayed_ref_node *ref;
2218 struct btrfs_delayed_ref_head *locked_ref = NULL;
5d4f98a2 2219 struct btrfs_delayed_extent_op *extent_op;
56bec294 2220 int ret;
c3e69d58 2221 int count = 0;
56bec294 2222 int must_insert_reserved = 0;
56bec294
CM
2223
2224 delayed_refs = &trans->transaction->delayed_refs;
56bec294
CM
2225 while (1) {
2226 if (!locked_ref) {
c3e69d58
CM
2227 /* pick a new head ref from the cluster list */
2228 if (list_empty(cluster))
56bec294 2229 break;
56bec294 2230
c3e69d58
CM
2231 locked_ref = list_entry(cluster->next,
2232 struct btrfs_delayed_ref_head, cluster);
2233
2234 /* grab the lock that says we are going to process
2235 * all the refs for this head */
2236 ret = btrfs_delayed_ref_lock(trans, locked_ref);
2237
2238 /*
2239 * we may have dropped the spin lock to get the head
2240 * mutex lock, and that might have given someone else
2241 * time to free the head. If that's true, it has been
2242 * removed from our list and we can move on.
2243 */
2244 if (ret == -EAGAIN) {
2245 locked_ref = NULL;
2246 count++;
2247 continue;
56bec294
CM
2248 }
2249 }
a28ec197 2250
d1270cd9
AJ
2251 /*
2252 * locked_ref is the head node, so we have to go one
2253 * node back for any delayed ref updates
2254 */
2255 ref = select_delayed_ref(locked_ref);
2256
2257 if (ref && ref->seq &&
2258 btrfs_check_delayed_seq(delayed_refs, ref->seq)) {
2259 /*
2260 * there are still refs with lower seq numbers in the
2261 * process of being added. Don't run this ref yet.
2262 */
2263 list_del_init(&locked_ref->cluster);
2264 mutex_unlock(&locked_ref->mutex);
2265 locked_ref = NULL;
2266 delayed_refs->num_heads_ready++;
2267 spin_unlock(&delayed_refs->lock);
2268 cond_resched();
2269 spin_lock(&delayed_refs->lock);
2270 continue;
2271 }
2272
56bec294
CM
2273 /*
2274 * record the must insert reserved flag before we
2275 * drop the spin lock.
2276 */
2277 must_insert_reserved = locked_ref->must_insert_reserved;
2278 locked_ref->must_insert_reserved = 0;
7bb86316 2279
5d4f98a2
YZ
2280 extent_op = locked_ref->extent_op;
2281 locked_ref->extent_op = NULL;
2282
56bec294
CM
2283 if (!ref) {
2284 /* All delayed refs have been processed, Go ahead
2285 * and send the head node to run_one_delayed_ref,
2286 * so that any accounting fixes can happen
2287 */
2288 ref = &locked_ref->node;
5d4f98a2
YZ
2289
2290 if (extent_op && must_insert_reserved) {
2291 kfree(extent_op);
2292 extent_op = NULL;
2293 }
2294
2295 if (extent_op) {
2296 spin_unlock(&delayed_refs->lock);
2297
2298 ret = run_delayed_extent_op(trans, root,
2299 ref, extent_op);
5d4f98a2
YZ
2300 kfree(extent_op);
2301
79787eaa
JM
2302 if (ret) {
2303 printk(KERN_DEBUG "btrfs: run_delayed_extent_op returned %d\n", ret);
253beebd 2304 spin_lock(&delayed_refs->lock);
79787eaa
JM
2305 return ret;
2306 }
2307
203bf287 2308 goto next;
5d4f98a2
YZ
2309 }
2310
c3e69d58 2311 list_del_init(&locked_ref->cluster);
56bec294
CM
2312 locked_ref = NULL;
2313 }
02217ed2 2314
56bec294
CM
2315 ref->in_tree = 0;
2316 rb_erase(&ref->rb_node, &delayed_refs->root);
2317 delayed_refs->num_entries--;
a168650c
JS
2318 /*
2319 * we modified num_entries, but as we're currently running
2320 * delayed refs, skip
2321 * wake_up(&delayed_refs->seq_wait);
2322 * here.
2323 */
56bec294 2324 spin_unlock(&delayed_refs->lock);
925baedd 2325
5d4f98a2 2326 ret = run_one_delayed_ref(trans, root, ref, extent_op,
56bec294 2327 must_insert_reserved);
eb099670 2328
5d4f98a2
YZ
2329 btrfs_put_delayed_ref(ref);
2330 kfree(extent_op);
c3e69d58 2331 count++;
79787eaa
JM
2332
2333 if (ret) {
2334 printk(KERN_DEBUG "btrfs: run_one_delayed_ref returned %d\n", ret);
253beebd 2335 spin_lock(&delayed_refs->lock);
79787eaa
JM
2336 return ret;
2337 }
2338
203bf287
CM
2339next:
2340 do_chunk_alloc(trans, root->fs_info->extent_root,
2341 2 * 1024 * 1024,
2342 btrfs_get_alloc_profile(root, 0),
2343 CHUNK_ALLOC_NO_FORCE);
c3e69d58
CM
2344 cond_resched();
2345 spin_lock(&delayed_refs->lock);
2346 }
2347 return count;
2348}
2349
a168650c 2350static void wait_for_more_refs(struct btrfs_delayed_ref_root *delayed_refs,
8ca78f3e
JS
2351 unsigned long num_refs,
2352 struct list_head *first_seq)
a168650c 2353{
a168650c
JS
2354 spin_unlock(&delayed_refs->lock);
2355 pr_debug("waiting for more refs (num %ld, first %p)\n",
2356 num_refs, first_seq);
2357 wait_event(delayed_refs->seq_wait,
2358 num_refs != delayed_refs->num_entries ||
2359 delayed_refs->seq_head.next != first_seq);
2360 pr_debug("done waiting for more refs (num %ld, first %p)\n",
2361 delayed_refs->num_entries, delayed_refs->seq_head.next);
2362 spin_lock(&delayed_refs->lock);
2363}
2364
c3e69d58
CM
2365/*
2366 * this starts processing the delayed reference count updates and
2367 * extent insertions we have queued up so far. count can be
2368 * 0, which means to process everything in the tree at the start
2369 * of the run (but not newly added entries), or it can be some target
2370 * number you'd like to process.
79787eaa
JM
2371 *
2372 * Returns 0 on success or if called with an aborted transaction
2373 * Returns <0 on error and aborts the transaction
c3e69d58
CM
2374 */
2375int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2376 struct btrfs_root *root, unsigned long count)
2377{
2378 struct rb_node *node;
2379 struct btrfs_delayed_ref_root *delayed_refs;
2380 struct btrfs_delayed_ref_node *ref;
2381 struct list_head cluster;
8ca78f3e 2382 struct list_head *first_seq = NULL;
c3e69d58 2383 int ret;
a168650c 2384 u64 delayed_start;
c3e69d58
CM
2385 int run_all = count == (unsigned long)-1;
2386 int run_most = 0;
a168650c
JS
2387 unsigned long num_refs = 0;
2388 int consider_waiting;
c3e69d58 2389
79787eaa
JM
2390 /* We'll clean this up in btrfs_cleanup_transaction */
2391 if (trans->aborted)
2392 return 0;
2393
c3e69d58
CM
2394 if (root == root->fs_info->extent_root)
2395 root = root->fs_info->tree_root;
2396
203bf287
CM
2397 do_chunk_alloc(trans, root->fs_info->extent_root,
2398 2 * 1024 * 1024, btrfs_get_alloc_profile(root, 0),
2399 CHUNK_ALLOC_NO_FORCE);
2400
c3e69d58
CM
2401 delayed_refs = &trans->transaction->delayed_refs;
2402 INIT_LIST_HEAD(&cluster);
2403again:
a168650c 2404 consider_waiting = 0;
c3e69d58
CM
2405 spin_lock(&delayed_refs->lock);
2406 if (count == 0) {
2407 count = delayed_refs->num_entries * 2;
2408 run_most = 1;
2409 }
2410 while (1) {
2411 if (!(run_all || run_most) &&
2412 delayed_refs->num_heads_ready < 64)
2413 break;
eb099670 2414
56bec294 2415 /*
c3e69d58
CM
2416 * go find something we can process in the rbtree. We start at
2417 * the beginning of the tree, and then build a cluster
2418 * of refs to process starting at the first one we are able to
2419 * lock
56bec294 2420 */
a168650c 2421 delayed_start = delayed_refs->run_delayed_start;
c3e69d58
CM
2422 ret = btrfs_find_ref_cluster(trans, &cluster,
2423 delayed_refs->run_delayed_start);
2424 if (ret)
56bec294
CM
2425 break;
2426
a168650c
JS
2427 if (delayed_start >= delayed_refs->run_delayed_start) {
2428 if (consider_waiting == 0) {
2429 /*
2430 * btrfs_find_ref_cluster looped. let's do one
2431 * more cycle. if we don't run any delayed ref
2432 * during that cycle (because we can't because
2433 * all of them are blocked) and if the number of
2434 * refs doesn't change, we avoid busy waiting.
2435 */
2436 consider_waiting = 1;
2437 num_refs = delayed_refs->num_entries;
8ca78f3e 2438 first_seq = root->fs_info->tree_mod_seq_list.next;
a168650c 2439 } else {
8ca78f3e
JS
2440 wait_for_more_refs(delayed_refs,
2441 num_refs, first_seq);
a168650c
JS
2442 /*
2443 * after waiting, things have changed. we
2444 * dropped the lock and someone else might have
2445 * run some refs, built new clusters and so on.
2446 * therefore, we restart staleness detection.
2447 */
2448 consider_waiting = 0;
2449 }
2450 }
2451
c3e69d58 2452 ret = run_clustered_refs(trans, root, &cluster);
79787eaa
JM
2453 if (ret < 0) {
2454 spin_unlock(&delayed_refs->lock);
2455 btrfs_abort_transaction(trans, root, ret);
2456 return ret;
2457 }
c3e69d58
CM
2458
2459 count -= min_t(unsigned long, ret, count);
2460
2461 if (count == 0)
2462 break;
a168650c
JS
2463
2464 if (ret || delayed_refs->run_delayed_start == 0) {
2465 /* refs were run, let's reset staleness detection */
2466 consider_waiting = 0;
2467 }
eb099670 2468 }
c3e69d58 2469
56bec294 2470 if (run_all) {
56bec294 2471 node = rb_first(&delayed_refs->root);
c3e69d58 2472 if (!node)
56bec294 2473 goto out;
c3e69d58 2474 count = (unsigned long)-1;
e9d0b13b 2475
56bec294
CM
2476 while (node) {
2477 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2478 rb_node);
2479 if (btrfs_delayed_ref_is_head(ref)) {
2480 struct btrfs_delayed_ref_head *head;
5caf2a00 2481
56bec294
CM
2482 head = btrfs_delayed_node_to_head(ref);
2483 atomic_inc(&ref->refs);
2484
2485 spin_unlock(&delayed_refs->lock);
8cc33e5c
DS
2486 /*
2487 * Mutex was contended, block until it's
2488 * released and try again
2489 */
56bec294
CM
2490 mutex_lock(&head->mutex);
2491 mutex_unlock(&head->mutex);
2492
2493 btrfs_put_delayed_ref(ref);
1887be66 2494 cond_resched();
56bec294
CM
2495 goto again;
2496 }
2497 node = rb_next(node);
2498 }
2499 spin_unlock(&delayed_refs->lock);
56bec294
CM
2500 schedule_timeout(1);
2501 goto again;
5f39d397 2502 }
54aa1f4d 2503out:
c3e69d58 2504 spin_unlock(&delayed_refs->lock);
a28ec197
CM
2505 return 0;
2506}
2507
5d4f98a2
YZ
2508int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2509 struct btrfs_root *root,
2510 u64 bytenr, u64 num_bytes, u64 flags,
2511 int is_data)
2512{
2513 struct btrfs_delayed_extent_op *extent_op;
2514 int ret;
2515
2516 extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
2517 if (!extent_op)
2518 return -ENOMEM;
2519
2520 extent_op->flags_to_set = flags;
2521 extent_op->update_flags = 1;
2522 extent_op->update_key = 0;
2523 extent_op->is_data = is_data ? 1 : 0;
2524
66d7e7f0
AJ
2525 ret = btrfs_add_delayed_extent_op(root->fs_info, trans, bytenr,
2526 num_bytes, extent_op);
5d4f98a2
YZ
2527 if (ret)
2528 kfree(extent_op);
2529 return ret;
2530}
2531
2532static noinline int check_delayed_ref(struct btrfs_trans_handle *trans,
2533 struct btrfs_root *root,
2534 struct btrfs_path *path,
2535 u64 objectid, u64 offset, u64 bytenr)
2536{
2537 struct btrfs_delayed_ref_head *head;
2538 struct btrfs_delayed_ref_node *ref;
2539 struct btrfs_delayed_data_ref *data_ref;
2540 struct btrfs_delayed_ref_root *delayed_refs;
2541 struct rb_node *node;
2542 int ret = 0;
2543
2544 ret = -ENOENT;
2545 delayed_refs = &trans->transaction->delayed_refs;
2546 spin_lock(&delayed_refs->lock);
2547 head = btrfs_find_delayed_ref_head(trans, bytenr);
2548 if (!head)
2549 goto out;
2550
2551 if (!mutex_trylock(&head->mutex)) {
2552 atomic_inc(&head->node.refs);
2553 spin_unlock(&delayed_refs->lock);
2554
b3b4aa74 2555 btrfs_release_path(path);
5d4f98a2 2556
8cc33e5c
DS
2557 /*
2558 * Mutex was contended, block until it's released and let
2559 * caller try again
2560 */
5d4f98a2
YZ
2561 mutex_lock(&head->mutex);
2562 mutex_unlock(&head->mutex);
2563 btrfs_put_delayed_ref(&head->node);
2564 return -EAGAIN;
2565 }
2566
2567 node = rb_prev(&head->node.rb_node);
2568 if (!node)
2569 goto out_unlock;
2570
2571 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2572
2573 if (ref->bytenr != bytenr)
2574 goto out_unlock;
2575
2576 ret = 1;
2577 if (ref->type != BTRFS_EXTENT_DATA_REF_KEY)
2578 goto out_unlock;
2579
2580 data_ref = btrfs_delayed_node_to_data_ref(ref);
2581
2582 node = rb_prev(node);
2583 if (node) {
2584 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2585 if (ref->bytenr == bytenr)
2586 goto out_unlock;
2587 }
2588
2589 if (data_ref->root != root->root_key.objectid ||
2590 data_ref->objectid != objectid || data_ref->offset != offset)
2591 goto out_unlock;
2592
2593 ret = 0;
2594out_unlock:
2595 mutex_unlock(&head->mutex);
2596out:
2597 spin_unlock(&delayed_refs->lock);
2598 return ret;
2599}
2600
2601static noinline int check_committed_ref(struct btrfs_trans_handle *trans,
2602 struct btrfs_root *root,
2603 struct btrfs_path *path,
2604 u64 objectid, u64 offset, u64 bytenr)
be20aa9d
CM
2605{
2606 struct btrfs_root *extent_root = root->fs_info->extent_root;
f321e491 2607 struct extent_buffer *leaf;
5d4f98a2
YZ
2608 struct btrfs_extent_data_ref *ref;
2609 struct btrfs_extent_inline_ref *iref;
2610 struct btrfs_extent_item *ei;
f321e491 2611 struct btrfs_key key;
5d4f98a2 2612 u32 item_size;
be20aa9d 2613 int ret;
925baedd 2614
be20aa9d 2615 key.objectid = bytenr;
31840ae1 2616 key.offset = (u64)-1;
f321e491 2617 key.type = BTRFS_EXTENT_ITEM_KEY;
be20aa9d 2618
be20aa9d
CM
2619 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2620 if (ret < 0)
2621 goto out;
79787eaa 2622 BUG_ON(ret == 0); /* Corruption */
80ff3856
YZ
2623
2624 ret = -ENOENT;
2625 if (path->slots[0] == 0)
31840ae1 2626 goto out;
be20aa9d 2627
31840ae1 2628 path->slots[0]--;
f321e491 2629 leaf = path->nodes[0];
5d4f98a2 2630 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
be20aa9d 2631
5d4f98a2 2632 if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
be20aa9d 2633 goto out;
f321e491 2634
5d4f98a2
YZ
2635 ret = 1;
2636 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2637#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2638 if (item_size < sizeof(*ei)) {
2639 WARN_ON(item_size != sizeof(struct btrfs_extent_item_v0));
2640 goto out;
2641 }
2642#endif
2643 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
bd09835d 2644
5d4f98a2
YZ
2645 if (item_size != sizeof(*ei) +
2646 btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY))
2647 goto out;
be20aa9d 2648
5d4f98a2
YZ
2649 if (btrfs_extent_generation(leaf, ei) <=
2650 btrfs_root_last_snapshot(&root->root_item))
2651 goto out;
2652
2653 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2654 if (btrfs_extent_inline_ref_type(leaf, iref) !=
2655 BTRFS_EXTENT_DATA_REF_KEY)
2656 goto out;
2657
2658 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
2659 if (btrfs_extent_refs(leaf, ei) !=
2660 btrfs_extent_data_ref_count(leaf, ref) ||
2661 btrfs_extent_data_ref_root(leaf, ref) !=
2662 root->root_key.objectid ||
2663 btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
2664 btrfs_extent_data_ref_offset(leaf, ref) != offset)
2665 goto out;
2666
2667 ret = 0;
2668out:
2669 return ret;
2670}
2671
2672int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
2673 struct btrfs_root *root,
2674 u64 objectid, u64 offset, u64 bytenr)
2675{
2676 struct btrfs_path *path;
2677 int ret;
2678 int ret2;
2679
2680 path = btrfs_alloc_path();
2681 if (!path)
2682 return -ENOENT;
2683
2684 do {
2685 ret = check_committed_ref(trans, root, path, objectid,
2686 offset, bytenr);
2687 if (ret && ret != -ENOENT)
f321e491 2688 goto out;
80ff3856 2689
5d4f98a2
YZ
2690 ret2 = check_delayed_ref(trans, root, path, objectid,
2691 offset, bytenr);
2692 } while (ret2 == -EAGAIN);
2693
2694 if (ret2 && ret2 != -ENOENT) {
2695 ret = ret2;
2696 goto out;
f321e491 2697 }
5d4f98a2
YZ
2698
2699 if (ret != -ENOENT || ret2 != -ENOENT)
2700 ret = 0;
be20aa9d 2701out:
80ff3856 2702 btrfs_free_path(path);
f0486c68
YZ
2703 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
2704 WARN_ON(ret > 0);
f321e491 2705 return ret;
be20aa9d 2706}
c5739bba 2707
5d4f98a2 2708static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
b7a9f29f 2709 struct btrfs_root *root,
5d4f98a2 2710 struct extent_buffer *buf,
66d7e7f0 2711 int full_backref, int inc, int for_cow)
31840ae1
ZY
2712{
2713 u64 bytenr;
5d4f98a2
YZ
2714 u64 num_bytes;
2715 u64 parent;
31840ae1 2716 u64 ref_root;
31840ae1 2717 u32 nritems;
31840ae1
ZY
2718 struct btrfs_key key;
2719 struct btrfs_file_extent_item *fi;
2720 int i;
2721 int level;
2722 int ret = 0;
31840ae1 2723 int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
66d7e7f0 2724 u64, u64, u64, u64, u64, u64, int);
31840ae1
ZY
2725
2726 ref_root = btrfs_header_owner(buf);
31840ae1
ZY
2727 nritems = btrfs_header_nritems(buf);
2728 level = btrfs_header_level(buf);
2729
5d4f98a2
YZ
2730 if (!root->ref_cows && level == 0)
2731 return 0;
31840ae1 2732
5d4f98a2
YZ
2733 if (inc)
2734 process_func = btrfs_inc_extent_ref;
2735 else
2736 process_func = btrfs_free_extent;
31840ae1 2737
5d4f98a2
YZ
2738 if (full_backref)
2739 parent = buf->start;
2740 else
2741 parent = 0;
2742
2743 for (i = 0; i < nritems; i++) {
31840ae1 2744 if (level == 0) {
5d4f98a2 2745 btrfs_item_key_to_cpu(buf, &key, i);
31840ae1
ZY
2746 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2747 continue;
5d4f98a2 2748 fi = btrfs_item_ptr(buf, i,
31840ae1
ZY
2749 struct btrfs_file_extent_item);
2750 if (btrfs_file_extent_type(buf, fi) ==
2751 BTRFS_FILE_EXTENT_INLINE)
2752 continue;
2753 bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2754 if (bytenr == 0)
2755 continue;
5d4f98a2
YZ
2756
2757 num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
2758 key.offset -= btrfs_file_extent_offset(buf, fi);
2759 ret = process_func(trans, root, bytenr, num_bytes,
2760 parent, ref_root, key.objectid,
66d7e7f0 2761 key.offset, for_cow);
31840ae1
ZY
2762 if (ret)
2763 goto fail;
2764 } else {
5d4f98a2
YZ
2765 bytenr = btrfs_node_blockptr(buf, i);
2766 num_bytes = btrfs_level_size(root, level - 1);
2767 ret = process_func(trans, root, bytenr, num_bytes,
66d7e7f0
AJ
2768 parent, ref_root, level - 1, 0,
2769 for_cow);
31840ae1
ZY
2770 if (ret)
2771 goto fail;
2772 }
2773 }
2774 return 0;
2775fail:
5d4f98a2
YZ
2776 return ret;
2777}
2778
2779int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
66d7e7f0 2780 struct extent_buffer *buf, int full_backref, int for_cow)
5d4f98a2 2781{
66d7e7f0 2782 return __btrfs_mod_ref(trans, root, buf, full_backref, 1, for_cow);
5d4f98a2
YZ
2783}
2784
2785int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
66d7e7f0 2786 struct extent_buffer *buf, int full_backref, int for_cow)
5d4f98a2 2787{
66d7e7f0 2788 return __btrfs_mod_ref(trans, root, buf, full_backref, 0, for_cow);
31840ae1
ZY
2789}
2790
9078a3e1
CM
2791static int write_one_cache_group(struct btrfs_trans_handle *trans,
2792 struct btrfs_root *root,
2793 struct btrfs_path *path,
2794 struct btrfs_block_group_cache *cache)
2795{
2796 int ret;
9078a3e1 2797 struct btrfs_root *extent_root = root->fs_info->extent_root;
5f39d397
CM
2798 unsigned long bi;
2799 struct extent_buffer *leaf;
9078a3e1 2800
9078a3e1 2801 ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
54aa1f4d
CM
2802 if (ret < 0)
2803 goto fail;
79787eaa 2804 BUG_ON(ret); /* Corruption */
5f39d397
CM
2805
2806 leaf = path->nodes[0];
2807 bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
2808 write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
2809 btrfs_mark_buffer_dirty(leaf);
b3b4aa74 2810 btrfs_release_path(path);
54aa1f4d 2811fail:
79787eaa
JM
2812 if (ret) {
2813 btrfs_abort_transaction(trans, root, ret);
9078a3e1 2814 return ret;
79787eaa 2815 }
9078a3e1
CM
2816 return 0;
2817
2818}
2819
4a8c9a62
YZ
2820static struct btrfs_block_group_cache *
2821next_block_group(struct btrfs_root *root,
2822 struct btrfs_block_group_cache *cache)
2823{
2824 struct rb_node *node;
2825 spin_lock(&root->fs_info->block_group_cache_lock);
2826 node = rb_next(&cache->cache_node);
2827 btrfs_put_block_group(cache);
2828 if (node) {
2829 cache = rb_entry(node, struct btrfs_block_group_cache,
2830 cache_node);
11dfe35a 2831 btrfs_get_block_group(cache);
4a8c9a62
YZ
2832 } else
2833 cache = NULL;
2834 spin_unlock(&root->fs_info->block_group_cache_lock);
2835 return cache;
2836}
2837
0af3d00b
JB
2838static int cache_save_setup(struct btrfs_block_group_cache *block_group,
2839 struct btrfs_trans_handle *trans,
2840 struct btrfs_path *path)
2841{
2842 struct btrfs_root *root = block_group->fs_info->tree_root;
2843 struct inode *inode = NULL;
2844 u64 alloc_hint = 0;
2b20982e 2845 int dcs = BTRFS_DC_ERROR;
0af3d00b
JB
2846 int num_pages = 0;
2847 int retries = 0;
2848 int ret = 0;
2849
2850 /*
2851 * If this block group is smaller than 100 megs don't bother caching the
2852 * block group.
2853 */
2854 if (block_group->key.offset < (100 * 1024 * 1024)) {
2855 spin_lock(&block_group->lock);
2856 block_group->disk_cache_state = BTRFS_DC_WRITTEN;
2857 spin_unlock(&block_group->lock);
2858 return 0;
2859 }
2860
2861again:
2862 inode = lookup_free_space_inode(root, block_group, path);
2863 if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) {
2864 ret = PTR_ERR(inode);
b3b4aa74 2865 btrfs_release_path(path);
0af3d00b
JB
2866 goto out;
2867 }
2868
2869 if (IS_ERR(inode)) {
2870 BUG_ON(retries);
2871 retries++;
2872
2873 if (block_group->ro)
2874 goto out_free;
2875
2876 ret = create_free_space_inode(root, trans, block_group, path);
2877 if (ret)
2878 goto out_free;
2879 goto again;
2880 }
2881
5b0e95bf
JB
2882 /* We've already setup this transaction, go ahead and exit */
2883 if (block_group->cache_generation == trans->transid &&
2884 i_size_read(inode)) {
2885 dcs = BTRFS_DC_SETUP;
2886 goto out_put;
2887 }
2888
0af3d00b
JB
2889 /*
2890 * We want to set the generation to 0, that way if anything goes wrong
2891 * from here on out we know not to trust this cache when we load up next
2892 * time.
2893 */
2894 BTRFS_I(inode)->generation = 0;
2895 ret = btrfs_update_inode(trans, root, inode);
2896 WARN_ON(ret);
2897
2898 if (i_size_read(inode) > 0) {
2899 ret = btrfs_truncate_free_space_cache(root, trans, path,
2900 inode);
2901 if (ret)
2902 goto out_put;
2903 }
2904
2905 spin_lock(&block_group->lock);
2906 if (block_group->cached != BTRFS_CACHE_FINISHED) {
2b20982e
JB
2907 /* We're not cached, don't bother trying to write stuff out */
2908 dcs = BTRFS_DC_WRITTEN;
0af3d00b
JB
2909 spin_unlock(&block_group->lock);
2910 goto out_put;
2911 }
2912 spin_unlock(&block_group->lock);
2913
2914 num_pages = (int)div64_u64(block_group->key.offset, 1024 * 1024 * 1024);
2915 if (!num_pages)
2916 num_pages = 1;
2917
2918 /*
2919 * Just to make absolutely sure we have enough space, we're going to
2920 * preallocate 12 pages worth of space for each block group. In
2921 * practice we ought to use at most 8, but we need extra space so we can
2922 * add our header and have a terminator between the extents and the
2923 * bitmaps.
2924 */
2925 num_pages *= 16;
2926 num_pages *= PAGE_CACHE_SIZE;
2927
2928 ret = btrfs_check_data_free_space(inode, num_pages);
2929 if (ret)
2930 goto out_put;
2931
2932 ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, num_pages,
2933 num_pages, num_pages,
2934 &alloc_hint);
2b20982e
JB
2935 if (!ret)
2936 dcs = BTRFS_DC_SETUP;
0af3d00b 2937 btrfs_free_reserved_data_space(inode, num_pages);
c09544e0 2938
0af3d00b
JB
2939out_put:
2940 iput(inode);
2941out_free:
b3b4aa74 2942 btrfs_release_path(path);
0af3d00b
JB
2943out:
2944 spin_lock(&block_group->lock);
e65cbb94 2945 if (!ret && dcs == BTRFS_DC_SETUP)
5b0e95bf 2946 block_group->cache_generation = trans->transid;
2b20982e 2947 block_group->disk_cache_state = dcs;
0af3d00b
JB
2948 spin_unlock(&block_group->lock);
2949
2950 return ret;
2951}
2952
96b5179d
CM
2953int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2954 struct btrfs_root *root)
9078a3e1 2955{
4a8c9a62 2956 struct btrfs_block_group_cache *cache;
9078a3e1 2957 int err = 0;
9078a3e1 2958 struct btrfs_path *path;
96b5179d 2959 u64 last = 0;
9078a3e1
CM
2960
2961 path = btrfs_alloc_path();
2962 if (!path)
2963 return -ENOMEM;
2964
0af3d00b
JB
2965again:
2966 while (1) {
2967 cache = btrfs_lookup_first_block_group(root->fs_info, last);
2968 while (cache) {
2969 if (cache->disk_cache_state == BTRFS_DC_CLEAR)
2970 break;
2971 cache = next_block_group(root, cache);
2972 }
2973 if (!cache) {
2974 if (last == 0)
2975 break;
2976 last = 0;
2977 continue;
2978 }
2979 err = cache_save_setup(cache, trans, path);
2980 last = cache->key.objectid + cache->key.offset;
2981 btrfs_put_block_group(cache);
2982 }
2983
d397712b 2984 while (1) {
4a8c9a62
YZ
2985 if (last == 0) {
2986 err = btrfs_run_delayed_refs(trans, root,
2987 (unsigned long)-1);
79787eaa
JM
2988 if (err) /* File system offline */
2989 goto out;
0f9dd46c 2990 }
54aa1f4d 2991
4a8c9a62
YZ
2992 cache = btrfs_lookup_first_block_group(root->fs_info, last);
2993 while (cache) {
0af3d00b
JB
2994 if (cache->disk_cache_state == BTRFS_DC_CLEAR) {
2995 btrfs_put_block_group(cache);
2996 goto again;
2997 }
2998
4a8c9a62
YZ
2999 if (cache->dirty)
3000 break;
3001 cache = next_block_group(root, cache);
3002 }
3003 if (!cache) {
3004 if (last == 0)
3005 break;
3006 last = 0;
3007 continue;
3008 }
0f9dd46c 3009
0cb59c99
JB
3010 if (cache->disk_cache_state == BTRFS_DC_SETUP)
3011 cache->disk_cache_state = BTRFS_DC_NEED_WRITE;
e8569813 3012 cache->dirty = 0;
4a8c9a62 3013 last = cache->key.objectid + cache->key.offset;
0f9dd46c 3014
4a8c9a62 3015 err = write_one_cache_group(trans, root, path, cache);
79787eaa
JM
3016 if (err) /* File system offline */
3017 goto out;
3018
4a8c9a62 3019 btrfs_put_block_group(cache);
9078a3e1 3020 }
4a8c9a62 3021
0cb59c99
JB
3022 while (1) {
3023 /*
3024 * I don't think this is needed since we're just marking our
3025 * preallocated extent as written, but just in case it can't
3026 * hurt.
3027 */
3028 if (last == 0) {
3029 err = btrfs_run_delayed_refs(trans, root,
3030 (unsigned long)-1);
79787eaa
JM
3031 if (err) /* File system offline */
3032 goto out;
0cb59c99
JB
3033 }
3034
3035 cache = btrfs_lookup_first_block_group(root->fs_info, last);
3036 while (cache) {
3037 /*
3038 * Really this shouldn't happen, but it could if we
3039 * couldn't write the entire preallocated extent and
3040 * splitting the extent resulted in a new block.
3041 */
3042 if (cache->dirty) {
3043 btrfs_put_block_group(cache);
3044 goto again;
3045 }
3046 if (cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
3047 break;
3048 cache = next_block_group(root, cache);
3049 }
3050 if (!cache) {
3051 if (last == 0)
3052 break;
3053 last = 0;
3054 continue;
3055 }
3056
79787eaa 3057 err = btrfs_write_out_cache(root, trans, cache, path);
0cb59c99
JB
3058
3059 /*
3060 * If we didn't have an error then the cache state is still
3061 * NEED_WRITE, so we can set it to WRITTEN.
3062 */
79787eaa 3063 if (!err && cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
0cb59c99
JB
3064 cache->disk_cache_state = BTRFS_DC_WRITTEN;
3065 last = cache->key.objectid + cache->key.offset;
3066 btrfs_put_block_group(cache);
3067 }
79787eaa 3068out:
0cb59c99 3069
9078a3e1 3070 btrfs_free_path(path);
79787eaa 3071 return err;
9078a3e1
CM
3072}
3073
d2fb3437
YZ
3074int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
3075{
3076 struct btrfs_block_group_cache *block_group;
3077 int readonly = 0;
3078
3079 block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
3080 if (!block_group || block_group->ro)
3081 readonly = 1;
3082 if (block_group)
fa9c0d79 3083 btrfs_put_block_group(block_group);
d2fb3437
YZ
3084 return readonly;
3085}
3086
593060d7
CM
3087static int update_space_info(struct btrfs_fs_info *info, u64 flags,
3088 u64 total_bytes, u64 bytes_used,
3089 struct btrfs_space_info **space_info)
3090{
3091 struct btrfs_space_info *found;
b742bb82
YZ
3092 int i;
3093 int factor;
3094
3095 if (flags & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
3096 BTRFS_BLOCK_GROUP_RAID10))
3097 factor = 2;
3098 else
3099 factor = 1;
593060d7
CM
3100
3101 found = __find_space_info(info, flags);
3102 if (found) {
25179201 3103 spin_lock(&found->lock);
593060d7 3104 found->total_bytes += total_bytes;
89a55897 3105 found->disk_total += total_bytes * factor;
593060d7 3106 found->bytes_used += bytes_used;
b742bb82 3107 found->disk_used += bytes_used * factor;
8f18cf13 3108 found->full = 0;
25179201 3109 spin_unlock(&found->lock);
593060d7
CM
3110 *space_info = found;
3111 return 0;
3112 }
c146afad 3113 found = kzalloc(sizeof(*found), GFP_NOFS);
593060d7
CM
3114 if (!found)
3115 return -ENOMEM;
3116
b742bb82
YZ
3117 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
3118 INIT_LIST_HEAD(&found->block_groups[i]);
80eb234a 3119 init_rwsem(&found->groups_sem);
0f9dd46c 3120 spin_lock_init(&found->lock);
52ba6929 3121 found->flags = flags & BTRFS_BLOCK_GROUP_TYPE_MASK;
593060d7 3122 found->total_bytes = total_bytes;
89a55897 3123 found->disk_total = total_bytes * factor;
593060d7 3124 found->bytes_used = bytes_used;
b742bb82 3125 found->disk_used = bytes_used * factor;
593060d7 3126 found->bytes_pinned = 0;
e8569813 3127 found->bytes_reserved = 0;
c146afad 3128 found->bytes_readonly = 0;
f0486c68 3129 found->bytes_may_use = 0;
593060d7 3130 found->full = 0;
0e4f8f88 3131 found->force_alloc = CHUNK_ALLOC_NO_FORCE;
6d74119f 3132 found->chunk_alloc = 0;
fdb5effd
JB
3133 found->flush = 0;
3134 init_waitqueue_head(&found->wait);
593060d7 3135 *space_info = found;
4184ea7f 3136 list_add_rcu(&found->list, &info->space_info);
593060d7
CM
3137 return 0;
3138}
3139
8790d502
CM
3140static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
3141{
899c81ea
ID
3142 u64 extra_flags = chunk_to_extended(flags) &
3143 BTRFS_EXTENDED_PROFILE_MASK;
a46d11a8
ID
3144
3145 if (flags & BTRFS_BLOCK_GROUP_DATA)
3146 fs_info->avail_data_alloc_bits |= extra_flags;
3147 if (flags & BTRFS_BLOCK_GROUP_METADATA)
3148 fs_info->avail_metadata_alloc_bits |= extra_flags;
3149 if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3150 fs_info->avail_system_alloc_bits |= extra_flags;
8790d502 3151}
593060d7 3152
fc67c450
ID
3153/*
3154 * returns target flags in extended format or 0 if restripe for this
3155 * chunk_type is not in progress
c6664b42
ID
3156 *
3157 * should be called with either volume_mutex or balance_lock held
fc67c450
ID
3158 */
3159static u64 get_restripe_target(struct btrfs_fs_info *fs_info, u64 flags)
3160{
3161 struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3162 u64 target = 0;
3163
fc67c450
ID
3164 if (!bctl)
3165 return 0;
3166
3167 if (flags & BTRFS_BLOCK_GROUP_DATA &&
3168 bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3169 target = BTRFS_BLOCK_GROUP_DATA | bctl->data.target;
3170 } else if (flags & BTRFS_BLOCK_GROUP_SYSTEM &&
3171 bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3172 target = BTRFS_BLOCK_GROUP_SYSTEM | bctl->sys.target;
3173 } else if (flags & BTRFS_BLOCK_GROUP_METADATA &&
3174 bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3175 target = BTRFS_BLOCK_GROUP_METADATA | bctl->meta.target;
3176 }
3177
3178 return target;
3179}
3180
a46d11a8
ID
3181/*
3182 * @flags: available profiles in extended format (see ctree.h)
3183 *
e4d8ec0f
ID
3184 * Returns reduced profile in chunk format. If profile changing is in
3185 * progress (either running or paused) picks the target profile (if it's
3186 * already available), otherwise falls back to plain reducing.
a46d11a8 3187 */
2b82032c 3188u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
ec44a35c 3189{
cd02dca5
CM
3190 /*
3191 * we add in the count of missing devices because we want
3192 * to make sure that any RAID levels on a degraded FS
3193 * continue to be honored.
3194 */
3195 u64 num_devices = root->fs_info->fs_devices->rw_devices +
3196 root->fs_info->fs_devices->missing_devices;
fc67c450 3197 u64 target;
a061fc8d 3198
fc67c450
ID
3199 /*
3200 * see if restripe for this chunk_type is in progress, if so
3201 * try to reduce to the target profile
3202 */
e4d8ec0f 3203 spin_lock(&root->fs_info->balance_lock);
fc67c450
ID
3204 target = get_restripe_target(root->fs_info, flags);
3205 if (target) {
3206 /* pick target profile only if it's already available */
3207 if ((flags & target) & BTRFS_EXTENDED_PROFILE_MASK) {
e4d8ec0f 3208 spin_unlock(&root->fs_info->balance_lock);
fc67c450 3209 return extended_to_chunk(target);
e4d8ec0f
ID
3210 }
3211 }
3212 spin_unlock(&root->fs_info->balance_lock);
3213
a061fc8d
CM
3214 if (num_devices == 1)
3215 flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0);
3216 if (num_devices < 4)
3217 flags &= ~BTRFS_BLOCK_GROUP_RAID10;
3218
ec44a35c
CM
3219 if ((flags & BTRFS_BLOCK_GROUP_DUP) &&
3220 (flags & (BTRFS_BLOCK_GROUP_RAID1 |
a061fc8d 3221 BTRFS_BLOCK_GROUP_RAID10))) {
ec44a35c 3222 flags &= ~BTRFS_BLOCK_GROUP_DUP;
a061fc8d 3223 }
ec44a35c
CM
3224
3225 if ((flags & BTRFS_BLOCK_GROUP_RAID1) &&
a061fc8d 3226 (flags & BTRFS_BLOCK_GROUP_RAID10)) {
ec44a35c 3227 flags &= ~BTRFS_BLOCK_GROUP_RAID1;
a061fc8d 3228 }
ec44a35c
CM
3229
3230 if ((flags & BTRFS_BLOCK_GROUP_RAID0) &&
3231 ((flags & BTRFS_BLOCK_GROUP_RAID1) |
3232 (flags & BTRFS_BLOCK_GROUP_RAID10) |
a46d11a8 3233 (flags & BTRFS_BLOCK_GROUP_DUP))) {
ec44a35c 3234 flags &= ~BTRFS_BLOCK_GROUP_RAID0;
a46d11a8
ID
3235 }
3236
899c81ea 3237 return extended_to_chunk(flags);
ec44a35c
CM
3238}
3239
b742bb82 3240static u64 get_alloc_profile(struct btrfs_root *root, u64 flags)
6a63209f 3241{
b742bb82 3242 if (flags & BTRFS_BLOCK_GROUP_DATA)
6fef8df1 3243 flags |= root->fs_info->avail_data_alloc_bits;
b742bb82 3244 else if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
6fef8df1 3245 flags |= root->fs_info->avail_system_alloc_bits;
b742bb82 3246 else if (flags & BTRFS_BLOCK_GROUP_METADATA)
6fef8df1
ID
3247 flags |= root->fs_info->avail_metadata_alloc_bits;
3248
b742bb82 3249 return btrfs_reduce_alloc_profile(root, flags);
6a63209f
JB
3250}
3251
6d07bcec 3252u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data)
9ed74f2d 3253{
b742bb82 3254 u64 flags;
9ed74f2d 3255
b742bb82
YZ
3256 if (data)
3257 flags = BTRFS_BLOCK_GROUP_DATA;
3258 else if (root == root->fs_info->chunk_root)
3259 flags = BTRFS_BLOCK_GROUP_SYSTEM;
9ed74f2d 3260 else
b742bb82 3261 flags = BTRFS_BLOCK_GROUP_METADATA;
9ed74f2d 3262
b742bb82 3263 return get_alloc_profile(root, flags);
6a63209f 3264}
9ed74f2d 3265
6a63209f
JB
3266void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *inode)
3267{
6a63209f 3268 BTRFS_I(inode)->space_info = __find_space_info(root->fs_info,
f0486c68 3269 BTRFS_BLOCK_GROUP_DATA);
9ed74f2d
JB
3270}
3271
6a63209f 3272/*
6a63209f
JB
3273 * This will check the space that the inode allocates from to make sure we have
3274 * enough space for bytes.
6a63209f 3275 */
0ca1f7ce 3276int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
6a63209f 3277{
6a63209f 3278 struct btrfs_space_info *data_sinfo;
0ca1f7ce 3279 struct btrfs_root *root = BTRFS_I(inode)->root;
ab6e2410 3280 u64 used;
0af3d00b 3281 int ret = 0, committed = 0, alloc_chunk = 1;
6a63209f 3282
6a63209f
JB
3283 /* make sure bytes are sectorsize aligned */
3284 bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
6a63209f 3285
82d5902d
LZ
3286 if (root == root->fs_info->tree_root ||
3287 BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID) {
0af3d00b
JB
3288 alloc_chunk = 0;
3289 committed = 1;
3290 }
3291
6a63209f 3292 data_sinfo = BTRFS_I(inode)->space_info;
33b4d47f
CM
3293 if (!data_sinfo)
3294 goto alloc;
9ed74f2d 3295
6a63209f
JB
3296again:
3297 /* make sure we have enough space to handle the data first */
3298 spin_lock(&data_sinfo->lock);
8929ecfa
YZ
3299 used = data_sinfo->bytes_used + data_sinfo->bytes_reserved +
3300 data_sinfo->bytes_pinned + data_sinfo->bytes_readonly +
3301 data_sinfo->bytes_may_use;
ab6e2410
JB
3302
3303 if (used + bytes > data_sinfo->total_bytes) {
4e06bdd6 3304 struct btrfs_trans_handle *trans;
9ed74f2d 3305
6a63209f
JB
3306 /*
3307 * if we don't have enough free bytes in this space then we need
3308 * to alloc a new chunk.
3309 */
0af3d00b 3310 if (!data_sinfo->full && alloc_chunk) {
6a63209f 3311 u64 alloc_target;
9ed74f2d 3312
0e4f8f88 3313 data_sinfo->force_alloc = CHUNK_ALLOC_FORCE;
6a63209f 3314 spin_unlock(&data_sinfo->lock);
33b4d47f 3315alloc:
6a63209f 3316 alloc_target = btrfs_get_alloc_profile(root, 1);
7a7eaa40 3317 trans = btrfs_join_transaction(root);
a22285a6
YZ
3318 if (IS_ERR(trans))
3319 return PTR_ERR(trans);
9ed74f2d 3320
6a63209f
JB
3321 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
3322 bytes + 2 * 1024 * 1024,
0e4f8f88
CM
3323 alloc_target,
3324 CHUNK_ALLOC_NO_FORCE);
6a63209f 3325 btrfs_end_transaction(trans, root);
d52a5b5f
MX
3326 if (ret < 0) {
3327 if (ret != -ENOSPC)
3328 return ret;
3329 else
3330 goto commit_trans;
3331 }
9ed74f2d 3332
33b4d47f
CM
3333 if (!data_sinfo) {
3334 btrfs_set_inode_space_info(root, inode);
3335 data_sinfo = BTRFS_I(inode)->space_info;
3336 }
6a63209f
JB
3337 goto again;
3338 }
f2bb8f5c
JB
3339
3340 /*
3341 * If we have less pinned bytes than we want to allocate then
3342 * don't bother committing the transaction, it won't help us.
3343 */
3344 if (data_sinfo->bytes_pinned < bytes)
3345 committed = 1;
6a63209f 3346 spin_unlock(&data_sinfo->lock);
6a63209f 3347
4e06bdd6 3348 /* commit the current transaction and try again */
d52a5b5f 3349commit_trans:
a4abeea4
JB
3350 if (!committed &&
3351 !atomic_read(&root->fs_info->open_ioctl_trans)) {
4e06bdd6 3352 committed = 1;
7a7eaa40 3353 trans = btrfs_join_transaction(root);
a22285a6
YZ
3354 if (IS_ERR(trans))
3355 return PTR_ERR(trans);
4e06bdd6
JB
3356 ret = btrfs_commit_transaction(trans, root);
3357 if (ret)
3358 return ret;
3359 goto again;
3360 }
9ed74f2d 3361
6a63209f
JB
3362 return -ENOSPC;
3363 }
3364 data_sinfo->bytes_may_use += bytes;
8c2a3ca2 3365 trace_btrfs_space_reservation(root->fs_info, "space_info",
2bcc0328 3366 data_sinfo->flags, bytes, 1);
6a63209f 3367 spin_unlock(&data_sinfo->lock);
6a63209f 3368
9ed74f2d 3369 return 0;
9ed74f2d 3370}
6a63209f 3371
6a63209f 3372/*
fb25e914 3373 * Called if we need to clear a data reservation for this inode.
6a63209f 3374 */
0ca1f7ce 3375void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)
e3ccfa98 3376{
0ca1f7ce 3377 struct btrfs_root *root = BTRFS_I(inode)->root;
6a63209f 3378 struct btrfs_space_info *data_sinfo;
e3ccfa98 3379
6a63209f
JB
3380 /* make sure bytes are sectorsize aligned */
3381 bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
e3ccfa98 3382
6a63209f
JB
3383 data_sinfo = BTRFS_I(inode)->space_info;
3384 spin_lock(&data_sinfo->lock);
3385 data_sinfo->bytes_may_use -= bytes;
8c2a3ca2 3386 trace_btrfs_space_reservation(root->fs_info, "space_info",
2bcc0328 3387 data_sinfo->flags, bytes, 0);
6a63209f 3388 spin_unlock(&data_sinfo->lock);
e3ccfa98
JB
3389}
3390
97e728d4 3391static void force_metadata_allocation(struct btrfs_fs_info *info)
e3ccfa98 3392{
97e728d4
JB
3393 struct list_head *head = &info->space_info;
3394 struct btrfs_space_info *found;
e3ccfa98 3395
97e728d4
JB
3396 rcu_read_lock();
3397 list_for_each_entry_rcu(found, head, list) {
3398 if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
0e4f8f88 3399 found->force_alloc = CHUNK_ALLOC_FORCE;
e3ccfa98 3400 }
97e728d4 3401 rcu_read_unlock();
e3ccfa98
JB
3402}
3403
e5bc2458 3404static int should_alloc_chunk(struct btrfs_root *root,
0e4f8f88
CM
3405 struct btrfs_space_info *sinfo, u64 alloc_bytes,
3406 int force)
32c00aff 3407{
fb25e914 3408 struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
424499db 3409 u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
0e4f8f88 3410 u64 num_allocated = sinfo->bytes_used + sinfo->bytes_reserved;
e5bc2458 3411 u64 thresh;
e3ccfa98 3412
0e4f8f88
CM
3413 if (force == CHUNK_ALLOC_FORCE)
3414 return 1;
3415
fb25e914
JB
3416 /*
3417 * We need to take into account the global rsv because for all intents
3418 * and purposes it's used space. Don't worry about locking the
3419 * global_rsv, it doesn't change except when the transaction commits.
3420 */
3421 num_allocated += global_rsv->size;
3422
0e4f8f88
CM
3423 /*
3424 * in limited mode, we want to have some free space up to
3425 * about 1% of the FS size.
3426 */
3427 if (force == CHUNK_ALLOC_LIMITED) {
6c41761f 3428 thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
0e4f8f88
CM
3429 thresh = max_t(u64, 64 * 1024 * 1024,
3430 div_factor_fine(thresh, 1));
3431
3432 if (num_bytes - num_allocated < thresh)
3433 return 1;
3434 }
6c41761f 3435 thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
0e4f8f88 3436
cf1d72c9
CM
3437 /* 256MB or 2% of the FS */
3438 thresh = max_t(u64, 256 * 1024 * 1024, div_factor_fine(thresh, 2));
96bdc7dc
CM
3439 /* system chunks need a much small threshold */
3440 if (sinfo->flags & BTRFS_BLOCK_GROUP_SYSTEM)
3441 thresh = 32 * 1024 * 1024;
e5bc2458 3442
cf1d72c9 3443 if (num_bytes > thresh && sinfo->bytes_used < div_factor(num_bytes, 8))
14ed0ca6 3444 return 0;
424499db 3445 return 1;
32c00aff
JB
3446}
3447
15d1ff81
LB
3448static u64 get_system_chunk_thresh(struct btrfs_root *root, u64 type)
3449{
3450 u64 num_dev;
3451
3452 if (type & BTRFS_BLOCK_GROUP_RAID10 ||
3453 type & BTRFS_BLOCK_GROUP_RAID0)
3454 num_dev = root->fs_info->fs_devices->rw_devices;
3455 else if (type & BTRFS_BLOCK_GROUP_RAID1)
3456 num_dev = 2;
3457 else
3458 num_dev = 1; /* DUP or single */
3459
3460 /* metadata for updaing devices and chunk tree */
3461 return btrfs_calc_trans_metadata_size(root, num_dev + 1);
3462}
3463
3464static void check_system_chunk(struct btrfs_trans_handle *trans,
3465 struct btrfs_root *root, u64 type)
3466{
3467 struct btrfs_space_info *info;
3468 u64 left;
3469 u64 thresh;
3470
3471 info = __find_space_info(root->fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
3472 spin_lock(&info->lock);
3473 left = info->total_bytes - info->bytes_used - info->bytes_pinned -
3474 info->bytes_reserved - info->bytes_readonly;
3475 spin_unlock(&info->lock);
3476
3477 thresh = get_system_chunk_thresh(root, type);
3478 if (left < thresh && btrfs_test_opt(root, ENOSPC_DEBUG)) {
3479 printk(KERN_INFO "left=%llu, need=%llu, flags=%llu\n",
3480 left, thresh, type);
3481 dump_space_info(info, 0, 0);
3482 }
3483
3484 if (left < thresh) {
3485 u64 flags;
3486
3487 flags = btrfs_get_alloc_profile(root->fs_info->chunk_root, 0);
3488 btrfs_alloc_chunk(trans, root, flags);
3489 }
3490}
3491
6324fbf3
CM
3492static int do_chunk_alloc(struct btrfs_trans_handle *trans,
3493 struct btrfs_root *extent_root, u64 alloc_bytes,
0ef3e66b 3494 u64 flags, int force)
9ed74f2d 3495{
6324fbf3 3496 struct btrfs_space_info *space_info;
97e728d4 3497 struct btrfs_fs_info *fs_info = extent_root->fs_info;
6d74119f 3498 int wait_for_alloc = 0;
9ed74f2d 3499 int ret = 0;
9ed74f2d 3500
6324fbf3 3501 space_info = __find_space_info(extent_root->fs_info, flags);
593060d7
CM
3502 if (!space_info) {
3503 ret = update_space_info(extent_root->fs_info, flags,
3504 0, 0, &space_info);
79787eaa 3505 BUG_ON(ret); /* -ENOMEM */
9ed74f2d 3506 }
79787eaa 3507 BUG_ON(!space_info); /* Logic error */
9ed74f2d 3508
6d74119f 3509again:
25179201 3510 spin_lock(&space_info->lock);
9e622d6b 3511 if (force < space_info->force_alloc)
0e4f8f88 3512 force = space_info->force_alloc;
25179201
JB
3513 if (space_info->full) {
3514 spin_unlock(&space_info->lock);
6d74119f 3515 return 0;
9ed74f2d
JB
3516 }
3517
0e4f8f88 3518 if (!should_alloc_chunk(extent_root, space_info, alloc_bytes, force)) {
25179201 3519 spin_unlock(&space_info->lock);
6d74119f
JB
3520 return 0;
3521 } else if (space_info->chunk_alloc) {
3522 wait_for_alloc = 1;
3523 } else {
3524 space_info->chunk_alloc = 1;
9ed74f2d 3525 }
0e4f8f88 3526
25179201 3527 spin_unlock(&space_info->lock);
9ed74f2d 3528
6d74119f
JB
3529 mutex_lock(&fs_info->chunk_mutex);
3530
3531 /*
3532 * The chunk_mutex is held throughout the entirety of a chunk
3533 * allocation, so once we've acquired the chunk_mutex we know that the
3534 * other guy is done and we need to recheck and see if we should
3535 * allocate.
3536 */
3537 if (wait_for_alloc) {
3538 mutex_unlock(&fs_info->chunk_mutex);
3539 wait_for_alloc = 0;
3540 goto again;
3541 }
3542
67377734
JB
3543 /*
3544 * If we have mixed data/metadata chunks we want to make sure we keep
3545 * allocating mixed chunks instead of individual chunks.
3546 */
3547 if (btrfs_mixed_space_info(space_info))
3548 flags |= (BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA);
3549
97e728d4
JB
3550 /*
3551 * if we're doing a data chunk, go ahead and make sure that
3552 * we keep a reasonable number of metadata chunks allocated in the
3553 * FS as well.
3554 */
9ed74f2d 3555 if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {
97e728d4
JB
3556 fs_info->data_chunk_allocations++;
3557 if (!(fs_info->data_chunk_allocations %
3558 fs_info->metadata_ratio))
3559 force_metadata_allocation(fs_info);
9ed74f2d
JB
3560 }
3561
15d1ff81
LB
3562 /*
3563 * Check if we have enough space in SYSTEM chunk because we may need
3564 * to update devices.
3565 */
3566 check_system_chunk(trans, extent_root, flags);
3567
2b82032c 3568 ret = btrfs_alloc_chunk(trans, extent_root, flags);
92b8e897
MF
3569 if (ret < 0 && ret != -ENOSPC)
3570 goto out;
3571
9ed74f2d 3572 spin_lock(&space_info->lock);
9ed74f2d 3573 if (ret)
6324fbf3 3574 space_info->full = 1;
424499db
YZ
3575 else
3576 ret = 1;
6d74119f 3577
0e4f8f88 3578 space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
6d74119f 3579 space_info->chunk_alloc = 0;
9ed74f2d 3580 spin_unlock(&space_info->lock);
92b8e897 3581out:
a25c75d5 3582 mutex_unlock(&fs_info->chunk_mutex);
0f9dd46c 3583 return ret;
6324fbf3 3584}
9ed74f2d 3585
9ed74f2d 3586/*
5da9d01b 3587 * shrink metadata reservation for delalloc
9ed74f2d 3588 */
663350ac 3589static int shrink_delalloc(struct btrfs_root *root, u64 to_reclaim,
f104d044 3590 bool wait_ordered)
5da9d01b 3591{
0ca1f7ce 3592 struct btrfs_block_rsv *block_rsv;
0019f10d 3593 struct btrfs_space_info *space_info;
663350ac 3594 struct btrfs_trans_handle *trans;
5da9d01b
YZ
3595 u64 reserved;
3596 u64 max_reclaim;
3597 u64 reclaimed = 0;
b1953bce 3598 long time_left;
877da174 3599 unsigned long nr_pages = (2 * 1024 * 1024) >> PAGE_CACHE_SHIFT;
b1953bce 3600 int loops = 0;
36e39c40 3601 unsigned long progress;
5da9d01b 3602
663350ac 3603 trans = (struct btrfs_trans_handle *)current->journal_info;
0ca1f7ce 3604 block_rsv = &root->fs_info->delalloc_block_rsv;
0019f10d 3605 space_info = block_rsv->space_info;
bf9022e0
CM
3606
3607 smp_mb();
fb25e914 3608 reserved = space_info->bytes_may_use;
36e39c40 3609 progress = space_info->reservation_progress;
5da9d01b
YZ
3610
3611 if (reserved == 0)
3612 return 0;
c4f675cd 3613
fdb5effd
JB
3614 smp_mb();
3615 if (root->fs_info->delalloc_bytes == 0) {
3616 if (trans)
3617 return 0;
3618 btrfs_wait_ordered_extents(root, 0, 0);
3619 return 0;
3620 }
3621
5da9d01b 3622 max_reclaim = min(reserved, to_reclaim);
877da174
JB
3623 nr_pages = max_t(unsigned long, nr_pages,
3624 max_reclaim >> PAGE_CACHE_SHIFT);
b1953bce 3625 while (loops < 1024) {
bf9022e0
CM
3626 /* have the flusher threads jump in and do some IO */
3627 smp_mb();
3628 nr_pages = min_t(unsigned long, nr_pages,
3629 root->fs_info->delalloc_bytes >> PAGE_CACHE_SHIFT);
0e175a18
CW
3630 writeback_inodes_sb_nr_if_idle(root->fs_info->sb, nr_pages,
3631 WB_REASON_FS_FREE_SPACE);
5da9d01b 3632
0019f10d 3633 spin_lock(&space_info->lock);
fb25e914
JB
3634 if (reserved > space_info->bytes_may_use)
3635 reclaimed += reserved - space_info->bytes_may_use;
3636 reserved = space_info->bytes_may_use;
0019f10d 3637 spin_unlock(&space_info->lock);
5da9d01b 3638
36e39c40
CM
3639 loops++;
3640
5da9d01b
YZ
3641 if (reserved == 0 || reclaimed >= max_reclaim)
3642 break;
3643
3644 if (trans && trans->transaction->blocked)
3645 return -EAGAIN;
bf9022e0 3646
f104d044
JB
3647 if (wait_ordered && !trans) {
3648 btrfs_wait_ordered_extents(root, 0, 0);
3649 } else {
3650 time_left = schedule_timeout_interruptible(1);
b1953bce 3651
f104d044
JB
3652 /* We were interrupted, exit */
3653 if (time_left)
3654 break;
3655 }
b1953bce 3656
36e39c40
CM
3657 /* we've kicked the IO a few times, if anything has been freed,
3658 * exit. There is no sense in looping here for a long time
3659 * when we really need to commit the transaction, or there are
3660 * just too many writers without enough free space
3661 */
3662
3663 if (loops > 3) {
3664 smp_mb();
3665 if (progress != space_info->reservation_progress)
3666 break;
3667 }
bf9022e0 3668
5da9d01b 3669 }
f104d044 3670
5da9d01b
YZ
3671 return reclaimed >= to_reclaim;
3672}
3673
663350ac
JB
3674/**
3675 * maybe_commit_transaction - possibly commit the transaction if its ok to
3676 * @root - the root we're allocating for
3677 * @bytes - the number of bytes we want to reserve
3678 * @force - force the commit
8bb8ab2e 3679 *
663350ac
JB
3680 * This will check to make sure that committing the transaction will actually
3681 * get us somewhere and then commit the transaction if it does. Otherwise it
3682 * will return -ENOSPC.
8bb8ab2e 3683 */
663350ac
JB
3684static int may_commit_transaction(struct btrfs_root *root,
3685 struct btrfs_space_info *space_info,
3686 u64 bytes, int force)
3687{
3688 struct btrfs_block_rsv *delayed_rsv = &root->fs_info->delayed_block_rsv;
3689 struct btrfs_trans_handle *trans;
3690
3691 trans = (struct btrfs_trans_handle *)current->journal_info;
3692 if (trans)
3693 return -EAGAIN;
3694
3695 if (force)
3696 goto commit;
3697
3698 /* See if there is enough pinned space to make this reservation */
3699 spin_lock(&space_info->lock);
3700 if (space_info->bytes_pinned >= bytes) {
3701 spin_unlock(&space_info->lock);
3702 goto commit;
3703 }
3704 spin_unlock(&space_info->lock);
3705
3706 /*
3707 * See if there is some space in the delayed insertion reservation for
3708 * this reservation.
3709 */
3710 if (space_info != delayed_rsv->space_info)
3711 return -ENOSPC;
3712
d9b0218f 3713 spin_lock(&space_info->lock);
663350ac 3714 spin_lock(&delayed_rsv->lock);
d9b0218f 3715 if (space_info->bytes_pinned + delayed_rsv->size < bytes) {
663350ac 3716 spin_unlock(&delayed_rsv->lock);
d9b0218f 3717 spin_unlock(&space_info->lock);
663350ac
JB
3718 return -ENOSPC;
3719 }
3720 spin_unlock(&delayed_rsv->lock);
d9b0218f 3721 spin_unlock(&space_info->lock);
663350ac
JB
3722
3723commit:
3724 trans = btrfs_join_transaction(root);
3725 if (IS_ERR(trans))
3726 return -ENOSPC;
3727
3728 return btrfs_commit_transaction(trans, root);
3729}
3730
96c3f433
JB
3731enum flush_state {
3732 FLUSH_DELALLOC = 1,
3733 FLUSH_DELALLOC_WAIT = 2,
3734 FLUSH_DELAYED_ITEMS_NR = 3,
3735 FLUSH_DELAYED_ITEMS = 4,
3736 COMMIT_TRANS = 5,
3737};
3738
3739static int flush_space(struct btrfs_root *root,
3740 struct btrfs_space_info *space_info, u64 num_bytes,
3741 u64 orig_bytes, int state)
3742{
3743 struct btrfs_trans_handle *trans;
3744 int nr;
3745 int ret;
3746
3747 switch (state) {
3748 case FLUSH_DELALLOC:
3749 case FLUSH_DELALLOC_WAIT:
3750 ret = shrink_delalloc(root, num_bytes,
3751 state == FLUSH_DELALLOC_WAIT);
3752 if (ret > 0)
3753 ret = 0;
3754 break;
3755 case FLUSH_DELAYED_ITEMS_NR:
3756 case FLUSH_DELAYED_ITEMS:
3757 if (state == FLUSH_DELAYED_ITEMS_NR) {
3758 u64 bytes = btrfs_calc_trans_metadata_size(root, 1);
3759
3760 nr = (int)div64_u64(num_bytes, bytes);
3761 if (!nr)
3762 nr = 1;
3763 nr *= 2;
3764 } else {
3765 nr = -1;
3766 }
3767 trans = btrfs_join_transaction(root);
3768 if (IS_ERR(trans)) {
3769 ret = PTR_ERR(trans);
3770 break;
3771 }
3772 ret = btrfs_run_delayed_items_nr(trans, root, nr);
3773 btrfs_end_transaction(trans, root);
3774 break;
3775 case COMMIT_TRANS:
3776 ret = may_commit_transaction(root, space_info, orig_bytes, 0);
3777 break;
3778 default:
3779 ret = -ENOSPC;
3780 break;
3781 }
3782
3783 return ret;
3784}
4a92b1b8
JB
3785/**
3786 * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
3787 * @root - the root we're allocating for
3788 * @block_rsv - the block_rsv we're allocating for
3789 * @orig_bytes - the number of bytes we want
3790 * @flush - wether or not we can flush to make our reservation
8bb8ab2e 3791 *
4a92b1b8
JB
3792 * This will reserve orgi_bytes number of bytes from the space info associated
3793 * with the block_rsv. If there is not enough space it will make an attempt to
3794 * flush out space to make room. It will do this by flushing delalloc if
3795 * possible or committing the transaction. If flush is 0 then no attempts to
3796 * regain reservations will be made and this will fail if there is not enough
3797 * space already.
8bb8ab2e 3798 */
4a92b1b8 3799static int reserve_metadata_bytes(struct btrfs_root *root,
8bb8ab2e
JB
3800 struct btrfs_block_rsv *block_rsv,
3801 u64 orig_bytes, int flush)
9ed74f2d 3802{
f0486c68 3803 struct btrfs_space_info *space_info = block_rsv->space_info;
2bf64758 3804 u64 used;
8bb8ab2e 3805 u64 num_bytes = orig_bytes;
96c3f433 3806 int flush_state = FLUSH_DELALLOC;
8bb8ab2e 3807 int ret = 0;
fdb5effd 3808 bool flushing = false;
96c3f433 3809 bool committed = false;
9ed74f2d 3810
8bb8ab2e 3811again:
fdb5effd 3812 ret = 0;
8bb8ab2e 3813 spin_lock(&space_info->lock);
fdb5effd
JB
3814 /*
3815 * We only want to wait if somebody other than us is flushing and we are
3816 * actually alloed to flush.
3817 */
3818 while (flush && !flushing && space_info->flush) {
3819 spin_unlock(&space_info->lock);
3820 /*
3821 * If we have a trans handle we can't wait because the flusher
3822 * may have to commit the transaction, which would mean we would
3823 * deadlock since we are waiting for the flusher to finish, but
3824 * hold the current transaction open.
3825 */
663350ac 3826 if (current->journal_info)
fdb5effd 3827 return -EAGAIN;
b9688bb8
AJ
3828 ret = wait_event_killable(space_info->wait, !space_info->flush);
3829 /* Must have been killed, return */
3830 if (ret)
fdb5effd
JB
3831 return -EINTR;
3832
3833 spin_lock(&space_info->lock);
3834 }
3835
3836 ret = -ENOSPC;
2bf64758
JB
3837 used = space_info->bytes_used + space_info->bytes_reserved +
3838 space_info->bytes_pinned + space_info->bytes_readonly +
3839 space_info->bytes_may_use;
9ed74f2d 3840
8bb8ab2e
JB
3841 /*
3842 * The idea here is that we've not already over-reserved the block group
3843 * then we can go ahead and save our reservation first and then start
3844 * flushing if we need to. Otherwise if we've already overcommitted
3845 * lets start flushing stuff first and then come back and try to make
3846 * our reservation.
3847 */
2bf64758
JB
3848 if (used <= space_info->total_bytes) {
3849 if (used + orig_bytes <= space_info->total_bytes) {
fb25e914 3850 space_info->bytes_may_use += orig_bytes;
8c2a3ca2 3851 trace_btrfs_space_reservation(root->fs_info,
2bcc0328 3852 "space_info", space_info->flags, orig_bytes, 1);
8bb8ab2e
JB
3853 ret = 0;
3854 } else {
3855 /*
3856 * Ok set num_bytes to orig_bytes since we aren't
3857 * overocmmitted, this way we only try and reclaim what
3858 * we need.
3859 */
3860 num_bytes = orig_bytes;
3861 }
3862 } else {
3863 /*
3864 * Ok we're over committed, set num_bytes to the overcommitted
3865 * amount plus the amount of bytes that we need for this
3866 * reservation.
3867 */
2bf64758 3868 num_bytes = used - space_info->total_bytes +
96c3f433 3869 (orig_bytes * 2);
8bb8ab2e 3870 }
9ed74f2d 3871
36ba022a 3872 if (ret) {
2bf64758
JB
3873 u64 profile = btrfs_get_alloc_profile(root, 0);
3874 u64 avail;
3875
7e355b83
JB
3876 /*
3877 * If we have a lot of space that's pinned, don't bother doing
3878 * the overcommit dance yet and just commit the transaction.
3879 */
3880 avail = (space_info->total_bytes - space_info->bytes_used) * 8;
3881 do_div(avail, 10);
663350ac 3882 if (space_info->bytes_pinned >= avail && flush && !committed) {
7e355b83
JB
3883 space_info->flush = 1;
3884 flushing = true;
3885 spin_unlock(&space_info->lock);
663350ac
JB
3886 ret = may_commit_transaction(root, space_info,
3887 orig_bytes, 1);
3888 if (ret)
3889 goto out;
3890 committed = true;
3891 goto again;
7e355b83
JB
3892 }
3893
2bf64758
JB
3894 spin_lock(&root->fs_info->free_chunk_lock);
3895 avail = root->fs_info->free_chunk_space;
3896
3897 /*
3898 * If we have dup, raid1 or raid10 then only half of the free
3899 * space is actually useable.
3900 */
3901 if (profile & (BTRFS_BLOCK_GROUP_DUP |
3902 BTRFS_BLOCK_GROUP_RAID1 |
3903 BTRFS_BLOCK_GROUP_RAID10))
3904 avail >>= 1;
3905
3906 /*
3907 * If we aren't flushing don't let us overcommit too much, say
3908 * 1/8th of the space. If we can flush, let it overcommit up to
3909 * 1/2 of the space.
3910 */
3911 if (flush)
3912 avail >>= 3;
3913 else
3914 avail >>= 1;
3915 spin_unlock(&root->fs_info->free_chunk_lock);
3916
9a82ca65 3917 if (used + num_bytes < space_info->total_bytes + avail) {
2bf64758 3918 space_info->bytes_may_use += orig_bytes;
8c2a3ca2 3919 trace_btrfs_space_reservation(root->fs_info,
2bcc0328 3920 "space_info", space_info->flags, orig_bytes, 1);
2bf64758
JB
3921 ret = 0;
3922 }
3923 }
3924
8bb8ab2e
JB
3925 /*
3926 * Couldn't make our reservation, save our place so while we're trying
3927 * to reclaim space we can actually use it instead of somebody else
3928 * stealing it from us.
3929 */
fdb5effd
JB
3930 if (ret && flush) {
3931 flushing = true;
3932 space_info->flush = 1;
8bb8ab2e 3933 }
9ed74f2d 3934
f0486c68 3935 spin_unlock(&space_info->lock);
9ed74f2d 3936
fdb5effd 3937 if (!ret || !flush)
8bb8ab2e 3938 goto out;
f0486c68 3939
96c3f433
JB
3940 ret = flush_space(root, space_info, num_bytes, orig_bytes,
3941 flush_state);
3942 flush_state++;
3943 if (!ret)
8bb8ab2e 3944 goto again;
96c3f433 3945 else if (flush_state <= COMMIT_TRANS)
8bb8ab2e
JB
3946 goto again;
3947
3948out:
fdb5effd 3949 if (flushing) {
8bb8ab2e 3950 spin_lock(&space_info->lock);
fdb5effd
JB
3951 space_info->flush = 0;
3952 wake_up_all(&space_info->wait);
8bb8ab2e 3953 spin_unlock(&space_info->lock);
f0486c68 3954 }
f0486c68
YZ
3955 return ret;
3956}
3957
79787eaa
JM
3958static struct btrfs_block_rsv *get_block_rsv(
3959 const struct btrfs_trans_handle *trans,
3960 const struct btrfs_root *root)
f0486c68 3961{
4c13d758
JB
3962 struct btrfs_block_rsv *block_rsv = NULL;
3963
0e721106
JB
3964 if (root->ref_cows)
3965 block_rsv = trans->block_rsv;
3966
3967 if (root == root->fs_info->csum_root && trans->adding_csums)
f0486c68 3968 block_rsv = trans->block_rsv;
4c13d758
JB
3969
3970 if (!block_rsv)
f0486c68
YZ
3971 block_rsv = root->block_rsv;
3972
3973 if (!block_rsv)
3974 block_rsv = &root->fs_info->empty_block_rsv;
3975
3976 return block_rsv;
3977}
3978
3979static int block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,
3980 u64 num_bytes)
3981{
3982 int ret = -ENOSPC;
3983 spin_lock(&block_rsv->lock);
3984 if (block_rsv->reserved >= num_bytes) {
3985 block_rsv->reserved -= num_bytes;
3986 if (block_rsv->reserved < block_rsv->size)
3987 block_rsv->full = 0;
3988 ret = 0;
3989 }
3990 spin_unlock(&block_rsv->lock);
3991 return ret;
3992}
3993
3994static void block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
3995 u64 num_bytes, int update_size)
3996{
3997 spin_lock(&block_rsv->lock);
3998 block_rsv->reserved += num_bytes;
3999 if (update_size)
4000 block_rsv->size += num_bytes;
4001 else if (block_rsv->reserved >= block_rsv->size)
4002 block_rsv->full = 1;
4003 spin_unlock(&block_rsv->lock);
4004}
4005
8c2a3ca2
JB
4006static void block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
4007 struct btrfs_block_rsv *block_rsv,
62a45b60 4008 struct btrfs_block_rsv *dest, u64 num_bytes)
f0486c68
YZ
4009{
4010 struct btrfs_space_info *space_info = block_rsv->space_info;
4011
4012 spin_lock(&block_rsv->lock);
4013 if (num_bytes == (u64)-1)
4014 num_bytes = block_rsv->size;
4015 block_rsv->size -= num_bytes;
4016 if (block_rsv->reserved >= block_rsv->size) {
4017 num_bytes = block_rsv->reserved - block_rsv->size;
4018 block_rsv->reserved = block_rsv->size;
4019 block_rsv->full = 1;
4020 } else {
4021 num_bytes = 0;
4022 }
4023 spin_unlock(&block_rsv->lock);
4024
4025 if (num_bytes > 0) {
4026 if (dest) {
e9e22899
JB
4027 spin_lock(&dest->lock);
4028 if (!dest->full) {
4029 u64 bytes_to_add;
4030
4031 bytes_to_add = dest->size - dest->reserved;
4032 bytes_to_add = min(num_bytes, bytes_to_add);
4033 dest->reserved += bytes_to_add;
4034 if (dest->reserved >= dest->size)
4035 dest->full = 1;
4036 num_bytes -= bytes_to_add;
4037 }
4038 spin_unlock(&dest->lock);
4039 }
4040 if (num_bytes) {
f0486c68 4041 spin_lock(&space_info->lock);
fb25e914 4042 space_info->bytes_may_use -= num_bytes;
8c2a3ca2 4043 trace_btrfs_space_reservation(fs_info, "space_info",
2bcc0328 4044 space_info->flags, num_bytes, 0);
36e39c40 4045 space_info->reservation_progress++;
f0486c68 4046 spin_unlock(&space_info->lock);
4e06bdd6 4047 }
9ed74f2d 4048 }
f0486c68 4049}
4e06bdd6 4050
f0486c68
YZ
4051static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
4052 struct btrfs_block_rsv *dst, u64 num_bytes)
4053{
4054 int ret;
9ed74f2d 4055
f0486c68
YZ
4056 ret = block_rsv_use_bytes(src, num_bytes);
4057 if (ret)
4058 return ret;
9ed74f2d 4059
f0486c68 4060 block_rsv_add_bytes(dst, num_bytes, 1);
9ed74f2d
JB
4061 return 0;
4062}
4063
f0486c68 4064void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv)
9ed74f2d 4065{
f0486c68
YZ
4066 memset(rsv, 0, sizeof(*rsv));
4067 spin_lock_init(&rsv->lock);
f0486c68
YZ
4068}
4069
4070struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
4071{
4072 struct btrfs_block_rsv *block_rsv;
4073 struct btrfs_fs_info *fs_info = root->fs_info;
9ed74f2d 4074
f0486c68
YZ
4075 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
4076 if (!block_rsv)
4077 return NULL;
9ed74f2d 4078
f0486c68 4079 btrfs_init_block_rsv(block_rsv);
f0486c68
YZ
4080 block_rsv->space_info = __find_space_info(fs_info,
4081 BTRFS_BLOCK_GROUP_METADATA);
f0486c68
YZ
4082 return block_rsv;
4083}
9ed74f2d 4084
f0486c68
YZ
4085void btrfs_free_block_rsv(struct btrfs_root *root,
4086 struct btrfs_block_rsv *rsv)
4087{
dabdb640
JB
4088 btrfs_block_rsv_release(root, rsv, (u64)-1);
4089 kfree(rsv);
9ed74f2d
JB
4090}
4091
61b520a9
MX
4092static inline int __block_rsv_add(struct btrfs_root *root,
4093 struct btrfs_block_rsv *block_rsv,
4094 u64 num_bytes, int flush)
9ed74f2d 4095{
f0486c68 4096 int ret;
9ed74f2d 4097
f0486c68
YZ
4098 if (num_bytes == 0)
4099 return 0;
8bb8ab2e 4100
61b520a9 4101 ret = reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
f0486c68
YZ
4102 if (!ret) {
4103 block_rsv_add_bytes(block_rsv, num_bytes, 1);
4104 return 0;
4105 }
9ed74f2d 4106
f0486c68 4107 return ret;
f0486c68 4108}
9ed74f2d 4109
61b520a9
MX
4110int btrfs_block_rsv_add(struct btrfs_root *root,
4111 struct btrfs_block_rsv *block_rsv,
4112 u64 num_bytes)
4113{
4114 return __block_rsv_add(root, block_rsv, num_bytes, 1);
4115}
4116
c06a0e12
JB
4117int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
4118 struct btrfs_block_rsv *block_rsv,
4119 u64 num_bytes)
f0486c68 4120{
61b520a9 4121 return __block_rsv_add(root, block_rsv, num_bytes, 0);
f0486c68 4122}
9ed74f2d 4123
4a92b1b8 4124int btrfs_block_rsv_check(struct btrfs_root *root,
36ba022a 4125 struct btrfs_block_rsv *block_rsv, int min_factor)
f0486c68
YZ
4126{
4127 u64 num_bytes = 0;
f0486c68 4128 int ret = -ENOSPC;
9ed74f2d 4129
f0486c68
YZ
4130 if (!block_rsv)
4131 return 0;
9ed74f2d 4132
f0486c68 4133 spin_lock(&block_rsv->lock);
36ba022a
JB
4134 num_bytes = div_factor(block_rsv->size, min_factor);
4135 if (block_rsv->reserved >= num_bytes)
4136 ret = 0;
4137 spin_unlock(&block_rsv->lock);
9ed74f2d 4138
36ba022a
JB
4139 return ret;
4140}
4141
aa38a711
MX
4142static inline int __btrfs_block_rsv_refill(struct btrfs_root *root,
4143 struct btrfs_block_rsv *block_rsv,
4144 u64 min_reserved, int flush)
36ba022a
JB
4145{
4146 u64 num_bytes = 0;
4147 int ret = -ENOSPC;
4148
4149 if (!block_rsv)
4150 return 0;
4151
4152 spin_lock(&block_rsv->lock);
4153 num_bytes = min_reserved;
13553e52 4154 if (block_rsv->reserved >= num_bytes)
f0486c68 4155 ret = 0;
13553e52 4156 else
f0486c68 4157 num_bytes -= block_rsv->reserved;
f0486c68 4158 spin_unlock(&block_rsv->lock);
13553e52 4159
f0486c68
YZ
4160 if (!ret)
4161 return 0;
4162
aa38a711 4163 ret = reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
dabdb640
JB
4164 if (!ret) {
4165 block_rsv_add_bytes(block_rsv, num_bytes, 0);
f0486c68 4166 return 0;
6a63209f 4167 }
9ed74f2d 4168
13553e52 4169 return ret;
f0486c68
YZ
4170}
4171
aa38a711
MX
4172int btrfs_block_rsv_refill(struct btrfs_root *root,
4173 struct btrfs_block_rsv *block_rsv,
4174 u64 min_reserved)
4175{
4176 return __btrfs_block_rsv_refill(root, block_rsv, min_reserved, 1);
4177}
4178
4179int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
4180 struct btrfs_block_rsv *block_rsv,
4181 u64 min_reserved)
4182{
4183 return __btrfs_block_rsv_refill(root, block_rsv, min_reserved, 0);
4184}
4185
f0486c68
YZ
4186int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
4187 struct btrfs_block_rsv *dst_rsv,
4188 u64 num_bytes)
4189{
4190 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
4191}
4192
4193void btrfs_block_rsv_release(struct btrfs_root *root,
4194 struct btrfs_block_rsv *block_rsv,
4195 u64 num_bytes)
4196{
4197 struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
4198 if (global_rsv->full || global_rsv == block_rsv ||
4199 block_rsv->space_info != global_rsv->space_info)
4200 global_rsv = NULL;
8c2a3ca2
JB
4201 block_rsv_release_bytes(root->fs_info, block_rsv, global_rsv,
4202 num_bytes);
6a63209f
JB
4203}
4204
4205/*
8929ecfa
YZ
4206 * helper to calculate size of global block reservation.
4207 * the desired value is sum of space used by extent tree,
4208 * checksum tree and root tree
6a63209f 4209 */
8929ecfa 4210static u64 calc_global_metadata_size(struct btrfs_fs_info *fs_info)
6a63209f 4211{
8929ecfa
YZ
4212 struct btrfs_space_info *sinfo;
4213 u64 num_bytes;
4214 u64 meta_used;
4215 u64 data_used;
6c41761f 4216 int csum_size = btrfs_super_csum_size(fs_info->super_copy);
6a63209f 4217
8929ecfa
YZ
4218 sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);
4219 spin_lock(&sinfo->lock);
4220 data_used = sinfo->bytes_used;
4221 spin_unlock(&sinfo->lock);
33b4d47f 4222
8929ecfa
YZ
4223 sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
4224 spin_lock(&sinfo->lock);
6d48755d
JB
4225 if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA)
4226 data_used = 0;
8929ecfa
YZ
4227 meta_used = sinfo->bytes_used;
4228 spin_unlock(&sinfo->lock);
ab6e2410 4229
8929ecfa
YZ
4230 num_bytes = (data_used >> fs_info->sb->s_blocksize_bits) *
4231 csum_size * 2;
4232 num_bytes += div64_u64(data_used + meta_used, 50);
4e06bdd6 4233
8929ecfa 4234 if (num_bytes * 3 > meta_used)
8e62c2de 4235 num_bytes = div64_u64(meta_used, 3);
ab6e2410 4236
8929ecfa
YZ
4237 return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10);
4238}
6a63209f 4239
8929ecfa
YZ
4240static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
4241{
4242 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
4243 struct btrfs_space_info *sinfo = block_rsv->space_info;
4244 u64 num_bytes;
6a63209f 4245
8929ecfa 4246 num_bytes = calc_global_metadata_size(fs_info);
33b4d47f 4247
8929ecfa 4248 spin_lock(&sinfo->lock);
1f699d38 4249 spin_lock(&block_rsv->lock);
4e06bdd6 4250
8929ecfa 4251 block_rsv->size = num_bytes;
4e06bdd6 4252
8929ecfa 4253 num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +
6d48755d
JB
4254 sinfo->bytes_reserved + sinfo->bytes_readonly +
4255 sinfo->bytes_may_use;
8929ecfa
YZ
4256
4257 if (sinfo->total_bytes > num_bytes) {
4258 num_bytes = sinfo->total_bytes - num_bytes;
4259 block_rsv->reserved += num_bytes;
fb25e914 4260 sinfo->bytes_may_use += num_bytes;
8c2a3ca2 4261 trace_btrfs_space_reservation(fs_info, "space_info",
2bcc0328 4262 sinfo->flags, num_bytes, 1);
6a63209f 4263 }
6a63209f 4264
8929ecfa
YZ
4265 if (block_rsv->reserved >= block_rsv->size) {
4266 num_bytes = block_rsv->reserved - block_rsv->size;
fb25e914 4267 sinfo->bytes_may_use -= num_bytes;
8c2a3ca2 4268 trace_btrfs_space_reservation(fs_info, "space_info",
2bcc0328 4269 sinfo->flags, num_bytes, 0);
36e39c40 4270 sinfo->reservation_progress++;
8929ecfa
YZ
4271 block_rsv->reserved = block_rsv->size;
4272 block_rsv->full = 1;
4273 }
182608c8 4274
8929ecfa 4275 spin_unlock(&block_rsv->lock);
1f699d38 4276 spin_unlock(&sinfo->lock);
6a63209f
JB
4277}
4278
f0486c68 4279static void init_global_block_rsv(struct btrfs_fs_info *fs_info)
6a63209f 4280{
f0486c68 4281 struct btrfs_space_info *space_info;
6a63209f 4282
f0486c68
YZ
4283 space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
4284 fs_info->chunk_block_rsv.space_info = space_info;
6a63209f 4285
f0486c68 4286 space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
8929ecfa 4287 fs_info->global_block_rsv.space_info = space_info;
8929ecfa 4288 fs_info->delalloc_block_rsv.space_info = space_info;
f0486c68
YZ
4289 fs_info->trans_block_rsv.space_info = space_info;
4290 fs_info->empty_block_rsv.space_info = space_info;
6d668dda 4291 fs_info->delayed_block_rsv.space_info = space_info;
f0486c68 4292
8929ecfa
YZ
4293 fs_info->extent_root->block_rsv = &fs_info->global_block_rsv;
4294 fs_info->csum_root->block_rsv = &fs_info->global_block_rsv;
4295 fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
4296 fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
f0486c68 4297 fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
8929ecfa 4298
8929ecfa 4299 update_global_block_rsv(fs_info);
6a63209f
JB
4300}
4301
8929ecfa 4302static void release_global_block_rsv(struct btrfs_fs_info *fs_info)
6a63209f 4303{
8c2a3ca2
JB
4304 block_rsv_release_bytes(fs_info, &fs_info->global_block_rsv, NULL,
4305 (u64)-1);
8929ecfa
YZ
4306 WARN_ON(fs_info->delalloc_block_rsv.size > 0);
4307 WARN_ON(fs_info->delalloc_block_rsv.reserved > 0);
4308 WARN_ON(fs_info->trans_block_rsv.size > 0);
4309 WARN_ON(fs_info->trans_block_rsv.reserved > 0);
4310 WARN_ON(fs_info->chunk_block_rsv.size > 0);
4311 WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
6d668dda
JB
4312 WARN_ON(fs_info->delayed_block_rsv.size > 0);
4313 WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
fcb80c2a
JB
4314}
4315
a22285a6
YZ
4316void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
4317 struct btrfs_root *root)
6a63209f 4318{
0e721106
JB
4319 if (!trans->block_rsv)
4320 return;
4321
a22285a6
YZ
4322 if (!trans->bytes_reserved)
4323 return;
6a63209f 4324
e77266e4 4325 trace_btrfs_space_reservation(root->fs_info, "transaction",
2bcc0328 4326 trans->transid, trans->bytes_reserved, 0);
b24e03db 4327 btrfs_block_rsv_release(root, trans->block_rsv, trans->bytes_reserved);
a22285a6
YZ
4328 trans->bytes_reserved = 0;
4329}
6a63209f 4330
79787eaa 4331/* Can only return 0 or -ENOSPC */
d68fc57b
YZ
4332int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
4333 struct inode *inode)
4334{
4335 struct btrfs_root *root = BTRFS_I(inode)->root;
4336 struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
4337 struct btrfs_block_rsv *dst_rsv = root->orphan_block_rsv;
4338
4339 /*
fcb80c2a
JB
4340 * We need to hold space in order to delete our orphan item once we've
4341 * added it, so this takes the reservation so we can release it later
4342 * when we are truly done with the orphan item.
d68fc57b 4343 */
ff5714cc 4344 u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
8c2a3ca2
JB
4345 trace_btrfs_space_reservation(root->fs_info, "orphan",
4346 btrfs_ino(inode), num_bytes, 1);
d68fc57b 4347 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
6a63209f
JB
4348}
4349
d68fc57b 4350void btrfs_orphan_release_metadata(struct inode *inode)
97e728d4 4351{
d68fc57b 4352 struct btrfs_root *root = BTRFS_I(inode)->root;
ff5714cc 4353 u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
8c2a3ca2
JB
4354 trace_btrfs_space_reservation(root->fs_info, "orphan",
4355 btrfs_ino(inode), num_bytes, 0);
d68fc57b
YZ
4356 btrfs_block_rsv_release(root, root->orphan_block_rsv, num_bytes);
4357}
97e728d4 4358
a22285a6
YZ
4359int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
4360 struct btrfs_pending_snapshot *pending)
4361{
4362 struct btrfs_root *root = pending->root;
4363 struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
4364 struct btrfs_block_rsv *dst_rsv = &pending->block_rsv;
4365 /*
4366 * two for root back/forward refs, two for directory entries
4367 * and one for root of the snapshot.
4368 */
16cdcec7 4369 u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5);
a22285a6
YZ
4370 dst_rsv->space_info = src_rsv->space_info;
4371 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
97e728d4
JB
4372}
4373
7709cde3
JB
4374/**
4375 * drop_outstanding_extent - drop an outstanding extent
4376 * @inode: the inode we're dropping the extent for
4377 *
4378 * This is called when we are freeing up an outstanding extent, either called
4379 * after an error or after an extent is written. This will return the number of
4380 * reserved extents that need to be freed. This must be called with
4381 * BTRFS_I(inode)->lock held.
4382 */
9e0baf60
JB
4383static unsigned drop_outstanding_extent(struct inode *inode)
4384{
7fd2ae21 4385 unsigned drop_inode_space = 0;
9e0baf60
JB
4386 unsigned dropped_extents = 0;
4387
9e0baf60
JB
4388 BUG_ON(!BTRFS_I(inode)->outstanding_extents);
4389 BTRFS_I(inode)->outstanding_extents--;
4390
7fd2ae21 4391 if (BTRFS_I(inode)->outstanding_extents == 0 &&
72ac3c0d
JB
4392 test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4393 &BTRFS_I(inode)->runtime_flags))
7fd2ae21 4394 drop_inode_space = 1;
7fd2ae21 4395
9e0baf60
JB
4396 /*
4397 * If we have more or the same amount of outsanding extents than we have
4398 * reserved then we need to leave the reserved extents count alone.
4399 */
4400 if (BTRFS_I(inode)->outstanding_extents >=
4401 BTRFS_I(inode)->reserved_extents)
7fd2ae21 4402 return drop_inode_space;
9e0baf60
JB
4403
4404 dropped_extents = BTRFS_I(inode)->reserved_extents -
4405 BTRFS_I(inode)->outstanding_extents;
4406 BTRFS_I(inode)->reserved_extents -= dropped_extents;
7fd2ae21 4407 return dropped_extents + drop_inode_space;
9e0baf60
JB
4408}
4409
7709cde3
JB
4410/**
4411 * calc_csum_metadata_size - return the amount of metada space that must be
4412 * reserved/free'd for the given bytes.
4413 * @inode: the inode we're manipulating
4414 * @num_bytes: the number of bytes in question
4415 * @reserve: 1 if we are reserving space, 0 if we are freeing space
4416 *
4417 * This adjusts the number of csum_bytes in the inode and then returns the
4418 * correct amount of metadata that must either be reserved or freed. We
4419 * calculate how many checksums we can fit into one leaf and then divide the
4420 * number of bytes that will need to be checksumed by this value to figure out
4421 * how many checksums will be required. If we are adding bytes then the number
4422 * may go up and we will return the number of additional bytes that must be
4423 * reserved. If it is going down we will return the number of bytes that must
4424 * be freed.
4425 *
4426 * This must be called with BTRFS_I(inode)->lock held.
4427 */
4428static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes,
4429 int reserve)
6324fbf3 4430{
7709cde3
JB
4431 struct btrfs_root *root = BTRFS_I(inode)->root;
4432 u64 csum_size;
4433 int num_csums_per_leaf;
4434 int num_csums;
4435 int old_csums;
4436
4437 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM &&
4438 BTRFS_I(inode)->csum_bytes == 0)
4439 return 0;
4440
4441 old_csums = (int)div64_u64(BTRFS_I(inode)->csum_bytes, root->sectorsize);
4442 if (reserve)
4443 BTRFS_I(inode)->csum_bytes += num_bytes;
4444 else
4445 BTRFS_I(inode)->csum_bytes -= num_bytes;
4446 csum_size = BTRFS_LEAF_DATA_SIZE(root) - sizeof(struct btrfs_item);
4447 num_csums_per_leaf = (int)div64_u64(csum_size,
4448 sizeof(struct btrfs_csum_item) +
4449 sizeof(struct btrfs_disk_key));
4450 num_csums = (int)div64_u64(BTRFS_I(inode)->csum_bytes, root->sectorsize);
4451 num_csums = num_csums + num_csums_per_leaf - 1;
4452 num_csums = num_csums / num_csums_per_leaf;
4453
4454 old_csums = old_csums + num_csums_per_leaf - 1;
4455 old_csums = old_csums / num_csums_per_leaf;
4456
4457 /* No change, no need to reserve more */
4458 if (old_csums == num_csums)
4459 return 0;
4460
4461 if (reserve)
4462 return btrfs_calc_trans_metadata_size(root,
4463 num_csums - old_csums);
4464
4465 return btrfs_calc_trans_metadata_size(root, old_csums - num_csums);
0ca1f7ce 4466}
c146afad 4467
0ca1f7ce
YZ
4468int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
4469{
4470 struct btrfs_root *root = BTRFS_I(inode)->root;
4471 struct btrfs_block_rsv *block_rsv = &root->fs_info->delalloc_block_rsv;
9e0baf60 4472 u64 to_reserve = 0;
660d3f6c 4473 u64 csum_bytes;
9e0baf60 4474 unsigned nr_extents = 0;
660d3f6c 4475 int extra_reserve = 0;
c09544e0 4476 int flush = 1;
0ca1f7ce 4477 int ret;
6324fbf3 4478
660d3f6c 4479 /* Need to be holding the i_mutex here if we aren't free space cache */
c09544e0
JB
4480 if (btrfs_is_free_space_inode(root, inode))
4481 flush = 0;
4482
4483 if (flush && btrfs_transaction_in_commit(root->fs_info))
0ca1f7ce 4484 schedule_timeout(1);
ec44a35c 4485
f248679e 4486 mutex_lock(&BTRFS_I(inode)->delalloc_mutex);
0ca1f7ce 4487 num_bytes = ALIGN(num_bytes, root->sectorsize);
8bb8ab2e 4488
9e0baf60
JB
4489 spin_lock(&BTRFS_I(inode)->lock);
4490 BTRFS_I(inode)->outstanding_extents++;
4491
4492 if (BTRFS_I(inode)->outstanding_extents >
660d3f6c 4493 BTRFS_I(inode)->reserved_extents)
9e0baf60
JB
4494 nr_extents = BTRFS_I(inode)->outstanding_extents -
4495 BTRFS_I(inode)->reserved_extents;
57a45ced 4496
7fd2ae21
JB
4497 /*
4498 * Add an item to reserve for updating the inode when we complete the
4499 * delalloc io.
4500 */
72ac3c0d
JB
4501 if (!test_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4502 &BTRFS_I(inode)->runtime_flags)) {
7fd2ae21 4503 nr_extents++;
660d3f6c 4504 extra_reserve = 1;
593060d7 4505 }
7fd2ae21
JB
4506
4507 to_reserve = btrfs_calc_trans_metadata_size(root, nr_extents);
7709cde3 4508 to_reserve += calc_csum_metadata_size(inode, num_bytes, 1);
660d3f6c 4509 csum_bytes = BTRFS_I(inode)->csum_bytes;
9e0baf60 4510 spin_unlock(&BTRFS_I(inode)->lock);
57a45ced 4511
36ba022a 4512 ret = reserve_metadata_bytes(root, block_rsv, to_reserve, flush);
9e0baf60 4513 if (ret) {
7ed49f18 4514 u64 to_free = 0;
9e0baf60 4515 unsigned dropped;
7ed49f18 4516
7709cde3 4517 spin_lock(&BTRFS_I(inode)->lock);
9e0baf60 4518 dropped = drop_outstanding_extent(inode);
9e0baf60 4519 /*
660d3f6c
JB
4520 * If the inodes csum_bytes is the same as the original
4521 * csum_bytes then we know we haven't raced with any free()ers
4522 * so we can just reduce our inodes csum bytes and carry on.
4523 * Otherwise we have to do the normal free thing to account for
4524 * the case that the free side didn't free up its reserve
4525 * because of this outstanding reservation.
9e0baf60 4526 */
660d3f6c
JB
4527 if (BTRFS_I(inode)->csum_bytes == csum_bytes)
4528 calc_csum_metadata_size(inode, num_bytes, 0);
4529 else
4530 to_free = calc_csum_metadata_size(inode, num_bytes, 0);
4531 spin_unlock(&BTRFS_I(inode)->lock);
4532 if (dropped)
4533 to_free += btrfs_calc_trans_metadata_size(root, dropped);
4534
8c2a3ca2 4535 if (to_free) {
7ed49f18 4536 btrfs_block_rsv_release(root, block_rsv, to_free);
8c2a3ca2
JB
4537 trace_btrfs_space_reservation(root->fs_info,
4538 "delalloc",
4539 btrfs_ino(inode),
4540 to_free, 0);
4541 }
f248679e 4542 mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
0ca1f7ce 4543 return ret;
9e0baf60 4544 }
25179201 4545
660d3f6c
JB
4546 spin_lock(&BTRFS_I(inode)->lock);
4547 if (extra_reserve) {
72ac3c0d
JB
4548 set_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4549 &BTRFS_I(inode)->runtime_flags);
660d3f6c
JB
4550 nr_extents--;
4551 }
4552 BTRFS_I(inode)->reserved_extents += nr_extents;
4553 spin_unlock(&BTRFS_I(inode)->lock);
f248679e 4554 mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
660d3f6c 4555
8c2a3ca2
JB
4556 if (to_reserve)
4557 trace_btrfs_space_reservation(root->fs_info,"delalloc",
4558 btrfs_ino(inode), to_reserve, 1);
0ca1f7ce
YZ
4559 block_rsv_add_bytes(block_rsv, to_reserve, 1);
4560
0ca1f7ce
YZ
4561 return 0;
4562}
4563
7709cde3
JB
4564/**
4565 * btrfs_delalloc_release_metadata - release a metadata reservation for an inode
4566 * @inode: the inode to release the reservation for
4567 * @num_bytes: the number of bytes we're releasing
4568 *
4569 * This will release the metadata reservation for an inode. This can be called
4570 * once we complete IO for a given set of bytes to release their metadata
4571 * reservations.
4572 */
0ca1f7ce
YZ
4573void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
4574{
4575 struct btrfs_root *root = BTRFS_I(inode)->root;
9e0baf60
JB
4576 u64 to_free = 0;
4577 unsigned dropped;
0ca1f7ce
YZ
4578
4579 num_bytes = ALIGN(num_bytes, root->sectorsize);
7709cde3 4580 spin_lock(&BTRFS_I(inode)->lock);
9e0baf60 4581 dropped = drop_outstanding_extent(inode);
97e728d4 4582
7709cde3
JB
4583 to_free = calc_csum_metadata_size(inode, num_bytes, 0);
4584 spin_unlock(&BTRFS_I(inode)->lock);
9e0baf60
JB
4585 if (dropped > 0)
4586 to_free += btrfs_calc_trans_metadata_size(root, dropped);
0ca1f7ce 4587
8c2a3ca2
JB
4588 trace_btrfs_space_reservation(root->fs_info, "delalloc",
4589 btrfs_ino(inode), to_free, 0);
0ca1f7ce
YZ
4590 btrfs_block_rsv_release(root, &root->fs_info->delalloc_block_rsv,
4591 to_free);
4592}
4593
7709cde3
JB
4594/**
4595 * btrfs_delalloc_reserve_space - reserve data and metadata space for delalloc
4596 * @inode: inode we're writing to
4597 * @num_bytes: the number of bytes we want to allocate
4598 *
4599 * This will do the following things
4600 *
4601 * o reserve space in the data space info for num_bytes
4602 * o reserve space in the metadata space info based on number of outstanding
4603 * extents and how much csums will be needed
4604 * o add to the inodes ->delalloc_bytes
4605 * o add it to the fs_info's delalloc inodes list.
4606 *
4607 * This will return 0 for success and -ENOSPC if there is no space left.
4608 */
0ca1f7ce
YZ
4609int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes)
4610{
4611 int ret;
4612
4613 ret = btrfs_check_data_free_space(inode, num_bytes);
d397712b 4614 if (ret)
0ca1f7ce
YZ
4615 return ret;
4616
4617 ret = btrfs_delalloc_reserve_metadata(inode, num_bytes);
4618 if (ret) {
4619 btrfs_free_reserved_data_space(inode, num_bytes);
4620 return ret;
4621 }
4622
4623 return 0;
4624}
4625
7709cde3
JB
4626/**
4627 * btrfs_delalloc_release_space - release data and metadata space for delalloc
4628 * @inode: inode we're releasing space for
4629 * @num_bytes: the number of bytes we want to free up
4630 *
4631 * This must be matched with a call to btrfs_delalloc_reserve_space. This is
4632 * called in the case that we don't need the metadata AND data reservations
4633 * anymore. So if there is an error or we insert an inline extent.
4634 *
4635 * This function will release the metadata space that was not used and will
4636 * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes
4637 * list if there are no delalloc bytes left.
4638 */
0ca1f7ce
YZ
4639void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes)
4640{
4641 btrfs_delalloc_release_metadata(inode, num_bytes);
4642 btrfs_free_reserved_data_space(inode, num_bytes);
6324fbf3
CM
4643}
4644
9078a3e1
CM
4645static int update_block_group(struct btrfs_trans_handle *trans,
4646 struct btrfs_root *root,
f0486c68 4647 u64 bytenr, u64 num_bytes, int alloc)
9078a3e1 4648{
0af3d00b 4649 struct btrfs_block_group_cache *cache = NULL;
9078a3e1 4650 struct btrfs_fs_info *info = root->fs_info;
db94535d 4651 u64 total = num_bytes;
9078a3e1 4652 u64 old_val;
db94535d 4653 u64 byte_in_group;
0af3d00b 4654 int factor;
3e1ad54f 4655
5d4f98a2
YZ
4656 /* block accounting for super block */
4657 spin_lock(&info->delalloc_lock);
6c41761f 4658 old_val = btrfs_super_bytes_used(info->super_copy);
5d4f98a2
YZ
4659 if (alloc)
4660 old_val += num_bytes;
4661 else
4662 old_val -= num_bytes;
6c41761f 4663 btrfs_set_super_bytes_used(info->super_copy, old_val);
5d4f98a2
YZ
4664 spin_unlock(&info->delalloc_lock);
4665
d397712b 4666 while (total) {
db94535d 4667 cache = btrfs_lookup_block_group(info, bytenr);
f3465ca4 4668 if (!cache)
79787eaa 4669 return -ENOENT;
b742bb82
YZ
4670 if (cache->flags & (BTRFS_BLOCK_GROUP_DUP |
4671 BTRFS_BLOCK_GROUP_RAID1 |
4672 BTRFS_BLOCK_GROUP_RAID10))
4673 factor = 2;
4674 else
4675 factor = 1;
9d66e233
JB
4676 /*
4677 * If this block group has free space cache written out, we
4678 * need to make sure to load it if we are removing space. This
4679 * is because we need the unpinning stage to actually add the
4680 * space back to the block group, otherwise we will leak space.
4681 */
4682 if (!alloc && cache->cached == BTRFS_CACHE_NO)
b8399dee 4683 cache_block_group(cache, trans, NULL, 1);
0af3d00b 4684
db94535d
CM
4685 byte_in_group = bytenr - cache->key.objectid;
4686 WARN_ON(byte_in_group > cache->key.offset);
9078a3e1 4687
25179201 4688 spin_lock(&cache->space_info->lock);
c286ac48 4689 spin_lock(&cache->lock);
0af3d00b 4690
73bc1876 4691 if (btrfs_test_opt(root, SPACE_CACHE) &&
0af3d00b
JB
4692 cache->disk_cache_state < BTRFS_DC_CLEAR)
4693 cache->disk_cache_state = BTRFS_DC_CLEAR;
4694
0f9dd46c 4695 cache->dirty = 1;
9078a3e1 4696 old_val = btrfs_block_group_used(&cache->item);
db94535d 4697 num_bytes = min(total, cache->key.offset - byte_in_group);
cd1bc465 4698 if (alloc) {
db94535d 4699 old_val += num_bytes;
11833d66
YZ
4700 btrfs_set_block_group_used(&cache->item, old_val);
4701 cache->reserved -= num_bytes;
11833d66 4702 cache->space_info->bytes_reserved -= num_bytes;
b742bb82
YZ
4703 cache->space_info->bytes_used += num_bytes;
4704 cache->space_info->disk_used += num_bytes * factor;
c286ac48 4705 spin_unlock(&cache->lock);
25179201 4706 spin_unlock(&cache->space_info->lock);
cd1bc465 4707 } else {
db94535d 4708 old_val -= num_bytes;
c286ac48 4709 btrfs_set_block_group_used(&cache->item, old_val);
f0486c68
YZ
4710 cache->pinned += num_bytes;
4711 cache->space_info->bytes_pinned += num_bytes;
6324fbf3 4712 cache->space_info->bytes_used -= num_bytes;
b742bb82 4713 cache->space_info->disk_used -= num_bytes * factor;
c286ac48 4714 spin_unlock(&cache->lock);
25179201 4715 spin_unlock(&cache->space_info->lock);
1f3c79a2 4716
f0486c68
YZ
4717 set_extent_dirty(info->pinned_extents,
4718 bytenr, bytenr + num_bytes - 1,
4719 GFP_NOFS | __GFP_NOFAIL);
cd1bc465 4720 }
fa9c0d79 4721 btrfs_put_block_group(cache);
db94535d
CM
4722 total -= num_bytes;
4723 bytenr += num_bytes;
9078a3e1
CM
4724 }
4725 return 0;
4726}
6324fbf3 4727
a061fc8d
CM
4728static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
4729{
0f9dd46c 4730 struct btrfs_block_group_cache *cache;
d2fb3437 4731 u64 bytenr;
0f9dd46c
JB
4732
4733 cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
4734 if (!cache)
a061fc8d 4735 return 0;
0f9dd46c 4736
d2fb3437 4737 bytenr = cache->key.objectid;
fa9c0d79 4738 btrfs_put_block_group(cache);
d2fb3437
YZ
4739
4740 return bytenr;
a061fc8d
CM
4741}
4742
f0486c68
YZ
4743static int pin_down_extent(struct btrfs_root *root,
4744 struct btrfs_block_group_cache *cache,
4745 u64 bytenr, u64 num_bytes, int reserved)
324ae4df 4746{
11833d66
YZ
4747 spin_lock(&cache->space_info->lock);
4748 spin_lock(&cache->lock);
4749 cache->pinned += num_bytes;
4750 cache->space_info->bytes_pinned += num_bytes;
4751 if (reserved) {
4752 cache->reserved -= num_bytes;
4753 cache->space_info->bytes_reserved -= num_bytes;
4754 }
4755 spin_unlock(&cache->lock);
4756 spin_unlock(&cache->space_info->lock);
68b38550 4757
f0486c68
YZ
4758 set_extent_dirty(root->fs_info->pinned_extents, bytenr,
4759 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);
4760 return 0;
4761}
68b38550 4762
f0486c68
YZ
4763/*
4764 * this function must be called within transaction
4765 */
4766int btrfs_pin_extent(struct btrfs_root *root,
4767 u64 bytenr, u64 num_bytes, int reserved)
4768{
4769 struct btrfs_block_group_cache *cache;
68b38550 4770
f0486c68 4771 cache = btrfs_lookup_block_group(root->fs_info, bytenr);
79787eaa 4772 BUG_ON(!cache); /* Logic error */
f0486c68
YZ
4773
4774 pin_down_extent(root, cache, bytenr, num_bytes, reserved);
4775
4776 btrfs_put_block_group(cache);
11833d66
YZ
4777 return 0;
4778}
4779
f0486c68 4780/*
e688b725
CM
4781 * this function must be called within transaction
4782 */
4783int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
4784 struct btrfs_root *root,
4785 u64 bytenr, u64 num_bytes)
4786{
4787 struct btrfs_block_group_cache *cache;
4788
4789 cache = btrfs_lookup_block_group(root->fs_info, bytenr);
79787eaa 4790 BUG_ON(!cache); /* Logic error */
e688b725
CM
4791
4792 /*
4793 * pull in the free space cache (if any) so that our pin
4794 * removes the free space from the cache. We have load_only set
4795 * to one because the slow code to read in the free extents does check
4796 * the pinned extents.
4797 */
4798 cache_block_group(cache, trans, root, 1);
4799
4800 pin_down_extent(root, cache, bytenr, num_bytes, 0);
4801
4802 /* remove us from the free space cache (if we're there at all) */
4803 btrfs_remove_free_space(cache, bytenr, num_bytes);
4804 btrfs_put_block_group(cache);
4805 return 0;
4806}
4807
fb25e914
JB
4808/**
4809 * btrfs_update_reserved_bytes - update the block_group and space info counters
4810 * @cache: The cache we are manipulating
4811 * @num_bytes: The number of bytes in question
4812 * @reserve: One of the reservation enums
4813 *
4814 * This is called by the allocator when it reserves space, or by somebody who is
4815 * freeing space that was never actually used on disk. For example if you
4816 * reserve some space for a new leaf in transaction A and before transaction A
4817 * commits you free that leaf, you call this with reserve set to 0 in order to
4818 * clear the reservation.
4819 *
4820 * Metadata reservations should be called with RESERVE_ALLOC so we do the proper
4821 * ENOSPC accounting. For data we handle the reservation through clearing the
4822 * delalloc bits in the io_tree. We have to do this since we could end up
4823 * allocating less disk space for the amount of data we have reserved in the
4824 * case of compression.
4825 *
4826 * If this is a reservation and the block group has become read only we cannot
4827 * make the reservation and return -EAGAIN, otherwise this function always
4828 * succeeds.
f0486c68 4829 */
fb25e914
JB
4830static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
4831 u64 num_bytes, int reserve)
11833d66 4832{
fb25e914 4833 struct btrfs_space_info *space_info = cache->space_info;
f0486c68 4834 int ret = 0;
79787eaa 4835
fb25e914
JB
4836 spin_lock(&space_info->lock);
4837 spin_lock(&cache->lock);
4838 if (reserve != RESERVE_FREE) {
f0486c68
YZ
4839 if (cache->ro) {
4840 ret = -EAGAIN;
4841 } else {
fb25e914
JB
4842 cache->reserved += num_bytes;
4843 space_info->bytes_reserved += num_bytes;
4844 if (reserve == RESERVE_ALLOC) {
8c2a3ca2 4845 trace_btrfs_space_reservation(cache->fs_info,
2bcc0328
LB
4846 "space_info", space_info->flags,
4847 num_bytes, 0);
fb25e914
JB
4848 space_info->bytes_may_use -= num_bytes;
4849 }
f0486c68 4850 }
fb25e914
JB
4851 } else {
4852 if (cache->ro)
4853 space_info->bytes_readonly += num_bytes;
4854 cache->reserved -= num_bytes;
4855 space_info->bytes_reserved -= num_bytes;
4856 space_info->reservation_progress++;
324ae4df 4857 }
fb25e914
JB
4858 spin_unlock(&cache->lock);
4859 spin_unlock(&space_info->lock);
f0486c68 4860 return ret;
324ae4df 4861}
9078a3e1 4862
143bede5 4863void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
11833d66 4864 struct btrfs_root *root)
e8569813 4865{
e8569813 4866 struct btrfs_fs_info *fs_info = root->fs_info;
11833d66
YZ
4867 struct btrfs_caching_control *next;
4868 struct btrfs_caching_control *caching_ctl;
4869 struct btrfs_block_group_cache *cache;
e8569813 4870
11833d66 4871 down_write(&fs_info->extent_commit_sem);
25179201 4872
11833d66
YZ
4873 list_for_each_entry_safe(caching_ctl, next,
4874 &fs_info->caching_block_groups, list) {
4875 cache = caching_ctl->block_group;
4876 if (block_group_cache_done(cache)) {
4877 cache->last_byte_to_unpin = (u64)-1;
4878 list_del_init(&caching_ctl->list);
4879 put_caching_control(caching_ctl);
e8569813 4880 } else {
11833d66 4881 cache->last_byte_to_unpin = caching_ctl->progress;
e8569813 4882 }
e8569813 4883 }
11833d66
YZ
4884
4885 if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4886 fs_info->pinned_extents = &fs_info->freed_extents[1];
4887 else
4888 fs_info->pinned_extents = &fs_info->freed_extents[0];
4889
4890 up_write(&fs_info->extent_commit_sem);
8929ecfa
YZ
4891
4892 update_global_block_rsv(fs_info);
e8569813
ZY
4893}
4894
11833d66 4895static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
ccd467d6 4896{
11833d66
YZ
4897 struct btrfs_fs_info *fs_info = root->fs_info;
4898 struct btrfs_block_group_cache *cache = NULL;
4899 u64 len;
ccd467d6 4900
11833d66
YZ
4901 while (start <= end) {
4902 if (!cache ||
4903 start >= cache->key.objectid + cache->key.offset) {
4904 if (cache)
4905 btrfs_put_block_group(cache);
4906 cache = btrfs_lookup_block_group(fs_info, start);
79787eaa 4907 BUG_ON(!cache); /* Logic error */
11833d66
YZ
4908 }
4909
4910 len = cache->key.objectid + cache->key.offset - start;
4911 len = min(len, end + 1 - start);
4912
4913 if (start < cache->last_byte_to_unpin) {
4914 len = min(len, cache->last_byte_to_unpin - start);
4915 btrfs_add_free_space(cache, start, len);
4916 }
4917
f0486c68
YZ
4918 start += len;
4919
11833d66
YZ
4920 spin_lock(&cache->space_info->lock);
4921 spin_lock(&cache->lock);
4922 cache->pinned -= len;
4923 cache->space_info->bytes_pinned -= len;
37be25bc 4924 if (cache->ro)
f0486c68 4925 cache->space_info->bytes_readonly += len;
11833d66
YZ
4926 spin_unlock(&cache->lock);
4927 spin_unlock(&cache->space_info->lock);
ccd467d6 4928 }
11833d66
YZ
4929
4930 if (cache)
4931 btrfs_put_block_group(cache);
ccd467d6
CM
4932 return 0;
4933}
4934
4935int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
11833d66 4936 struct btrfs_root *root)
a28ec197 4937{
11833d66
YZ
4938 struct btrfs_fs_info *fs_info = root->fs_info;
4939 struct extent_io_tree *unpin;
1a5bc167
CM
4940 u64 start;
4941 u64 end;
a28ec197 4942 int ret;
a28ec197 4943
79787eaa
JM
4944 if (trans->aborted)
4945 return 0;
4946
11833d66
YZ
4947 if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4948 unpin = &fs_info->freed_extents[1];
4949 else
4950 unpin = &fs_info->freed_extents[0];
4951
d397712b 4952 while (1) {
1a5bc167
CM
4953 ret = find_first_extent_bit(unpin, 0, &start, &end,
4954 EXTENT_DIRTY);
4955 if (ret)
a28ec197 4956 break;
1f3c79a2 4957
5378e607
LD
4958 if (btrfs_test_opt(root, DISCARD))
4959 ret = btrfs_discard_extent(root, start,
4960 end + 1 - start, NULL);
1f3c79a2 4961
1a5bc167 4962 clear_extent_dirty(unpin, start, end, GFP_NOFS);
11833d66 4963 unpin_extent_range(root, start, end);
b9473439 4964 cond_resched();
a28ec197 4965 }
817d52f8 4966
e20d96d6
CM
4967 return 0;
4968}
4969
5d4f98a2
YZ
4970static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
4971 struct btrfs_root *root,
4972 u64 bytenr, u64 num_bytes, u64 parent,
4973 u64 root_objectid, u64 owner_objectid,
4974 u64 owner_offset, int refs_to_drop,
4975 struct btrfs_delayed_extent_op *extent_op)
a28ec197 4976{
e2fa7227 4977 struct btrfs_key key;
5d4f98a2 4978 struct btrfs_path *path;
1261ec42
CM
4979 struct btrfs_fs_info *info = root->fs_info;
4980 struct btrfs_root *extent_root = info->extent_root;
5f39d397 4981 struct extent_buffer *leaf;
5d4f98a2
YZ
4982 struct btrfs_extent_item *ei;
4983 struct btrfs_extent_inline_ref *iref;
a28ec197 4984 int ret;
5d4f98a2 4985 int is_data;
952fccac
CM
4986 int extent_slot = 0;
4987 int found_extent = 0;
4988 int num_to_del = 1;
5d4f98a2
YZ
4989 u32 item_size;
4990 u64 refs;
037e6390 4991
5caf2a00 4992 path = btrfs_alloc_path();
54aa1f4d
CM
4993 if (!path)
4994 return -ENOMEM;
5f26f772 4995
3c12ac72 4996 path->reada = 1;
b9473439 4997 path->leave_spinning = 1;
5d4f98a2
YZ
4998
4999 is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
5000 BUG_ON(!is_data && refs_to_drop != 1);
5001
5002 ret = lookup_extent_backref(trans, extent_root, path, &iref,
5003 bytenr, num_bytes, parent,
5004 root_objectid, owner_objectid,
5005 owner_offset);
7bb86316 5006 if (ret == 0) {
952fccac 5007 extent_slot = path->slots[0];
5d4f98a2
YZ
5008 while (extent_slot >= 0) {
5009 btrfs_item_key_to_cpu(path->nodes[0], &key,
952fccac 5010 extent_slot);
5d4f98a2 5011 if (key.objectid != bytenr)
952fccac 5012 break;
5d4f98a2
YZ
5013 if (key.type == BTRFS_EXTENT_ITEM_KEY &&
5014 key.offset == num_bytes) {
952fccac
CM
5015 found_extent = 1;
5016 break;
5017 }
5018 if (path->slots[0] - extent_slot > 5)
5019 break;
5d4f98a2 5020 extent_slot--;
952fccac 5021 }
5d4f98a2
YZ
5022#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5023 item_size = btrfs_item_size_nr(path->nodes[0], extent_slot);
5024 if (found_extent && item_size < sizeof(*ei))
5025 found_extent = 0;
5026#endif
31840ae1 5027 if (!found_extent) {
5d4f98a2 5028 BUG_ON(iref);
56bec294 5029 ret = remove_extent_backref(trans, extent_root, path,
5d4f98a2
YZ
5030 NULL, refs_to_drop,
5031 is_data);
79787eaa
JM
5032 if (ret)
5033 goto abort;
b3b4aa74 5034 btrfs_release_path(path);
b9473439 5035 path->leave_spinning = 1;
5d4f98a2
YZ
5036
5037 key.objectid = bytenr;
5038 key.type = BTRFS_EXTENT_ITEM_KEY;
5039 key.offset = num_bytes;
5040
31840ae1
ZY
5041 ret = btrfs_search_slot(trans, extent_root,
5042 &key, path, -1, 1);
f3465ca4
JB
5043 if (ret) {
5044 printk(KERN_ERR "umm, got %d back from search"
d397712b
CM
5045 ", was looking for %llu\n", ret,
5046 (unsigned long long)bytenr);
b783e62d
JB
5047 if (ret > 0)
5048 btrfs_print_leaf(extent_root,
5049 path->nodes[0]);
f3465ca4 5050 }
79787eaa
JM
5051 if (ret < 0)
5052 goto abort;
31840ae1
ZY
5053 extent_slot = path->slots[0];
5054 }
79787eaa 5055 } else if (ret == -ENOENT) {
7bb86316
CM
5056 btrfs_print_leaf(extent_root, path->nodes[0]);
5057 WARN_ON(1);
d397712b 5058 printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
5d4f98a2 5059 "parent %llu root %llu owner %llu offset %llu\n",
d397712b 5060 (unsigned long long)bytenr,
56bec294 5061 (unsigned long long)parent,
d397712b 5062 (unsigned long long)root_objectid,
5d4f98a2
YZ
5063 (unsigned long long)owner_objectid,
5064 (unsigned long long)owner_offset);
79787eaa
JM
5065 } else {
5066 goto abort;
7bb86316 5067 }
5f39d397
CM
5068
5069 leaf = path->nodes[0];
5d4f98a2
YZ
5070 item_size = btrfs_item_size_nr(leaf, extent_slot);
5071#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5072 if (item_size < sizeof(*ei)) {
5073 BUG_ON(found_extent || extent_slot != path->slots[0]);
5074 ret = convert_extent_item_v0(trans, extent_root, path,
5075 owner_objectid, 0);
79787eaa
JM
5076 if (ret < 0)
5077 goto abort;
5d4f98a2 5078
b3b4aa74 5079 btrfs_release_path(path);
5d4f98a2
YZ
5080 path->leave_spinning = 1;
5081
5082 key.objectid = bytenr;
5083 key.type = BTRFS_EXTENT_ITEM_KEY;
5084 key.offset = num_bytes;
5085
5086 ret = btrfs_search_slot(trans, extent_root, &key, path,
5087 -1, 1);
5088 if (ret) {
5089 printk(KERN_ERR "umm, got %d back from search"
5090 ", was looking for %llu\n", ret,
5091 (unsigned long long)bytenr);
5092 btrfs_print_leaf(extent_root, path->nodes[0]);
5093 }
79787eaa
JM
5094 if (ret < 0)
5095 goto abort;
5d4f98a2
YZ
5096 extent_slot = path->slots[0];
5097 leaf = path->nodes[0];
5098 item_size = btrfs_item_size_nr(leaf, extent_slot);
5099 }
5100#endif
5101 BUG_ON(item_size < sizeof(*ei));
952fccac 5102 ei = btrfs_item_ptr(leaf, extent_slot,
123abc88 5103 struct btrfs_extent_item);
5d4f98a2
YZ
5104 if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID) {
5105 struct btrfs_tree_block_info *bi;
5106 BUG_ON(item_size < sizeof(*ei) + sizeof(*bi));
5107 bi = (struct btrfs_tree_block_info *)(ei + 1);
5108 WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
5109 }
56bec294 5110
5d4f98a2 5111 refs = btrfs_extent_refs(leaf, ei);
56bec294
CM
5112 BUG_ON(refs < refs_to_drop);
5113 refs -= refs_to_drop;
5f39d397 5114
5d4f98a2
YZ
5115 if (refs > 0) {
5116 if (extent_op)
5117 __run_delayed_extent_op(extent_op, leaf, ei);
5118 /*
5119 * In the case of inline back ref, reference count will
5120 * be updated by remove_extent_backref
952fccac 5121 */
5d4f98a2
YZ
5122 if (iref) {
5123 BUG_ON(!found_extent);
5124 } else {
5125 btrfs_set_extent_refs(leaf, ei, refs);
5126 btrfs_mark_buffer_dirty(leaf);
5127 }
5128 if (found_extent) {
5129 ret = remove_extent_backref(trans, extent_root, path,
5130 iref, refs_to_drop,
5131 is_data);
79787eaa
JM
5132 if (ret)
5133 goto abort;
952fccac 5134 }
5d4f98a2 5135 } else {
5d4f98a2
YZ
5136 if (found_extent) {
5137 BUG_ON(is_data && refs_to_drop !=
5138 extent_data_ref_count(root, path, iref));
5139 if (iref) {
5140 BUG_ON(path->slots[0] != extent_slot);
5141 } else {
5142 BUG_ON(path->slots[0] != extent_slot + 1);
5143 path->slots[0] = extent_slot;
5144 num_to_del = 2;
5145 }
78fae27e 5146 }
b9473439 5147
952fccac
CM
5148 ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
5149 num_to_del);
79787eaa
JM
5150 if (ret)
5151 goto abort;
b3b4aa74 5152 btrfs_release_path(path);
21af804c 5153
5d4f98a2 5154 if (is_data) {
459931ec 5155 ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
79787eaa
JM
5156 if (ret)
5157 goto abort;
459931ec
CM
5158 }
5159
f0486c68 5160 ret = update_block_group(trans, root, bytenr, num_bytes, 0);
79787eaa
JM
5161 if (ret)
5162 goto abort;
a28ec197 5163 }
79787eaa 5164out:
5caf2a00 5165 btrfs_free_path(path);
a28ec197 5166 return ret;
79787eaa
JM
5167
5168abort:
5169 btrfs_abort_transaction(trans, extent_root, ret);
5170 goto out;
a28ec197
CM
5171}
5172
1887be66 5173/*
f0486c68 5174 * when we free an block, it is possible (and likely) that we free the last
1887be66
CM
5175 * delayed ref for that extent as well. This searches the delayed ref tree for
5176 * a given extent, and if there are no other delayed refs to be processed, it
5177 * removes it from the tree.
5178 */
5179static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
5180 struct btrfs_root *root, u64 bytenr)
5181{
5182 struct btrfs_delayed_ref_head *head;
5183 struct btrfs_delayed_ref_root *delayed_refs;
5184 struct btrfs_delayed_ref_node *ref;
5185 struct rb_node *node;
f0486c68 5186 int ret = 0;
1887be66
CM
5187
5188 delayed_refs = &trans->transaction->delayed_refs;
5189 spin_lock(&delayed_refs->lock);
5190 head = btrfs_find_delayed_ref_head(trans, bytenr);
5191 if (!head)
5192 goto out;
5193
5194 node = rb_prev(&head->node.rb_node);
5195 if (!node)
5196 goto out;
5197
5198 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
5199
5200 /* there are still entries for this ref, we can't drop it */
5201 if (ref->bytenr == bytenr)
5202 goto out;
5203
5d4f98a2
YZ
5204 if (head->extent_op) {
5205 if (!head->must_insert_reserved)
5206 goto out;
5207 kfree(head->extent_op);
5208 head->extent_op = NULL;
5209 }
5210
1887be66
CM
5211 /*
5212 * waiting for the lock here would deadlock. If someone else has it
5213 * locked they are already in the process of dropping it anyway
5214 */
5215 if (!mutex_trylock(&head->mutex))
5216 goto out;
5217
5218 /*
5219 * at this point we have a head with no other entries. Go
5220 * ahead and process it.
5221 */
5222 head->node.in_tree = 0;
5223 rb_erase(&head->node.rb_node, &delayed_refs->root);
c3e69d58 5224
1887be66 5225 delayed_refs->num_entries--;
a168650c
JS
5226 if (waitqueue_active(&delayed_refs->seq_wait))
5227 wake_up(&delayed_refs->seq_wait);
1887be66
CM
5228
5229 /*
5230 * we don't take a ref on the node because we're removing it from the
5231 * tree, so we just steal the ref the tree was holding.
5232 */
c3e69d58
CM
5233 delayed_refs->num_heads--;
5234 if (list_empty(&head->cluster))
5235 delayed_refs->num_heads_ready--;
5236
5237 list_del_init(&head->cluster);
1887be66
CM
5238 spin_unlock(&delayed_refs->lock);
5239
f0486c68
YZ
5240 BUG_ON(head->extent_op);
5241 if (head->must_insert_reserved)
5242 ret = 1;
5243
5244 mutex_unlock(&head->mutex);
1887be66 5245 btrfs_put_delayed_ref(&head->node);
f0486c68 5246 return ret;
1887be66
CM
5247out:
5248 spin_unlock(&delayed_refs->lock);
5249 return 0;
5250}
5251
f0486c68
YZ
5252void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
5253 struct btrfs_root *root,
5254 struct extent_buffer *buf,
5581a51a 5255 u64 parent, int last_ref)
f0486c68 5256{
f0486c68
YZ
5257 struct btrfs_block_group_cache *cache = NULL;
5258 int ret;
5259
5260 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
66d7e7f0
AJ
5261 ret = btrfs_add_delayed_tree_ref(root->fs_info, trans,
5262 buf->start, buf->len,
5263 parent, root->root_key.objectid,
5264 btrfs_header_level(buf),
5581a51a 5265 BTRFS_DROP_DELAYED_REF, NULL, 0);
79787eaa 5266 BUG_ON(ret); /* -ENOMEM */
f0486c68
YZ
5267 }
5268
5269 if (!last_ref)
5270 return;
5271
f0486c68 5272 cache = btrfs_lookup_block_group(root->fs_info, buf->start);
f0486c68
YZ
5273
5274 if (btrfs_header_generation(buf) == trans->transid) {
5275 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
5276 ret = check_ref_cleanup(trans, root, buf->start);
5277 if (!ret)
37be25bc 5278 goto out;
f0486c68
YZ
5279 }
5280
5281 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
5282 pin_down_extent(root, cache, buf->start, buf->len, 1);
37be25bc 5283 goto out;
f0486c68
YZ
5284 }
5285
5286 WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
5287
5288 btrfs_add_free_space(cache, buf->start, buf->len);
fb25e914 5289 btrfs_update_reserved_bytes(cache, buf->len, RESERVE_FREE);
f0486c68
YZ
5290 }
5291out:
a826d6dc
JB
5292 /*
5293 * Deleting the buffer, clear the corrupt flag since it doesn't matter
5294 * anymore.
5295 */
5296 clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);
f0486c68
YZ
5297 btrfs_put_block_group(cache);
5298}
5299
79787eaa 5300/* Can return -ENOMEM */
66d7e7f0
AJ
5301int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root,
5302 u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
5303 u64 owner, u64 offset, int for_cow)
925baedd
CM
5304{
5305 int ret;
66d7e7f0 5306 struct btrfs_fs_info *fs_info = root->fs_info;
925baedd 5307
56bec294
CM
5308 /*
5309 * tree log blocks never actually go into the extent allocation
5310 * tree, just update pinning info and exit early.
56bec294 5311 */
5d4f98a2
YZ
5312 if (root_objectid == BTRFS_TREE_LOG_OBJECTID) {
5313 WARN_ON(owner >= BTRFS_FIRST_FREE_OBJECTID);
b9473439 5314 /* unlocks the pinned mutex */
11833d66 5315 btrfs_pin_extent(root, bytenr, num_bytes, 1);
56bec294 5316 ret = 0;
5d4f98a2 5317 } else if (owner < BTRFS_FIRST_FREE_OBJECTID) {
66d7e7f0
AJ
5318 ret = btrfs_add_delayed_tree_ref(fs_info, trans, bytenr,
5319 num_bytes,
5d4f98a2 5320 parent, root_objectid, (int)owner,
66d7e7f0 5321 BTRFS_DROP_DELAYED_REF, NULL, for_cow);
5d4f98a2 5322 } else {
66d7e7f0
AJ
5323 ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr,
5324 num_bytes,
5325 parent, root_objectid, owner,
5326 offset, BTRFS_DROP_DELAYED_REF,
5327 NULL, for_cow);
56bec294 5328 }
925baedd
CM
5329 return ret;
5330}
5331
87ee04eb
CM
5332static u64 stripe_align(struct btrfs_root *root, u64 val)
5333{
5334 u64 mask = ((u64)root->stripesize - 1);
5335 u64 ret = (val + mask) & ~mask;
5336 return ret;
5337}
5338
817d52f8
JB
5339/*
5340 * when we wait for progress in the block group caching, its because
5341 * our allocation attempt failed at least once. So, we must sleep
5342 * and let some progress happen before we try again.
5343 *
5344 * This function will sleep at least once waiting for new free space to
5345 * show up, and then it will check the block group free space numbers
5346 * for our min num_bytes. Another option is to have it go ahead
5347 * and look in the rbtree for a free extent of a given size, but this
5348 * is a good start.
5349 */
5350static noinline int
5351wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
5352 u64 num_bytes)
5353{
11833d66 5354 struct btrfs_caching_control *caching_ctl;
817d52f8
JB
5355 DEFINE_WAIT(wait);
5356
11833d66
YZ
5357 caching_ctl = get_caching_control(cache);
5358 if (!caching_ctl)
817d52f8 5359 return 0;
817d52f8 5360
11833d66 5361 wait_event(caching_ctl->wait, block_group_cache_done(cache) ||
34d52cb6 5362 (cache->free_space_ctl->free_space >= num_bytes));
11833d66
YZ
5363
5364 put_caching_control(caching_ctl);
5365 return 0;
5366}
5367
5368static noinline int
5369wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
5370{
5371 struct btrfs_caching_control *caching_ctl;
5372 DEFINE_WAIT(wait);
5373
5374 caching_ctl = get_caching_control(cache);
5375 if (!caching_ctl)
5376 return 0;
5377
5378 wait_event(caching_ctl->wait, block_group_cache_done(cache));
5379
5380 put_caching_control(caching_ctl);
817d52f8
JB
5381 return 0;
5382}
5383
7738a53a 5384static int __get_block_group_index(u64 flags)
b742bb82
YZ
5385{
5386 int index;
7738a53a
ID
5387
5388 if (flags & BTRFS_BLOCK_GROUP_RAID10)
b742bb82 5389 index = 0;
7738a53a 5390 else if (flags & BTRFS_BLOCK_GROUP_RAID1)
b742bb82 5391 index = 1;
7738a53a 5392 else if (flags & BTRFS_BLOCK_GROUP_DUP)
b742bb82 5393 index = 2;
7738a53a 5394 else if (flags & BTRFS_BLOCK_GROUP_RAID0)
b742bb82
YZ
5395 index = 3;
5396 else
5397 index = 4;
7738a53a 5398
b742bb82
YZ
5399 return index;
5400}
5401
7738a53a
ID
5402static int get_block_group_index(struct btrfs_block_group_cache *cache)
5403{
5404 return __get_block_group_index(cache->flags);
5405}
5406
817d52f8 5407enum btrfs_loop_type {
285ff5af
JB
5408 LOOP_CACHING_NOWAIT = 0,
5409 LOOP_CACHING_WAIT = 1,
5410 LOOP_ALLOC_CHUNK = 2,
5411 LOOP_NO_EMPTY_SIZE = 3,
817d52f8
JB
5412};
5413
fec577fb
CM
5414/*
5415 * walks the btree of allocated extents and find a hole of a given size.
5416 * The key ins is changed to record the hole:
5417 * ins->objectid == block start
62e2749e 5418 * ins->flags = BTRFS_EXTENT_ITEM_KEY
fec577fb
CM
5419 * ins->offset == number of blocks
5420 * Any available blocks before search_start are skipped.
5421 */
d397712b 5422static noinline int find_free_extent(struct btrfs_trans_handle *trans,
98ed5174
CM
5423 struct btrfs_root *orig_root,
5424 u64 num_bytes, u64 empty_size,
98ed5174 5425 u64 hint_byte, struct btrfs_key *ins,
e0f54067 5426 u64 data)
fec577fb 5427{
80eb234a 5428 int ret = 0;
d397712b 5429 struct btrfs_root *root = orig_root->fs_info->extent_root;
fa9c0d79 5430 struct btrfs_free_cluster *last_ptr = NULL;
80eb234a 5431 struct btrfs_block_group_cache *block_group = NULL;
274bd4fb 5432 struct btrfs_block_group_cache *used_block_group;
81c9ad23 5433 u64 search_start = 0;
239b14b3 5434 int empty_cluster = 2 * 1024 * 1024;
0ef3e66b 5435 int allowed_chunk_alloc = 0;
ccf0e725 5436 int done_chunk_alloc = 0;
80eb234a 5437 struct btrfs_space_info *space_info;
fa9c0d79 5438 int loop = 0;
f0486c68 5439 int index = 0;
fb25e914
JB
5440 int alloc_type = (data & BTRFS_BLOCK_GROUP_DATA) ?
5441 RESERVE_ALLOC_NO_ACCOUNT : RESERVE_ALLOC;
817d52f8 5442 bool found_uncached_bg = false;
0a24325e 5443 bool failed_cluster_refill = false;
1cdda9b8 5444 bool failed_alloc = false;
67377734 5445 bool use_cluster = true;
60d2adbb 5446 bool have_caching_bg = false;
fec577fb 5447
db94535d 5448 WARN_ON(num_bytes < root->sectorsize);
b1a4d965 5449 btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
80eb234a
JB
5450 ins->objectid = 0;
5451 ins->offset = 0;
b1a4d965 5452
3f7de037
JB
5453 trace_find_free_extent(orig_root, num_bytes, empty_size, data);
5454
2552d17e 5455 space_info = __find_space_info(root->fs_info, data);
1b1d1f66 5456 if (!space_info) {
e0f54067 5457 printk(KERN_ERR "No space info for %llu\n", data);
1b1d1f66
JB
5458 return -ENOSPC;
5459 }
2552d17e 5460
67377734
JB
5461 /*
5462 * If the space info is for both data and metadata it means we have a
5463 * small filesystem and we can't use the clustering stuff.
5464 */
5465 if (btrfs_mixed_space_info(space_info))
5466 use_cluster = false;
5467
0ef3e66b
CM
5468 if (orig_root->ref_cows || empty_size)
5469 allowed_chunk_alloc = 1;
5470
67377734 5471 if (data & BTRFS_BLOCK_GROUP_METADATA && use_cluster) {
fa9c0d79 5472 last_ptr = &root->fs_info->meta_alloc_cluster;
536ac8ae
CM
5473 if (!btrfs_test_opt(root, SSD))
5474 empty_cluster = 64 * 1024;
239b14b3
CM
5475 }
5476
67377734
JB
5477 if ((data & BTRFS_BLOCK_GROUP_DATA) && use_cluster &&
5478 btrfs_test_opt(root, SSD)) {
fa9c0d79
CM
5479 last_ptr = &root->fs_info->data_alloc_cluster;
5480 }
0f9dd46c 5481
239b14b3 5482 if (last_ptr) {
fa9c0d79
CM
5483 spin_lock(&last_ptr->lock);
5484 if (last_ptr->block_group)
5485 hint_byte = last_ptr->window_start;
5486 spin_unlock(&last_ptr->lock);
239b14b3 5487 }
fa9c0d79 5488
a061fc8d 5489 search_start = max(search_start, first_logical_byte(root, 0));
239b14b3 5490 search_start = max(search_start, hint_byte);
0b86a832 5491
817d52f8 5492 if (!last_ptr)
fa9c0d79 5493 empty_cluster = 0;
fa9c0d79 5494
2552d17e 5495 if (search_start == hint_byte) {
2552d17e
JB
5496 block_group = btrfs_lookup_block_group(root->fs_info,
5497 search_start);
274bd4fb 5498 used_block_group = block_group;
817d52f8
JB
5499 /*
5500 * we don't want to use the block group if it doesn't match our
5501 * allocation bits, or if its not cached.
ccf0e725
JB
5502 *
5503 * However if we are re-searching with an ideal block group
5504 * picked out then we don't care that the block group is cached.
817d52f8
JB
5505 */
5506 if (block_group && block_group_bits(block_group, data) &&
285ff5af 5507 block_group->cached != BTRFS_CACHE_NO) {
2552d17e 5508 down_read(&space_info->groups_sem);
44fb5511
CM
5509 if (list_empty(&block_group->list) ||
5510 block_group->ro) {
5511 /*
5512 * someone is removing this block group,
5513 * we can't jump into the have_block_group
5514 * target because our list pointers are not
5515 * valid
5516 */
5517 btrfs_put_block_group(block_group);
5518 up_read(&space_info->groups_sem);
ccf0e725 5519 } else {
b742bb82 5520 index = get_block_group_index(block_group);
44fb5511 5521 goto have_block_group;
ccf0e725 5522 }
2552d17e 5523 } else if (block_group) {
fa9c0d79 5524 btrfs_put_block_group(block_group);
2552d17e 5525 }
42e70e7a 5526 }
2552d17e 5527search:
60d2adbb 5528 have_caching_bg = false;
80eb234a 5529 down_read(&space_info->groups_sem);
b742bb82
YZ
5530 list_for_each_entry(block_group, &space_info->block_groups[index],
5531 list) {
6226cb0a 5532 u64 offset;
817d52f8 5533 int cached;
8a1413a2 5534
274bd4fb 5535 used_block_group = block_group;
11dfe35a 5536 btrfs_get_block_group(block_group);
2552d17e 5537 search_start = block_group->key.objectid;
42e70e7a 5538
83a50de9
CM
5539 /*
5540 * this can happen if we end up cycling through all the
5541 * raid types, but we want to make sure we only allocate
5542 * for the proper type.
5543 */
5544 if (!block_group_bits(block_group, data)) {
5545 u64 extra = BTRFS_BLOCK_GROUP_DUP |
5546 BTRFS_BLOCK_GROUP_RAID1 |
5547 BTRFS_BLOCK_GROUP_RAID10;
5548
5549 /*
5550 * if they asked for extra copies and this block group
5551 * doesn't provide them, bail. This does allow us to
5552 * fill raid0 from raid1.
5553 */
5554 if ((data & extra) && !(block_group->flags & extra))
5555 goto loop;
5556 }
5557
2552d17e 5558have_block_group:
291c7d2f
JB
5559 cached = block_group_cache_done(block_group);
5560 if (unlikely(!cached)) {
291c7d2f 5561 found_uncached_bg = true;
b8399dee 5562 ret = cache_block_group(block_group, trans,
285ff5af 5563 orig_root, 0);
1d4284bd
CM
5564 BUG_ON(ret < 0);
5565 ret = 0;
817d52f8
JB
5566 }
5567
ea6a478e 5568 if (unlikely(block_group->ro))
2552d17e 5569 goto loop;
0f9dd46c 5570
0a24325e 5571 /*
062c05c4
AO
5572 * Ok we want to try and use the cluster allocator, so
5573 * lets look there
0a24325e 5574 */
062c05c4 5575 if (last_ptr) {
fa9c0d79
CM
5576 /*
5577 * the refill lock keeps out other
5578 * people trying to start a new cluster
5579 */
5580 spin_lock(&last_ptr->refill_lock);
274bd4fb
AO
5581 used_block_group = last_ptr->block_group;
5582 if (used_block_group != block_group &&
5583 (!used_block_group ||
5584 used_block_group->ro ||
5585 !block_group_bits(used_block_group, data))) {
5586 used_block_group = block_group;
44fb5511 5587 goto refill_cluster;
274bd4fb
AO
5588 }
5589
5590 if (used_block_group != block_group)
5591 btrfs_get_block_group(used_block_group);
44fb5511 5592
274bd4fb
AO
5593 offset = btrfs_alloc_from_cluster(used_block_group,
5594 last_ptr, num_bytes, used_block_group->key.objectid);
fa9c0d79
CM
5595 if (offset) {
5596 /* we have a block, we're done */
5597 spin_unlock(&last_ptr->refill_lock);
3f7de037
JB
5598 trace_btrfs_reserve_extent_cluster(root,
5599 block_group, search_start, num_bytes);
fa9c0d79
CM
5600 goto checks;
5601 }
5602
274bd4fb
AO
5603 WARN_ON(last_ptr->block_group != used_block_group);
5604 if (used_block_group != block_group) {
5605 btrfs_put_block_group(used_block_group);
5606 used_block_group = block_group;
fa9c0d79 5607 }
44fb5511 5608refill_cluster:
274bd4fb 5609 BUG_ON(used_block_group != block_group);
062c05c4
AO
5610 /* If we are on LOOP_NO_EMPTY_SIZE, we can't
5611 * set up a new clusters, so lets just skip it
5612 * and let the allocator find whatever block
5613 * it can find. If we reach this point, we
5614 * will have tried the cluster allocator
5615 * plenty of times and not have found
5616 * anything, so we are likely way too
5617 * fragmented for the clustering stuff to find
a5f6f719
AO
5618 * anything.
5619 *
5620 * However, if the cluster is taken from the
5621 * current block group, release the cluster
5622 * first, so that we stand a better chance of
5623 * succeeding in the unclustered
5624 * allocation. */
5625 if (loop >= LOOP_NO_EMPTY_SIZE &&
5626 last_ptr->block_group != block_group) {
062c05c4
AO
5627 spin_unlock(&last_ptr->refill_lock);
5628 goto unclustered_alloc;
5629 }
5630
fa9c0d79
CM
5631 /*
5632 * this cluster didn't work out, free it and
5633 * start over
5634 */
5635 btrfs_return_cluster_to_free_space(NULL, last_ptr);
5636
a5f6f719
AO
5637 if (loop >= LOOP_NO_EMPTY_SIZE) {
5638 spin_unlock(&last_ptr->refill_lock);
5639 goto unclustered_alloc;
5640 }
5641
fa9c0d79 5642 /* allocate a cluster in this block group */
451d7585 5643 ret = btrfs_find_space_cluster(trans, root,
fa9c0d79 5644 block_group, last_ptr,
1b22bad7 5645 search_start, num_bytes,
fa9c0d79
CM
5646 empty_cluster + empty_size);
5647 if (ret == 0) {
5648 /*
5649 * now pull our allocation out of this
5650 * cluster
5651 */
5652 offset = btrfs_alloc_from_cluster(block_group,
5653 last_ptr, num_bytes,
5654 search_start);
5655 if (offset) {
5656 /* we found one, proceed */
5657 spin_unlock(&last_ptr->refill_lock);
3f7de037
JB
5658 trace_btrfs_reserve_extent_cluster(root,
5659 block_group, search_start,
5660 num_bytes);
fa9c0d79
CM
5661 goto checks;
5662 }
0a24325e
JB
5663 } else if (!cached && loop > LOOP_CACHING_NOWAIT
5664 && !failed_cluster_refill) {
817d52f8
JB
5665 spin_unlock(&last_ptr->refill_lock);
5666
0a24325e 5667 failed_cluster_refill = true;
817d52f8
JB
5668 wait_block_group_cache_progress(block_group,
5669 num_bytes + empty_cluster + empty_size);
5670 goto have_block_group;
fa9c0d79 5671 }
817d52f8 5672
fa9c0d79
CM
5673 /*
5674 * at this point we either didn't find a cluster
5675 * or we weren't able to allocate a block from our
5676 * cluster. Free the cluster we've been trying
5677 * to use, and go to the next block group
5678 */
0a24325e 5679 btrfs_return_cluster_to_free_space(NULL, last_ptr);
fa9c0d79 5680 spin_unlock(&last_ptr->refill_lock);
0a24325e 5681 goto loop;
fa9c0d79
CM
5682 }
5683
062c05c4 5684unclustered_alloc:
a5f6f719
AO
5685 spin_lock(&block_group->free_space_ctl->tree_lock);
5686 if (cached &&
5687 block_group->free_space_ctl->free_space <
5688 num_bytes + empty_cluster + empty_size) {
5689 spin_unlock(&block_group->free_space_ctl->tree_lock);
5690 goto loop;
5691 }
5692 spin_unlock(&block_group->free_space_ctl->tree_lock);
5693
6226cb0a
JB
5694 offset = btrfs_find_space_for_alloc(block_group, search_start,
5695 num_bytes, empty_size);
1cdda9b8
JB
5696 /*
5697 * If we didn't find a chunk, and we haven't failed on this
5698 * block group before, and this block group is in the middle of
5699 * caching and we are ok with waiting, then go ahead and wait
5700 * for progress to be made, and set failed_alloc to true.
5701 *
5702 * If failed_alloc is true then we've already waited on this
5703 * block group once and should move on to the next block group.
5704 */
5705 if (!offset && !failed_alloc && !cached &&
5706 loop > LOOP_CACHING_NOWAIT) {
817d52f8 5707 wait_block_group_cache_progress(block_group,
1cdda9b8
JB
5708 num_bytes + empty_size);
5709 failed_alloc = true;
817d52f8 5710 goto have_block_group;
1cdda9b8 5711 } else if (!offset) {
60d2adbb
MX
5712 if (!cached)
5713 have_caching_bg = true;
1cdda9b8 5714 goto loop;
817d52f8 5715 }
fa9c0d79 5716checks:
6226cb0a 5717 search_start = stripe_align(root, offset);
25179201 5718
2552d17e
JB
5719 /* move on to the next group */
5720 if (search_start + num_bytes >
274bd4fb
AO
5721 used_block_group->key.objectid + used_block_group->key.offset) {
5722 btrfs_add_free_space(used_block_group, offset, num_bytes);
2552d17e 5723 goto loop;
6226cb0a 5724 }
f5a31e16 5725
f0486c68 5726 if (offset < search_start)
274bd4fb 5727 btrfs_add_free_space(used_block_group, offset,
f0486c68
YZ
5728 search_start - offset);
5729 BUG_ON(offset > search_start);
2552d17e 5730
274bd4fb 5731 ret = btrfs_update_reserved_bytes(used_block_group, num_bytes,
fb25e914 5732 alloc_type);
f0486c68 5733 if (ret == -EAGAIN) {
274bd4fb 5734 btrfs_add_free_space(used_block_group, offset, num_bytes);
2552d17e 5735 goto loop;
0f9dd46c 5736 }
0b86a832 5737
f0486c68 5738 /* we are all good, lets return */
2552d17e
JB
5739 ins->objectid = search_start;
5740 ins->offset = num_bytes;
d2fb3437 5741
3f7de037
JB
5742 trace_btrfs_reserve_extent(orig_root, block_group,
5743 search_start, num_bytes);
6226cb0a 5744 if (offset < search_start)
274bd4fb 5745 btrfs_add_free_space(used_block_group, offset,
6226cb0a
JB
5746 search_start - offset);
5747 BUG_ON(offset > search_start);
274bd4fb
AO
5748 if (used_block_group != block_group)
5749 btrfs_put_block_group(used_block_group);
d82a6f1d 5750 btrfs_put_block_group(block_group);
2552d17e
JB
5751 break;
5752loop:
0a24325e 5753 failed_cluster_refill = false;
1cdda9b8 5754 failed_alloc = false;
b742bb82 5755 BUG_ON(index != get_block_group_index(block_group));
274bd4fb
AO
5756 if (used_block_group != block_group)
5757 btrfs_put_block_group(used_block_group);
fa9c0d79 5758 btrfs_put_block_group(block_group);
2552d17e
JB
5759 }
5760 up_read(&space_info->groups_sem);
5761
60d2adbb
MX
5762 if (!ins->objectid && loop >= LOOP_CACHING_WAIT && have_caching_bg)
5763 goto search;
5764
b742bb82
YZ
5765 if (!ins->objectid && ++index < BTRFS_NR_RAID_TYPES)
5766 goto search;
5767
285ff5af 5768 /*
ccf0e725
JB
5769 * LOOP_CACHING_NOWAIT, search partially cached block groups, kicking
5770 * caching kthreads as we move along
817d52f8
JB
5771 * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching
5772 * LOOP_ALLOC_CHUNK, force a chunk allocation and try again
5773 * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try
5774 * again
fa9c0d79 5775 */
723bda20 5776 if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE) {
b742bb82 5777 index = 0;
723bda20 5778 loop++;
817d52f8 5779 if (loop == LOOP_ALLOC_CHUNK) {
723bda20
JB
5780 if (allowed_chunk_alloc) {
5781 ret = do_chunk_alloc(trans, root, num_bytes +
5782 2 * 1024 * 1024, data,
5783 CHUNK_ALLOC_LIMITED);
79787eaa
JM
5784 if (ret < 0) {
5785 btrfs_abort_transaction(trans,
5786 root, ret);
5787 goto out;
5788 }
723bda20
JB
5789 allowed_chunk_alloc = 0;
5790 if (ret == 1)
5791 done_chunk_alloc = 1;
5792 } else if (!done_chunk_alloc &&
5793 space_info->force_alloc ==
5794 CHUNK_ALLOC_NO_FORCE) {
5795 space_info->force_alloc = CHUNK_ALLOC_LIMITED;
5796 }
2552d17e 5797
723bda20
JB
5798 /*
5799 * We didn't allocate a chunk, go ahead and drop the
5800 * empty size and loop again.
5801 */
5802 if (!done_chunk_alloc)
5803 loop = LOOP_NO_EMPTY_SIZE;
2552d17e
JB
5804 }
5805
723bda20
JB
5806 if (loop == LOOP_NO_EMPTY_SIZE) {
5807 empty_size = 0;
5808 empty_cluster = 0;
fa9c0d79 5809 }
723bda20
JB
5810
5811 goto search;
2552d17e
JB
5812 } else if (!ins->objectid) {
5813 ret = -ENOSPC;
d82a6f1d 5814 } else if (ins->objectid) {
80eb234a 5815 ret = 0;
be744175 5816 }
79787eaa 5817out:
be744175 5818
0f70abe2 5819 return ret;
fec577fb 5820}
ec44a35c 5821
9ed74f2d
JB
5822static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
5823 int dump_block_groups)
0f9dd46c
JB
5824{
5825 struct btrfs_block_group_cache *cache;
b742bb82 5826 int index = 0;
0f9dd46c 5827
9ed74f2d 5828 spin_lock(&info->lock);
fb25e914
JB
5829 printk(KERN_INFO "space_info %llu has %llu free, is %sfull\n",
5830 (unsigned long long)info->flags,
d397712b 5831 (unsigned long long)(info->total_bytes - info->bytes_used -
9ed74f2d 5832 info->bytes_pinned - info->bytes_reserved -
8929ecfa 5833 info->bytes_readonly),
d397712b 5834 (info->full) ? "" : "not ");
8929ecfa
YZ
5835 printk(KERN_INFO "space_info total=%llu, used=%llu, pinned=%llu, "
5836 "reserved=%llu, may_use=%llu, readonly=%llu\n",
21380931 5837 (unsigned long long)info->total_bytes,
8929ecfa 5838 (unsigned long long)info->bytes_used,
21380931 5839 (unsigned long long)info->bytes_pinned,
8929ecfa 5840 (unsigned long long)info->bytes_reserved,
21380931 5841 (unsigned long long)info->bytes_may_use,
8929ecfa 5842 (unsigned long long)info->bytes_readonly);
9ed74f2d
JB
5843 spin_unlock(&info->lock);
5844
5845 if (!dump_block_groups)
5846 return;
0f9dd46c 5847
80eb234a 5848 down_read(&info->groups_sem);
b742bb82
YZ
5849again:
5850 list_for_each_entry(cache, &info->block_groups[index], list) {
0f9dd46c 5851 spin_lock(&cache->lock);
d397712b
CM
5852 printk(KERN_INFO "block group %llu has %llu bytes, %llu used "
5853 "%llu pinned %llu reserved\n",
5854 (unsigned long long)cache->key.objectid,
5855 (unsigned long long)cache->key.offset,
5856 (unsigned long long)btrfs_block_group_used(&cache->item),
5857 (unsigned long long)cache->pinned,
5858 (unsigned long long)cache->reserved);
0f9dd46c
JB
5859 btrfs_dump_free_space(cache, bytes);
5860 spin_unlock(&cache->lock);
5861 }
b742bb82
YZ
5862 if (++index < BTRFS_NR_RAID_TYPES)
5863 goto again;
80eb234a 5864 up_read(&info->groups_sem);
0f9dd46c 5865}
e8569813 5866
11833d66
YZ
5867int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
5868 struct btrfs_root *root,
5869 u64 num_bytes, u64 min_alloc_size,
5870 u64 empty_size, u64 hint_byte,
81c9ad23 5871 struct btrfs_key *ins, u64 data)
fec577fb 5872{
9e622d6b 5873 bool final_tried = false;
fec577fb 5874 int ret;
925baedd 5875
6a63209f 5876 data = btrfs_get_alloc_profile(root, data);
98d20f67 5877again:
0ef3e66b
CM
5878 /*
5879 * the only place that sets empty_size is btrfs_realloc_node, which
5880 * is not called recursively on allocations
5881 */
79787eaa 5882 if (empty_size || root->ref_cows) {
6324fbf3 5883 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
0e4f8f88
CM
5884 num_bytes + 2 * 1024 * 1024, data,
5885 CHUNK_ALLOC_NO_FORCE);
79787eaa
JM
5886 if (ret < 0 && ret != -ENOSPC) {
5887 btrfs_abort_transaction(trans, root, ret);
5888 return ret;
5889 }
5890 }
0b86a832 5891
db94535d
CM
5892 WARN_ON(num_bytes < root->sectorsize);
5893 ret = find_free_extent(trans, root, num_bytes, empty_size,
81c9ad23 5894 hint_byte, ins, data);
3b951516 5895
9e622d6b
MX
5896 if (ret == -ENOSPC) {
5897 if (!final_tried) {
5898 num_bytes = num_bytes >> 1;
5899 num_bytes = num_bytes & ~(root->sectorsize - 1);
5900 num_bytes = max(num_bytes, min_alloc_size);
79787eaa 5901 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
9e622d6b 5902 num_bytes, data, CHUNK_ALLOC_FORCE);
79787eaa
JM
5903 if (ret < 0 && ret != -ENOSPC) {
5904 btrfs_abort_transaction(trans, root, ret);
5905 return ret;
5906 }
9e622d6b
MX
5907 if (num_bytes == min_alloc_size)
5908 final_tried = true;
5909 goto again;
5910 } else if (btrfs_test_opt(root, ENOSPC_DEBUG)) {
5911 struct btrfs_space_info *sinfo;
5912
5913 sinfo = __find_space_info(root->fs_info, data);
5914 printk(KERN_ERR "btrfs allocation failed flags %llu, "
5915 "wanted %llu\n", (unsigned long long)data,
5916 (unsigned long long)num_bytes);
53804280
JM
5917 if (sinfo)
5918 dump_space_info(sinfo, num_bytes, 1);
9e622d6b 5919 }
925baedd 5920 }
0f9dd46c 5921
1abe9b8a 5922 trace_btrfs_reserved_extent_alloc(root, ins->objectid, ins->offset);
5923
0f9dd46c 5924 return ret;
e6dcd2dc
CM
5925}
5926
e688b725
CM
5927static int __btrfs_free_reserved_extent(struct btrfs_root *root,
5928 u64 start, u64 len, int pin)
65b51a00 5929{
0f9dd46c 5930 struct btrfs_block_group_cache *cache;
1f3c79a2 5931 int ret = 0;
0f9dd46c 5932
0f9dd46c
JB
5933 cache = btrfs_lookup_block_group(root->fs_info, start);
5934 if (!cache) {
d397712b
CM
5935 printk(KERN_ERR "Unable to find block group for %llu\n",
5936 (unsigned long long)start);
0f9dd46c
JB
5937 return -ENOSPC;
5938 }
1f3c79a2 5939
5378e607
LD
5940 if (btrfs_test_opt(root, DISCARD))
5941 ret = btrfs_discard_extent(root, start, len, NULL);
1f3c79a2 5942
e688b725
CM
5943 if (pin)
5944 pin_down_extent(root, cache, start, len, 1);
5945 else {
5946 btrfs_add_free_space(cache, start, len);
5947 btrfs_update_reserved_bytes(cache, len, RESERVE_FREE);
5948 }
fa9c0d79 5949 btrfs_put_block_group(cache);
817d52f8 5950
1abe9b8a 5951 trace_btrfs_reserved_extent_free(root, start, len);
5952
e6dcd2dc
CM
5953 return ret;
5954}
5955
e688b725
CM
5956int btrfs_free_reserved_extent(struct btrfs_root *root,
5957 u64 start, u64 len)
5958{
5959 return __btrfs_free_reserved_extent(root, start, len, 0);
5960}
5961
5962int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
5963 u64 start, u64 len)
5964{
5965 return __btrfs_free_reserved_extent(root, start, len, 1);
5966}
5967
5d4f98a2
YZ
5968static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
5969 struct btrfs_root *root,
5970 u64 parent, u64 root_objectid,
5971 u64 flags, u64 owner, u64 offset,
5972 struct btrfs_key *ins, int ref_mod)
e6dcd2dc
CM
5973{
5974 int ret;
5d4f98a2 5975 struct btrfs_fs_info *fs_info = root->fs_info;
e6dcd2dc 5976 struct btrfs_extent_item *extent_item;
5d4f98a2 5977 struct btrfs_extent_inline_ref *iref;
e6dcd2dc 5978 struct btrfs_path *path;
5d4f98a2
YZ
5979 struct extent_buffer *leaf;
5980 int type;
5981 u32 size;
26b8003f 5982
5d4f98a2
YZ
5983 if (parent > 0)
5984 type = BTRFS_SHARED_DATA_REF_KEY;
5985 else
5986 type = BTRFS_EXTENT_DATA_REF_KEY;
58176a96 5987
5d4f98a2 5988 size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
7bb86316
CM
5989
5990 path = btrfs_alloc_path();
db5b493a
TI
5991 if (!path)
5992 return -ENOMEM;
47e4bb98 5993
b9473439 5994 path->leave_spinning = 1;
5d4f98a2
YZ
5995 ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
5996 ins, size);
79787eaa
JM
5997 if (ret) {
5998 btrfs_free_path(path);
5999 return ret;
6000 }
0f9dd46c 6001
5d4f98a2
YZ
6002 leaf = path->nodes[0];
6003 extent_item = btrfs_item_ptr(leaf, path->slots[0],
47e4bb98 6004 struct btrfs_extent_item);
5d4f98a2
YZ
6005 btrfs_set_extent_refs(leaf, extent_item, ref_mod);
6006 btrfs_set_extent_generation(leaf, extent_item, trans->transid);
6007 btrfs_set_extent_flags(leaf, extent_item,
6008 flags | BTRFS_EXTENT_FLAG_DATA);
6009
6010 iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
6011 btrfs_set_extent_inline_ref_type(leaf, iref, type);
6012 if (parent > 0) {
6013 struct btrfs_shared_data_ref *ref;
6014 ref = (struct btrfs_shared_data_ref *)(iref + 1);
6015 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
6016 btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
6017 } else {
6018 struct btrfs_extent_data_ref *ref;
6019 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
6020 btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
6021 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
6022 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
6023 btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
6024 }
47e4bb98
CM
6025
6026 btrfs_mark_buffer_dirty(path->nodes[0]);
7bb86316 6027 btrfs_free_path(path);
f510cfec 6028
f0486c68 6029 ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
79787eaa 6030 if (ret) { /* -ENOENT, logic error */
d397712b
CM
6031 printk(KERN_ERR "btrfs update block group failed for %llu "
6032 "%llu\n", (unsigned long long)ins->objectid,
6033 (unsigned long long)ins->offset);
f5947066
CM
6034 BUG();
6035 }
e6dcd2dc
CM
6036 return ret;
6037}
6038
5d4f98a2
YZ
6039static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
6040 struct btrfs_root *root,
6041 u64 parent, u64 root_objectid,
6042 u64 flags, struct btrfs_disk_key *key,
6043 int level, struct btrfs_key *ins)
e6dcd2dc
CM
6044{
6045 int ret;
5d4f98a2
YZ
6046 struct btrfs_fs_info *fs_info = root->fs_info;
6047 struct btrfs_extent_item *extent_item;
6048 struct btrfs_tree_block_info *block_info;
6049 struct btrfs_extent_inline_ref *iref;
6050 struct btrfs_path *path;
6051 struct extent_buffer *leaf;
6052 u32 size = sizeof(*extent_item) + sizeof(*block_info) + sizeof(*iref);
1c2308f8 6053
5d4f98a2 6054 path = btrfs_alloc_path();
d8926bb3
MF
6055 if (!path)
6056 return -ENOMEM;
56bec294 6057
5d4f98a2
YZ
6058 path->leave_spinning = 1;
6059 ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
6060 ins, size);
79787eaa
JM
6061 if (ret) {
6062 btrfs_free_path(path);
6063 return ret;
6064 }
5d4f98a2
YZ
6065
6066 leaf = path->nodes[0];
6067 extent_item = btrfs_item_ptr(leaf, path->slots[0],
6068 struct btrfs_extent_item);
6069 btrfs_set_extent_refs(leaf, extent_item, 1);
6070 btrfs_set_extent_generation(leaf, extent_item, trans->transid);
6071 btrfs_set_extent_flags(leaf, extent_item,
6072 flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
6073 block_info = (struct btrfs_tree_block_info *)(extent_item + 1);
6074
6075 btrfs_set_tree_block_key(leaf, block_info, key);
6076 btrfs_set_tree_block_level(leaf, block_info, level);
6077
6078 iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
6079 if (parent > 0) {
6080 BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
6081 btrfs_set_extent_inline_ref_type(leaf, iref,
6082 BTRFS_SHARED_BLOCK_REF_KEY);
6083 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
6084 } else {
6085 btrfs_set_extent_inline_ref_type(leaf, iref,
6086 BTRFS_TREE_BLOCK_REF_KEY);
6087 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
6088 }
6089
6090 btrfs_mark_buffer_dirty(leaf);
6091 btrfs_free_path(path);
6092
f0486c68 6093 ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
79787eaa 6094 if (ret) { /* -ENOENT, logic error */
5d4f98a2
YZ
6095 printk(KERN_ERR "btrfs update block group failed for %llu "
6096 "%llu\n", (unsigned long long)ins->objectid,
6097 (unsigned long long)ins->offset);
6098 BUG();
6099 }
6100 return ret;
6101}
6102
6103int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
6104 struct btrfs_root *root,
6105 u64 root_objectid, u64 owner,
6106 u64 offset, struct btrfs_key *ins)
6107{
6108 int ret;
6109
6110 BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);
6111
66d7e7f0
AJ
6112 ret = btrfs_add_delayed_data_ref(root->fs_info, trans, ins->objectid,
6113 ins->offset, 0,
6114 root_objectid, owner, offset,
6115 BTRFS_ADD_DELAYED_EXTENT, NULL, 0);
e6dcd2dc
CM
6116 return ret;
6117}
e02119d5
CM
6118
6119/*
6120 * this is used by the tree logging recovery code. It records that
6121 * an extent has been allocated and makes sure to clear the free
6122 * space cache bits as well
6123 */
5d4f98a2
YZ
6124int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
6125 struct btrfs_root *root,
6126 u64 root_objectid, u64 owner, u64 offset,
6127 struct btrfs_key *ins)
e02119d5
CM
6128{
6129 int ret;
6130 struct btrfs_block_group_cache *block_group;
11833d66
YZ
6131 struct btrfs_caching_control *caching_ctl;
6132 u64 start = ins->objectid;
6133 u64 num_bytes = ins->offset;
e02119d5 6134
e02119d5 6135 block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
b8399dee 6136 cache_block_group(block_group, trans, NULL, 0);
11833d66 6137 caching_ctl = get_caching_control(block_group);
e02119d5 6138
11833d66
YZ
6139 if (!caching_ctl) {
6140 BUG_ON(!block_group_cache_done(block_group));
6141 ret = btrfs_remove_free_space(block_group, start, num_bytes);
79787eaa 6142 BUG_ON(ret); /* -ENOMEM */
11833d66
YZ
6143 } else {
6144 mutex_lock(&caching_ctl->mutex);
6145
6146 if (start >= caching_ctl->progress) {
6147 ret = add_excluded_extent(root, start, num_bytes);
79787eaa 6148 BUG_ON(ret); /* -ENOMEM */
11833d66
YZ
6149 } else if (start + num_bytes <= caching_ctl->progress) {
6150 ret = btrfs_remove_free_space(block_group,
6151 start, num_bytes);
79787eaa 6152 BUG_ON(ret); /* -ENOMEM */
11833d66
YZ
6153 } else {
6154 num_bytes = caching_ctl->progress - start;
6155 ret = btrfs_remove_free_space(block_group,
6156 start, num_bytes);
79787eaa 6157 BUG_ON(ret); /* -ENOMEM */
11833d66
YZ
6158
6159 start = caching_ctl->progress;
6160 num_bytes = ins->objectid + ins->offset -
6161 caching_ctl->progress;
6162 ret = add_excluded_extent(root, start, num_bytes);
79787eaa 6163 BUG_ON(ret); /* -ENOMEM */
11833d66
YZ
6164 }
6165
6166 mutex_unlock(&caching_ctl->mutex);
6167 put_caching_control(caching_ctl);
6168 }
6169
fb25e914
JB
6170 ret = btrfs_update_reserved_bytes(block_group, ins->offset,
6171 RESERVE_ALLOC_NO_ACCOUNT);
79787eaa 6172 BUG_ON(ret); /* logic error */
fa9c0d79 6173 btrfs_put_block_group(block_group);
5d4f98a2
YZ
6174 ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
6175 0, owner, offset, ins, 1);
e02119d5
CM
6176 return ret;
6177}
6178
65b51a00
CM
6179struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
6180 struct btrfs_root *root,
4008c04a
CM
6181 u64 bytenr, u32 blocksize,
6182 int level)
65b51a00
CM
6183{
6184 struct extent_buffer *buf;
6185
6186 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
6187 if (!buf)
6188 return ERR_PTR(-ENOMEM);
6189 btrfs_set_header_generation(buf, trans->transid);
85d4e461 6190 btrfs_set_buffer_lockdep_class(root->root_key.objectid, buf, level);
65b51a00
CM
6191 btrfs_tree_lock(buf);
6192 clean_tree_block(trans, root, buf);
3083ee2e 6193 clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);
b4ce94de
CM
6194
6195 btrfs_set_lock_blocking(buf);
65b51a00 6196 btrfs_set_buffer_uptodate(buf);
b4ce94de 6197
d0c803c4 6198 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
8cef4e16
YZ
6199 /*
6200 * we allow two log transactions at a time, use different
6201 * EXENT bit to differentiate dirty pages.
6202 */
6203 if (root->log_transid % 2 == 0)
6204 set_extent_dirty(&root->dirty_log_pages, buf->start,
6205 buf->start + buf->len - 1, GFP_NOFS);
6206 else
6207 set_extent_new(&root->dirty_log_pages, buf->start,
6208 buf->start + buf->len - 1, GFP_NOFS);
d0c803c4
CM
6209 } else {
6210 set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
65b51a00 6211 buf->start + buf->len - 1, GFP_NOFS);
d0c803c4 6212 }
65b51a00 6213 trans->blocks_used++;
b4ce94de 6214 /* this returns a buffer locked for blocking */
65b51a00
CM
6215 return buf;
6216}
6217
f0486c68
YZ
6218static struct btrfs_block_rsv *
6219use_block_rsv(struct btrfs_trans_handle *trans,
6220 struct btrfs_root *root, u32 blocksize)
6221{
6222 struct btrfs_block_rsv *block_rsv;
68a82277 6223 struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
f0486c68
YZ
6224 int ret;
6225
6226 block_rsv = get_block_rsv(trans, root);
6227
6228 if (block_rsv->size == 0) {
36ba022a 6229 ret = reserve_metadata_bytes(root, block_rsv, blocksize, 0);
68a82277
JB
6230 /*
6231 * If we couldn't reserve metadata bytes try and use some from
6232 * the global reserve.
6233 */
6234 if (ret && block_rsv != global_rsv) {
6235 ret = block_rsv_use_bytes(global_rsv, blocksize);
6236 if (!ret)
6237 return global_rsv;
f0486c68 6238 return ERR_PTR(ret);
68a82277 6239 } else if (ret) {
f0486c68 6240 return ERR_PTR(ret);
68a82277 6241 }
f0486c68
YZ
6242 return block_rsv;
6243 }
6244
6245 ret = block_rsv_use_bytes(block_rsv, blocksize);
6246 if (!ret)
6247 return block_rsv;
68a82277 6248 if (ret) {
dff51cd1
DS
6249 static DEFINE_RATELIMIT_STATE(_rs,
6250 DEFAULT_RATELIMIT_INTERVAL,
6251 /*DEFAULT_RATELIMIT_BURST*/ 2);
6252 if (__ratelimit(&_rs)) {
6253 printk(KERN_DEBUG "btrfs: block rsv returned %d\n", ret);
6254 WARN_ON(1);
6255 }
36ba022a 6256 ret = reserve_metadata_bytes(root, block_rsv, blocksize, 0);
68a82277 6257 if (!ret) {
68a82277
JB
6258 return block_rsv;
6259 } else if (ret && block_rsv != global_rsv) {
6260 ret = block_rsv_use_bytes(global_rsv, blocksize);
6261 if (!ret)
6262 return global_rsv;
6263 }
6264 }
f0486c68 6265
f0486c68
YZ
6266 return ERR_PTR(-ENOSPC);
6267}
6268
8c2a3ca2
JB
6269static void unuse_block_rsv(struct btrfs_fs_info *fs_info,
6270 struct btrfs_block_rsv *block_rsv, u32 blocksize)
f0486c68
YZ
6271{
6272 block_rsv_add_bytes(block_rsv, blocksize, 0);
8c2a3ca2 6273 block_rsv_release_bytes(fs_info, block_rsv, NULL, 0);
f0486c68
YZ
6274}
6275
fec577fb 6276/*
f0486c68
YZ
6277 * finds a free extent and does all the dirty work required for allocation
6278 * returns the key for the extent through ins, and a tree buffer for
6279 * the first block of the extent through buf.
6280 *
fec577fb
CM
6281 * returns the tree buffer or NULL.
6282 */
5f39d397 6283struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
5d4f98a2
YZ
6284 struct btrfs_root *root, u32 blocksize,
6285 u64 parent, u64 root_objectid,
6286 struct btrfs_disk_key *key, int level,
5581a51a 6287 u64 hint, u64 empty_size)
fec577fb 6288{
e2fa7227 6289 struct btrfs_key ins;
f0486c68 6290 struct btrfs_block_rsv *block_rsv;
5f39d397 6291 struct extent_buffer *buf;
f0486c68
YZ
6292 u64 flags = 0;
6293 int ret;
6294
fec577fb 6295
f0486c68
YZ
6296 block_rsv = use_block_rsv(trans, root, blocksize);
6297 if (IS_ERR(block_rsv))
6298 return ERR_CAST(block_rsv);
6299
6300 ret = btrfs_reserve_extent(trans, root, blocksize, blocksize,
81c9ad23 6301 empty_size, hint, &ins, 0);
fec577fb 6302 if (ret) {
8c2a3ca2 6303 unuse_block_rsv(root->fs_info, block_rsv, blocksize);
54aa1f4d 6304 return ERR_PTR(ret);
fec577fb 6305 }
55c69072 6306
4008c04a
CM
6307 buf = btrfs_init_new_buffer(trans, root, ins.objectid,
6308 blocksize, level);
79787eaa 6309 BUG_ON(IS_ERR(buf)); /* -ENOMEM */
f0486c68
YZ
6310
6311 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
6312 if (parent == 0)
6313 parent = ins.objectid;
6314 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
6315 } else
6316 BUG_ON(parent > 0);
6317
6318 if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
6319 struct btrfs_delayed_extent_op *extent_op;
6320 extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
79787eaa 6321 BUG_ON(!extent_op); /* -ENOMEM */
f0486c68
YZ
6322 if (key)
6323 memcpy(&extent_op->key, key, sizeof(extent_op->key));
6324 else
6325 memset(&extent_op->key, 0, sizeof(extent_op->key));
6326 extent_op->flags_to_set = flags;
6327 extent_op->update_key = 1;
6328 extent_op->update_flags = 1;
6329 extent_op->is_data = 0;
6330
66d7e7f0
AJ
6331 ret = btrfs_add_delayed_tree_ref(root->fs_info, trans,
6332 ins.objectid,
f0486c68
YZ
6333 ins.offset, parent, root_objectid,
6334 level, BTRFS_ADD_DELAYED_EXTENT,
5581a51a 6335 extent_op, 0);
79787eaa 6336 BUG_ON(ret); /* -ENOMEM */
f0486c68 6337 }
fec577fb
CM
6338 return buf;
6339}
a28ec197 6340
2c47e605
YZ
6341struct walk_control {
6342 u64 refs[BTRFS_MAX_LEVEL];
6343 u64 flags[BTRFS_MAX_LEVEL];
6344 struct btrfs_key update_progress;
6345 int stage;
6346 int level;
6347 int shared_level;
6348 int update_ref;
6349 int keep_locks;
1c4850e2
YZ
6350 int reada_slot;
6351 int reada_count;
66d7e7f0 6352 int for_reloc;
2c47e605
YZ
6353};
6354
6355#define DROP_REFERENCE 1
6356#define UPDATE_BACKREF 2
6357
1c4850e2
YZ
6358static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
6359 struct btrfs_root *root,
6360 struct walk_control *wc,
6361 struct btrfs_path *path)
6407bf6d 6362{
1c4850e2
YZ
6363 u64 bytenr;
6364 u64 generation;
6365 u64 refs;
94fcca9f 6366 u64 flags;
5d4f98a2 6367 u32 nritems;
1c4850e2
YZ
6368 u32 blocksize;
6369 struct btrfs_key key;
6370 struct extent_buffer *eb;
6407bf6d 6371 int ret;
1c4850e2
YZ
6372 int slot;
6373 int nread = 0;
6407bf6d 6374
1c4850e2
YZ
6375 if (path->slots[wc->level] < wc->reada_slot) {
6376 wc->reada_count = wc->reada_count * 2 / 3;
6377 wc->reada_count = max(wc->reada_count, 2);
6378 } else {
6379 wc->reada_count = wc->reada_count * 3 / 2;
6380 wc->reada_count = min_t(int, wc->reada_count,
6381 BTRFS_NODEPTRS_PER_BLOCK(root));
6382 }
7bb86316 6383
1c4850e2
YZ
6384 eb = path->nodes[wc->level];
6385 nritems = btrfs_header_nritems(eb);
6386 blocksize = btrfs_level_size(root, wc->level - 1);
bd56b302 6387
1c4850e2
YZ
6388 for (slot = path->slots[wc->level]; slot < nritems; slot++) {
6389 if (nread >= wc->reada_count)
6390 break;
bd56b302 6391
2dd3e67b 6392 cond_resched();
1c4850e2
YZ
6393 bytenr = btrfs_node_blockptr(eb, slot);
6394 generation = btrfs_node_ptr_generation(eb, slot);
2dd3e67b 6395
1c4850e2
YZ
6396 if (slot == path->slots[wc->level])
6397 goto reada;
5d4f98a2 6398
1c4850e2
YZ
6399 if (wc->stage == UPDATE_BACKREF &&
6400 generation <= root->root_key.offset)
bd56b302
CM
6401 continue;
6402
94fcca9f
YZ
6403 /* We don't lock the tree block, it's OK to be racy here */
6404 ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
6405 &refs, &flags);
79787eaa
JM
6406 /* We don't care about errors in readahead. */
6407 if (ret < 0)
6408 continue;
94fcca9f
YZ
6409 BUG_ON(refs == 0);
6410
1c4850e2 6411 if (wc->stage == DROP_REFERENCE) {
1c4850e2
YZ
6412 if (refs == 1)
6413 goto reada;
bd56b302 6414
94fcca9f
YZ
6415 if (wc->level == 1 &&
6416 (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6417 continue;
1c4850e2
YZ
6418 if (!wc->update_ref ||
6419 generation <= root->root_key.offset)
6420 continue;
6421 btrfs_node_key_to_cpu(eb, &key, slot);
6422 ret = btrfs_comp_cpu_keys(&key,
6423 &wc->update_progress);
6424 if (ret < 0)
6425 continue;
94fcca9f
YZ
6426 } else {
6427 if (wc->level == 1 &&
6428 (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6429 continue;
6407bf6d 6430 }
1c4850e2
YZ
6431reada:
6432 ret = readahead_tree_block(root, bytenr, blocksize,
6433 generation);
6434 if (ret)
bd56b302 6435 break;
1c4850e2 6436 nread++;
20524f02 6437 }
1c4850e2 6438 wc->reada_slot = slot;
20524f02 6439}
2c47e605 6440
f82d02d9 6441/*
2c47e605
YZ
6442 * hepler to process tree block while walking down the tree.
6443 *
2c47e605
YZ
6444 * when wc->stage == UPDATE_BACKREF, this function updates
6445 * back refs for pointers in the block.
6446 *
6447 * NOTE: return value 1 means we should stop walking down.
f82d02d9 6448 */
2c47e605 6449static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
5d4f98a2 6450 struct btrfs_root *root,
2c47e605 6451 struct btrfs_path *path,
94fcca9f 6452 struct walk_control *wc, int lookup_info)
f82d02d9 6453{
2c47e605
YZ
6454 int level = wc->level;
6455 struct extent_buffer *eb = path->nodes[level];
2c47e605 6456 u64 flag = BTRFS_BLOCK_FLAG_FULL_BACKREF;
f82d02d9
YZ
6457 int ret;
6458
2c47e605
YZ
6459 if (wc->stage == UPDATE_BACKREF &&
6460 btrfs_header_owner(eb) != root->root_key.objectid)
6461 return 1;
f82d02d9 6462
2c47e605
YZ
6463 /*
6464 * when reference count of tree block is 1, it won't increase
6465 * again. once full backref flag is set, we never clear it.
6466 */
94fcca9f
YZ
6467 if (lookup_info &&
6468 ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
6469 (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
2c47e605
YZ
6470 BUG_ON(!path->locks[level]);
6471 ret = btrfs_lookup_extent_info(trans, root,
6472 eb->start, eb->len,
6473 &wc->refs[level],
6474 &wc->flags[level]);
79787eaa
JM
6475 BUG_ON(ret == -ENOMEM);
6476 if (ret)
6477 return ret;
2c47e605
YZ
6478 BUG_ON(wc->refs[level] == 0);
6479 }
5d4f98a2 6480
2c47e605
YZ
6481 if (wc->stage == DROP_REFERENCE) {
6482 if (wc->refs[level] > 1)
6483 return 1;
f82d02d9 6484
2c47e605 6485 if (path->locks[level] && !wc->keep_locks) {
bd681513 6486 btrfs_tree_unlock_rw(eb, path->locks[level]);
2c47e605
YZ
6487 path->locks[level] = 0;
6488 }
6489 return 0;
6490 }
f82d02d9 6491
2c47e605
YZ
6492 /* wc->stage == UPDATE_BACKREF */
6493 if (!(wc->flags[level] & flag)) {
6494 BUG_ON(!path->locks[level]);
66d7e7f0 6495 ret = btrfs_inc_ref(trans, root, eb, 1, wc->for_reloc);
79787eaa 6496 BUG_ON(ret); /* -ENOMEM */
66d7e7f0 6497 ret = btrfs_dec_ref(trans, root, eb, 0, wc->for_reloc);
79787eaa 6498 BUG_ON(ret); /* -ENOMEM */
2c47e605
YZ
6499 ret = btrfs_set_disk_extent_flags(trans, root, eb->start,
6500 eb->len, flag, 0);
79787eaa 6501 BUG_ON(ret); /* -ENOMEM */
2c47e605
YZ
6502 wc->flags[level] |= flag;
6503 }
6504
6505 /*
6506 * the block is shared by multiple trees, so it's not good to
6507 * keep the tree lock
6508 */
6509 if (path->locks[level] && level > 0) {
bd681513 6510 btrfs_tree_unlock_rw(eb, path->locks[level]);
2c47e605
YZ
6511 path->locks[level] = 0;
6512 }
6513 return 0;
6514}
6515
1c4850e2
YZ
6516/*
6517 * hepler to process tree block pointer.
6518 *
6519 * when wc->stage == DROP_REFERENCE, this function checks
6520 * reference count of the block pointed to. if the block
6521 * is shared and we need update back refs for the subtree
6522 * rooted at the block, this function changes wc->stage to
6523 * UPDATE_BACKREF. if the block is shared and there is no
6524 * need to update back, this function drops the reference
6525 * to the block.
6526 *
6527 * NOTE: return value 1 means we should stop walking down.
6528 */
6529static noinline int do_walk_down(struct btrfs_trans_handle *trans,
6530 struct btrfs_root *root,
6531 struct btrfs_path *path,
94fcca9f 6532 struct walk_control *wc, int *lookup_info)
1c4850e2
YZ
6533{
6534 u64 bytenr;
6535 u64 generation;
6536 u64 parent;
6537 u32 blocksize;
6538 struct btrfs_key key;
6539 struct extent_buffer *next;
6540 int level = wc->level;
6541 int reada = 0;
6542 int ret = 0;
6543
6544 generation = btrfs_node_ptr_generation(path->nodes[level],
6545 path->slots[level]);
6546 /*
6547 * if the lower level block was created before the snapshot
6548 * was created, we know there is no need to update back refs
6549 * for the subtree
6550 */
6551 if (wc->stage == UPDATE_BACKREF &&
94fcca9f
YZ
6552 generation <= root->root_key.offset) {
6553 *lookup_info = 1;
1c4850e2 6554 return 1;
94fcca9f 6555 }
1c4850e2
YZ
6556
6557 bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
6558 blocksize = btrfs_level_size(root, level - 1);
6559
6560 next = btrfs_find_tree_block(root, bytenr, blocksize);
6561 if (!next) {
6562 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
90d2c51d
MX
6563 if (!next)
6564 return -ENOMEM;
1c4850e2
YZ
6565 reada = 1;
6566 }
6567 btrfs_tree_lock(next);
6568 btrfs_set_lock_blocking(next);
6569
94fcca9f
YZ
6570 ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
6571 &wc->refs[level - 1],
6572 &wc->flags[level - 1]);
79787eaa
JM
6573 if (ret < 0) {
6574 btrfs_tree_unlock(next);
6575 return ret;
6576 }
6577
94fcca9f
YZ
6578 BUG_ON(wc->refs[level - 1] == 0);
6579 *lookup_info = 0;
1c4850e2 6580
94fcca9f 6581 if (wc->stage == DROP_REFERENCE) {
1c4850e2 6582 if (wc->refs[level - 1] > 1) {
94fcca9f
YZ
6583 if (level == 1 &&
6584 (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6585 goto skip;
6586
1c4850e2
YZ
6587 if (!wc->update_ref ||
6588 generation <= root->root_key.offset)
6589 goto skip;
6590
6591 btrfs_node_key_to_cpu(path->nodes[level], &key,
6592 path->slots[level]);
6593 ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
6594 if (ret < 0)
6595 goto skip;
6596
6597 wc->stage = UPDATE_BACKREF;
6598 wc->shared_level = level - 1;
6599 }
94fcca9f
YZ
6600 } else {
6601 if (level == 1 &&
6602 (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6603 goto skip;
1c4850e2
YZ
6604 }
6605
b9fab919 6606 if (!btrfs_buffer_uptodate(next, generation, 0)) {
1c4850e2
YZ
6607 btrfs_tree_unlock(next);
6608 free_extent_buffer(next);
6609 next = NULL;
94fcca9f 6610 *lookup_info = 1;
1c4850e2
YZ
6611 }
6612
6613 if (!next) {
6614 if (reada && level == 1)
6615 reada_walk_down(trans, root, wc, path);
6616 next = read_tree_block(root, bytenr, blocksize, generation);
97d9a8a4
TI
6617 if (!next)
6618 return -EIO;
1c4850e2
YZ
6619 btrfs_tree_lock(next);
6620 btrfs_set_lock_blocking(next);
6621 }
6622
6623 level--;
6624 BUG_ON(level != btrfs_header_level(next));
6625 path->nodes[level] = next;
6626 path->slots[level] = 0;
bd681513 6627 path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
1c4850e2
YZ
6628 wc->level = level;
6629 if (wc->level == 1)
6630 wc->reada_slot = 0;
6631 return 0;
6632skip:
6633 wc->refs[level - 1] = 0;
6634 wc->flags[level - 1] = 0;
94fcca9f
YZ
6635 if (wc->stage == DROP_REFERENCE) {
6636 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
6637 parent = path->nodes[level]->start;
6638 } else {
6639 BUG_ON(root->root_key.objectid !=
6640 btrfs_header_owner(path->nodes[level]));
6641 parent = 0;
6642 }
1c4850e2 6643
94fcca9f 6644 ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
66d7e7f0 6645 root->root_key.objectid, level - 1, 0, 0);
79787eaa 6646 BUG_ON(ret); /* -ENOMEM */
1c4850e2 6647 }
1c4850e2
YZ
6648 btrfs_tree_unlock(next);
6649 free_extent_buffer(next);
94fcca9f 6650 *lookup_info = 1;
1c4850e2
YZ
6651 return 1;
6652}
6653
2c47e605
YZ
6654/*
6655 * hepler to process tree block while walking up the tree.
6656 *
6657 * when wc->stage == DROP_REFERENCE, this function drops
6658 * reference count on the block.
6659 *
6660 * when wc->stage == UPDATE_BACKREF, this function changes
6661 * wc->stage back to DROP_REFERENCE if we changed wc->stage
6662 * to UPDATE_BACKREF previously while processing the block.
6663 *
6664 * NOTE: return value 1 means we should stop walking up.
6665 */
6666static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
6667 struct btrfs_root *root,
6668 struct btrfs_path *path,
6669 struct walk_control *wc)
6670{
f0486c68 6671 int ret;
2c47e605
YZ
6672 int level = wc->level;
6673 struct extent_buffer *eb = path->nodes[level];
6674 u64 parent = 0;
6675
6676 if (wc->stage == UPDATE_BACKREF) {
6677 BUG_ON(wc->shared_level < level);
6678 if (level < wc->shared_level)
6679 goto out;
6680
2c47e605
YZ
6681 ret = find_next_key(path, level + 1, &wc->update_progress);
6682 if (ret > 0)
6683 wc->update_ref = 0;
6684
6685 wc->stage = DROP_REFERENCE;
6686 wc->shared_level = -1;
6687 path->slots[level] = 0;
6688
6689 /*
6690 * check reference count again if the block isn't locked.
6691 * we should start walking down the tree again if reference
6692 * count is one.
6693 */
6694 if (!path->locks[level]) {
6695 BUG_ON(level == 0);
6696 btrfs_tree_lock(eb);
6697 btrfs_set_lock_blocking(eb);
bd681513 6698 path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
2c47e605
YZ
6699
6700 ret = btrfs_lookup_extent_info(trans, root,
6701 eb->start, eb->len,
6702 &wc->refs[level],
6703 &wc->flags[level]);
79787eaa
JM
6704 if (ret < 0) {
6705 btrfs_tree_unlock_rw(eb, path->locks[level]);
6706 return ret;
6707 }
2c47e605
YZ
6708 BUG_ON(wc->refs[level] == 0);
6709 if (wc->refs[level] == 1) {
bd681513 6710 btrfs_tree_unlock_rw(eb, path->locks[level]);
2c47e605
YZ
6711 return 1;
6712 }
f82d02d9 6713 }
2c47e605 6714 }
f82d02d9 6715
2c47e605
YZ
6716 /* wc->stage == DROP_REFERENCE */
6717 BUG_ON(wc->refs[level] > 1 && !path->locks[level]);
5d4f98a2 6718
2c47e605
YZ
6719 if (wc->refs[level] == 1) {
6720 if (level == 0) {
6721 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
66d7e7f0
AJ
6722 ret = btrfs_dec_ref(trans, root, eb, 1,
6723 wc->for_reloc);
2c47e605 6724 else
66d7e7f0
AJ
6725 ret = btrfs_dec_ref(trans, root, eb, 0,
6726 wc->for_reloc);
79787eaa 6727 BUG_ON(ret); /* -ENOMEM */
2c47e605
YZ
6728 }
6729 /* make block locked assertion in clean_tree_block happy */
6730 if (!path->locks[level] &&
6731 btrfs_header_generation(eb) == trans->transid) {
6732 btrfs_tree_lock(eb);
6733 btrfs_set_lock_blocking(eb);
bd681513 6734 path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
2c47e605
YZ
6735 }
6736 clean_tree_block(trans, root, eb);
6737 }
6738
6739 if (eb == root->node) {
6740 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6741 parent = eb->start;
6742 else
6743 BUG_ON(root->root_key.objectid !=
6744 btrfs_header_owner(eb));
6745 } else {
6746 if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6747 parent = path->nodes[level + 1]->start;
6748 else
6749 BUG_ON(root->root_key.objectid !=
6750 btrfs_header_owner(path->nodes[level + 1]));
f82d02d9 6751 }
f82d02d9 6752
5581a51a 6753 btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);
2c47e605
YZ
6754out:
6755 wc->refs[level] = 0;
6756 wc->flags[level] = 0;
f0486c68 6757 return 0;
2c47e605
YZ
6758}
6759
6760static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
6761 struct btrfs_root *root,
6762 struct btrfs_path *path,
6763 struct walk_control *wc)
6764{
2c47e605 6765 int level = wc->level;
94fcca9f 6766 int lookup_info = 1;
2c47e605
YZ
6767 int ret;
6768
6769 while (level >= 0) {
94fcca9f 6770 ret = walk_down_proc(trans, root, path, wc, lookup_info);
2c47e605
YZ
6771 if (ret > 0)
6772 break;
6773
6774 if (level == 0)
6775 break;
6776
7a7965f8
YZ
6777 if (path->slots[level] >=
6778 btrfs_header_nritems(path->nodes[level]))
6779 break;
6780
94fcca9f 6781 ret = do_walk_down(trans, root, path, wc, &lookup_info);
1c4850e2
YZ
6782 if (ret > 0) {
6783 path->slots[level]++;
6784 continue;
90d2c51d
MX
6785 } else if (ret < 0)
6786 return ret;
1c4850e2 6787 level = wc->level;
f82d02d9 6788 }
f82d02d9
YZ
6789 return 0;
6790}
6791
d397712b 6792static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
98ed5174 6793 struct btrfs_root *root,
f82d02d9 6794 struct btrfs_path *path,
2c47e605 6795 struct walk_control *wc, int max_level)
20524f02 6796{
2c47e605 6797 int level = wc->level;
20524f02 6798 int ret;
9f3a7427 6799
2c47e605
YZ
6800 path->slots[level] = btrfs_header_nritems(path->nodes[level]);
6801 while (level < max_level && path->nodes[level]) {
6802 wc->level = level;
6803 if (path->slots[level] + 1 <
6804 btrfs_header_nritems(path->nodes[level])) {
6805 path->slots[level]++;
20524f02
CM
6806 return 0;
6807 } else {
2c47e605
YZ
6808 ret = walk_up_proc(trans, root, path, wc);
6809 if (ret > 0)
6810 return 0;
bd56b302 6811
2c47e605 6812 if (path->locks[level]) {
bd681513
CM
6813 btrfs_tree_unlock_rw(path->nodes[level],
6814 path->locks[level]);
2c47e605 6815 path->locks[level] = 0;
f82d02d9 6816 }
2c47e605
YZ
6817 free_extent_buffer(path->nodes[level]);
6818 path->nodes[level] = NULL;
6819 level++;
20524f02
CM
6820 }
6821 }
6822 return 1;
6823}
6824
9aca1d51 6825/*
2c47e605
YZ
6826 * drop a subvolume tree.
6827 *
6828 * this function traverses the tree freeing any blocks that only
6829 * referenced by the tree.
6830 *
6831 * when a shared tree block is found. this function decreases its
6832 * reference count by one. if update_ref is true, this function
6833 * also make sure backrefs for the shared block and all lower level
6834 * blocks are properly updated.
9aca1d51 6835 */
2c536799 6836int btrfs_drop_snapshot(struct btrfs_root *root,
66d7e7f0
AJ
6837 struct btrfs_block_rsv *block_rsv, int update_ref,
6838 int for_reloc)
20524f02 6839{
5caf2a00 6840 struct btrfs_path *path;
2c47e605
YZ
6841 struct btrfs_trans_handle *trans;
6842 struct btrfs_root *tree_root = root->fs_info->tree_root;
9f3a7427 6843 struct btrfs_root_item *root_item = &root->root_item;
2c47e605
YZ
6844 struct walk_control *wc;
6845 struct btrfs_key key;
6846 int err = 0;
6847 int ret;
6848 int level;
20524f02 6849
5caf2a00 6850 path = btrfs_alloc_path();
cb1b69f4
TI
6851 if (!path) {
6852 err = -ENOMEM;
6853 goto out;
6854 }
20524f02 6855
2c47e605 6856 wc = kzalloc(sizeof(*wc), GFP_NOFS);
38a1a919
MF
6857 if (!wc) {
6858 btrfs_free_path(path);
cb1b69f4
TI
6859 err = -ENOMEM;
6860 goto out;
38a1a919 6861 }
2c47e605 6862
a22285a6 6863 trans = btrfs_start_transaction(tree_root, 0);
79787eaa
JM
6864 if (IS_ERR(trans)) {
6865 err = PTR_ERR(trans);
6866 goto out_free;
6867 }
98d5dc13 6868
3fd0a558
YZ
6869 if (block_rsv)
6870 trans->block_rsv = block_rsv;
2c47e605 6871
9f3a7427 6872 if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
2c47e605 6873 level = btrfs_header_level(root->node);
5d4f98a2
YZ
6874 path->nodes[level] = btrfs_lock_root_node(root);
6875 btrfs_set_lock_blocking(path->nodes[level]);
9f3a7427 6876 path->slots[level] = 0;
bd681513 6877 path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
2c47e605
YZ
6878 memset(&wc->update_progress, 0,
6879 sizeof(wc->update_progress));
9f3a7427 6880 } else {
9f3a7427 6881 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
2c47e605
YZ
6882 memcpy(&wc->update_progress, &key,
6883 sizeof(wc->update_progress));
6884
6702ed49 6885 level = root_item->drop_level;
2c47e605 6886 BUG_ON(level == 0);
6702ed49 6887 path->lowest_level = level;
2c47e605
YZ
6888 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6889 path->lowest_level = 0;
6890 if (ret < 0) {
6891 err = ret;
79787eaa 6892 goto out_end_trans;
9f3a7427 6893 }
1c4850e2 6894 WARN_ON(ret > 0);
2c47e605 6895
7d9eb12c
CM
6896 /*
6897 * unlock our path, this is safe because only this
6898 * function is allowed to delete this snapshot
6899 */
5d4f98a2 6900 btrfs_unlock_up_safe(path, 0);
2c47e605
YZ
6901
6902 level = btrfs_header_level(root->node);
6903 while (1) {
6904 btrfs_tree_lock(path->nodes[level]);
6905 btrfs_set_lock_blocking(path->nodes[level]);
6906
6907 ret = btrfs_lookup_extent_info(trans, root,
6908 path->nodes[level]->start,
6909 path->nodes[level]->len,
6910 &wc->refs[level],
6911 &wc->flags[level]);
79787eaa
JM
6912 if (ret < 0) {
6913 err = ret;
6914 goto out_end_trans;
6915 }
2c47e605
YZ
6916 BUG_ON(wc->refs[level] == 0);
6917
6918 if (level == root_item->drop_level)
6919 break;
6920
6921 btrfs_tree_unlock(path->nodes[level]);
6922 WARN_ON(wc->refs[level] != 1);
6923 level--;
6924 }
9f3a7427 6925 }
2c47e605
YZ
6926
6927 wc->level = level;
6928 wc->shared_level = -1;
6929 wc->stage = DROP_REFERENCE;
6930 wc->update_ref = update_ref;
6931 wc->keep_locks = 0;
66d7e7f0 6932 wc->for_reloc = for_reloc;
1c4850e2 6933 wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
2c47e605 6934
d397712b 6935 while (1) {
2c47e605
YZ
6936 ret = walk_down_tree(trans, root, path, wc);
6937 if (ret < 0) {
6938 err = ret;
20524f02 6939 break;
2c47e605 6940 }
9aca1d51 6941
2c47e605
YZ
6942 ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);
6943 if (ret < 0) {
6944 err = ret;
20524f02 6945 break;
2c47e605
YZ
6946 }
6947
6948 if (ret > 0) {
6949 BUG_ON(wc->stage != DROP_REFERENCE);
e7a84565
CM
6950 break;
6951 }
2c47e605
YZ
6952
6953 if (wc->stage == DROP_REFERENCE) {
6954 level = wc->level;
6955 btrfs_node_key(path->nodes[level],
6956 &root_item->drop_progress,
6957 path->slots[level]);
6958 root_item->drop_level = level;
6959 }
6960
6961 BUG_ON(wc->level == 0);
3fd0a558 6962 if (btrfs_should_end_transaction(trans, tree_root)) {
2c47e605
YZ
6963 ret = btrfs_update_root(trans, tree_root,
6964 &root->root_key,
6965 root_item);
79787eaa
JM
6966 if (ret) {
6967 btrfs_abort_transaction(trans, tree_root, ret);
6968 err = ret;
6969 goto out_end_trans;
6970 }
2c47e605 6971
3fd0a558 6972 btrfs_end_transaction_throttle(trans, tree_root);
a22285a6 6973 trans = btrfs_start_transaction(tree_root, 0);
79787eaa
JM
6974 if (IS_ERR(trans)) {
6975 err = PTR_ERR(trans);
6976 goto out_free;
6977 }
3fd0a558
YZ
6978 if (block_rsv)
6979 trans->block_rsv = block_rsv;
c3e69d58 6980 }
20524f02 6981 }
b3b4aa74 6982 btrfs_release_path(path);
79787eaa
JM
6983 if (err)
6984 goto out_end_trans;
2c47e605
YZ
6985
6986 ret = btrfs_del_root(trans, tree_root, &root->root_key);
79787eaa
JM
6987 if (ret) {
6988 btrfs_abort_transaction(trans, tree_root, ret);
6989 goto out_end_trans;
6990 }
2c47e605 6991
76dda93c
YZ
6992 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
6993 ret = btrfs_find_last_root(tree_root, root->root_key.objectid,
6994 NULL, NULL);
79787eaa
JM
6995 if (ret < 0) {
6996 btrfs_abort_transaction(trans, tree_root, ret);
6997 err = ret;
6998 goto out_end_trans;
6999 } else if (ret > 0) {
84cd948c
JB
7000 /* if we fail to delete the orphan item this time
7001 * around, it'll get picked up the next time.
7002 *
7003 * The most common failure here is just -ENOENT.
7004 */
7005 btrfs_del_orphan_item(trans, tree_root,
7006 root->root_key.objectid);
76dda93c
YZ
7007 }
7008 }
7009
7010 if (root->in_radix) {
7011 btrfs_free_fs_root(tree_root->fs_info, root);
7012 } else {
7013 free_extent_buffer(root->node);
7014 free_extent_buffer(root->commit_root);
7015 kfree(root);
7016 }
79787eaa 7017out_end_trans:
3fd0a558 7018 btrfs_end_transaction_throttle(trans, tree_root);
79787eaa 7019out_free:
2c47e605 7020 kfree(wc);
5caf2a00 7021 btrfs_free_path(path);
cb1b69f4
TI
7022out:
7023 if (err)
7024 btrfs_std_error(root->fs_info, err);
2c536799 7025 return err;
20524f02 7026}
9078a3e1 7027
2c47e605
YZ
7028/*
7029 * drop subtree rooted at tree block 'node'.
7030 *
7031 * NOTE: this function will unlock and release tree block 'node'
66d7e7f0 7032 * only used by relocation code
2c47e605 7033 */
f82d02d9
YZ
7034int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
7035 struct btrfs_root *root,
7036 struct extent_buffer *node,
7037 struct extent_buffer *parent)
7038{
7039 struct btrfs_path *path;
2c47e605 7040 struct walk_control *wc;
f82d02d9
YZ
7041 int level;
7042 int parent_level;
7043 int ret = 0;
7044 int wret;
7045
2c47e605
YZ
7046 BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
7047
f82d02d9 7048 path = btrfs_alloc_path();
db5b493a
TI
7049 if (!path)
7050 return -ENOMEM;
f82d02d9 7051
2c47e605 7052 wc = kzalloc(sizeof(*wc), GFP_NOFS);
db5b493a
TI
7053 if (!wc) {
7054 btrfs_free_path(path);
7055 return -ENOMEM;
7056 }
2c47e605 7057
b9447ef8 7058 btrfs_assert_tree_locked(parent);
f82d02d9
YZ
7059 parent_level = btrfs_header_level(parent);
7060 extent_buffer_get(parent);
7061 path->nodes[parent_level] = parent;
7062 path->slots[parent_level] = btrfs_header_nritems(parent);
7063
b9447ef8 7064 btrfs_assert_tree_locked(node);
f82d02d9 7065 level = btrfs_header_level(node);
f82d02d9
YZ
7066 path->nodes[level] = node;
7067 path->slots[level] = 0;
bd681513 7068 path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
2c47e605
YZ
7069
7070 wc->refs[parent_level] = 1;
7071 wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;
7072 wc->level = level;
7073 wc->shared_level = -1;
7074 wc->stage = DROP_REFERENCE;
7075 wc->update_ref = 0;
7076 wc->keep_locks = 1;
66d7e7f0 7077 wc->for_reloc = 1;
1c4850e2 7078 wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
f82d02d9
YZ
7079
7080 while (1) {
2c47e605
YZ
7081 wret = walk_down_tree(trans, root, path, wc);
7082 if (wret < 0) {
f82d02d9 7083 ret = wret;
f82d02d9 7084 break;
2c47e605 7085 }
f82d02d9 7086
2c47e605 7087 wret = walk_up_tree(trans, root, path, wc, parent_level);
f82d02d9
YZ
7088 if (wret < 0)
7089 ret = wret;
7090 if (wret != 0)
7091 break;
7092 }
7093
2c47e605 7094 kfree(wc);
f82d02d9
YZ
7095 btrfs_free_path(path);
7096 return ret;
7097}
7098
ec44a35c
CM
7099static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
7100{
7101 u64 num_devices;
fc67c450 7102 u64 stripped;
e4d8ec0f 7103
fc67c450
ID
7104 /*
7105 * if restripe for this chunk_type is on pick target profile and
7106 * return, otherwise do the usual balance
7107 */
7108 stripped = get_restripe_target(root->fs_info, flags);
7109 if (stripped)
7110 return extended_to_chunk(stripped);
e4d8ec0f 7111
cd02dca5
CM
7112 /*
7113 * we add in the count of missing devices because we want
7114 * to make sure that any RAID levels on a degraded FS
7115 * continue to be honored.
7116 */
7117 num_devices = root->fs_info->fs_devices->rw_devices +
7118 root->fs_info->fs_devices->missing_devices;
7119
fc67c450
ID
7120 stripped = BTRFS_BLOCK_GROUP_RAID0 |
7121 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;
7122
ec44a35c
CM
7123 if (num_devices == 1) {
7124 stripped |= BTRFS_BLOCK_GROUP_DUP;
7125 stripped = flags & ~stripped;
7126
7127 /* turn raid0 into single device chunks */
7128 if (flags & BTRFS_BLOCK_GROUP_RAID0)
7129 return stripped;
7130
7131 /* turn mirroring into duplication */
7132 if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
7133 BTRFS_BLOCK_GROUP_RAID10))
7134 return stripped | BTRFS_BLOCK_GROUP_DUP;
ec44a35c
CM
7135 } else {
7136 /* they already had raid on here, just return */
ec44a35c
CM
7137 if (flags & stripped)
7138 return flags;
7139
7140 stripped |= BTRFS_BLOCK_GROUP_DUP;
7141 stripped = flags & ~stripped;
7142
7143 /* switch duplicated blocks with raid1 */
7144 if (flags & BTRFS_BLOCK_GROUP_DUP)
7145 return stripped | BTRFS_BLOCK_GROUP_RAID1;
7146
e3176ca2 7147 /* this is drive concat, leave it alone */
ec44a35c 7148 }
e3176ca2 7149
ec44a35c
CM
7150 return flags;
7151}
7152
199c36ea 7153static int set_block_group_ro(struct btrfs_block_group_cache *cache, int force)
0ef3e66b 7154{
f0486c68
YZ
7155 struct btrfs_space_info *sinfo = cache->space_info;
7156 u64 num_bytes;
199c36ea 7157 u64 min_allocable_bytes;
f0486c68 7158 int ret = -ENOSPC;
0ef3e66b 7159
c286ac48 7160
199c36ea
MX
7161 /*
7162 * We need some metadata space and system metadata space for
7163 * allocating chunks in some corner cases until we force to set
7164 * it to be readonly.
7165 */
7166 if ((sinfo->flags &
7167 (BTRFS_BLOCK_GROUP_SYSTEM | BTRFS_BLOCK_GROUP_METADATA)) &&
7168 !force)
7169 min_allocable_bytes = 1 * 1024 * 1024;
7170 else
7171 min_allocable_bytes = 0;
7172
f0486c68
YZ
7173 spin_lock(&sinfo->lock);
7174 spin_lock(&cache->lock);
61cfea9b
W
7175
7176 if (cache->ro) {
7177 ret = 0;
7178 goto out;
7179 }
7180
f0486c68
YZ
7181 num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7182 cache->bytes_super - btrfs_block_group_used(&cache->item);
7183
7184 if (sinfo->bytes_used + sinfo->bytes_reserved + sinfo->bytes_pinned +
37be25bc
JB
7185 sinfo->bytes_may_use + sinfo->bytes_readonly + num_bytes +
7186 min_allocable_bytes <= sinfo->total_bytes) {
f0486c68 7187 sinfo->bytes_readonly += num_bytes;
f0486c68
YZ
7188 cache->ro = 1;
7189 ret = 0;
7190 }
61cfea9b 7191out:
f0486c68
YZ
7192 spin_unlock(&cache->lock);
7193 spin_unlock(&sinfo->lock);
7194 return ret;
7195}
7d9eb12c 7196
f0486c68
YZ
7197int btrfs_set_block_group_ro(struct btrfs_root *root,
7198 struct btrfs_block_group_cache *cache)
c286ac48 7199
f0486c68
YZ
7200{
7201 struct btrfs_trans_handle *trans;
7202 u64 alloc_flags;
7203 int ret;
7d9eb12c 7204
f0486c68 7205 BUG_ON(cache->ro);
0ef3e66b 7206
ff5714cc 7207 trans = btrfs_join_transaction(root);
79787eaa
JM
7208 if (IS_ERR(trans))
7209 return PTR_ERR(trans);
5d4f98a2 7210
f0486c68 7211 alloc_flags = update_block_group_flags(root, cache->flags);
79787eaa
JM
7212 if (alloc_flags != cache->flags) {
7213 ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
7214 CHUNK_ALLOC_FORCE);
7215 if (ret < 0)
7216 goto out;
7217 }
5d4f98a2 7218
199c36ea 7219 ret = set_block_group_ro(cache, 0);
f0486c68
YZ
7220 if (!ret)
7221 goto out;
7222 alloc_flags = get_alloc_profile(root, cache->space_info->flags);
0e4f8f88
CM
7223 ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
7224 CHUNK_ALLOC_FORCE);
f0486c68
YZ
7225 if (ret < 0)
7226 goto out;
199c36ea 7227 ret = set_block_group_ro(cache, 0);
f0486c68
YZ
7228out:
7229 btrfs_end_transaction(trans, root);
7230 return ret;
7231}
5d4f98a2 7232
c87f08ca
CM
7233int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
7234 struct btrfs_root *root, u64 type)
7235{
7236 u64 alloc_flags = get_alloc_profile(root, type);
0e4f8f88
CM
7237 return do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
7238 CHUNK_ALLOC_FORCE);
c87f08ca
CM
7239}
7240
6d07bcec
MX
7241/*
7242 * helper to account the unused space of all the readonly block group in the
7243 * list. takes mirrors into account.
7244 */
7245static u64 __btrfs_get_ro_block_group_free_space(struct list_head *groups_list)
7246{
7247 struct btrfs_block_group_cache *block_group;
7248 u64 free_bytes = 0;
7249 int factor;
7250
7251 list_for_each_entry(block_group, groups_list, list) {
7252 spin_lock(&block_group->lock);
7253
7254 if (!block_group->ro) {
7255 spin_unlock(&block_group->lock);
7256 continue;
7257 }
7258
7259 if (block_group->flags & (BTRFS_BLOCK_GROUP_RAID1 |
7260 BTRFS_BLOCK_GROUP_RAID10 |
7261 BTRFS_BLOCK_GROUP_DUP))
7262 factor = 2;
7263 else
7264 factor = 1;
7265
7266 free_bytes += (block_group->key.offset -
7267 btrfs_block_group_used(&block_group->item)) *
7268 factor;
7269
7270 spin_unlock(&block_group->lock);
7271 }
7272
7273 return free_bytes;
7274}
7275
7276/*
7277 * helper to account the unused space of all the readonly block group in the
7278 * space_info. takes mirrors into account.
7279 */
7280u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo)
7281{
7282 int i;
7283 u64 free_bytes = 0;
7284
7285 spin_lock(&sinfo->lock);
7286
7287 for(i = 0; i < BTRFS_NR_RAID_TYPES; i++)
7288 if (!list_empty(&sinfo->block_groups[i]))
7289 free_bytes += __btrfs_get_ro_block_group_free_space(
7290 &sinfo->block_groups[i]);
7291
7292 spin_unlock(&sinfo->lock);
7293
7294 return free_bytes;
7295}
7296
143bede5 7297void btrfs_set_block_group_rw(struct btrfs_root *root,
f0486c68 7298 struct btrfs_block_group_cache *cache)
5d4f98a2 7299{
f0486c68
YZ
7300 struct btrfs_space_info *sinfo = cache->space_info;
7301 u64 num_bytes;
7302
7303 BUG_ON(!cache->ro);
7304
7305 spin_lock(&sinfo->lock);
7306 spin_lock(&cache->lock);
7307 num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7308 cache->bytes_super - btrfs_block_group_used(&cache->item);
7309 sinfo->bytes_readonly -= num_bytes;
7310 cache->ro = 0;
7311 spin_unlock(&cache->lock);
7312 spin_unlock(&sinfo->lock);
5d4f98a2
YZ
7313}
7314
ba1bf481
JB
7315/*
7316 * checks to see if its even possible to relocate this block group.
7317 *
7318 * @return - -1 if it's not a good idea to relocate this block group, 0 if its
7319 * ok to go ahead and try.
7320 */
7321int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
1a40e23b 7322{
ba1bf481
JB
7323 struct btrfs_block_group_cache *block_group;
7324 struct btrfs_space_info *space_info;
7325 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
7326 struct btrfs_device *device;
cdcb725c 7327 u64 min_free;
6719db6a
JB
7328 u64 dev_min = 1;
7329 u64 dev_nr = 0;
4a5e98f5 7330 u64 target;
cdcb725c 7331 int index;
ba1bf481
JB
7332 int full = 0;
7333 int ret = 0;
1a40e23b 7334
ba1bf481 7335 block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
1a40e23b 7336
ba1bf481
JB
7337 /* odd, couldn't find the block group, leave it alone */
7338 if (!block_group)
7339 return -1;
1a40e23b 7340
cdcb725c 7341 min_free = btrfs_block_group_used(&block_group->item);
7342
ba1bf481 7343 /* no bytes used, we're good */
cdcb725c 7344 if (!min_free)
1a40e23b
ZY
7345 goto out;
7346
ba1bf481
JB
7347 space_info = block_group->space_info;
7348 spin_lock(&space_info->lock);
17d217fe 7349
ba1bf481 7350 full = space_info->full;
17d217fe 7351
ba1bf481
JB
7352 /*
7353 * if this is the last block group we have in this space, we can't
7ce618db
CM
7354 * relocate it unless we're able to allocate a new chunk below.
7355 *
7356 * Otherwise, we need to make sure we have room in the space to handle
7357 * all of the extents from this block group. If we can, we're good
ba1bf481 7358 */
7ce618db 7359 if ((space_info->total_bytes != block_group->key.offset) &&
cdcb725c 7360 (space_info->bytes_used + space_info->bytes_reserved +
7361 space_info->bytes_pinned + space_info->bytes_readonly +
7362 min_free < space_info->total_bytes)) {
ba1bf481
JB
7363 spin_unlock(&space_info->lock);
7364 goto out;
17d217fe 7365 }
ba1bf481 7366 spin_unlock(&space_info->lock);
ea8c2819 7367
ba1bf481
JB
7368 /*
7369 * ok we don't have enough space, but maybe we have free space on our
7370 * devices to allocate new chunks for relocation, so loop through our
4a5e98f5
ID
7371 * alloc devices and guess if we have enough space. if this block
7372 * group is going to be restriped, run checks against the target
7373 * profile instead of the current one.
ba1bf481
JB
7374 */
7375 ret = -1;
ea8c2819 7376
cdcb725c 7377 /*
7378 * index:
7379 * 0: raid10
7380 * 1: raid1
7381 * 2: dup
7382 * 3: raid0
7383 * 4: single
7384 */
4a5e98f5
ID
7385 target = get_restripe_target(root->fs_info, block_group->flags);
7386 if (target) {
7387 index = __get_block_group_index(extended_to_chunk(target));
7388 } else {
7389 /*
7390 * this is just a balance, so if we were marked as full
7391 * we know there is no space for a new chunk
7392 */
7393 if (full)
7394 goto out;
7395
7396 index = get_block_group_index(block_group);
7397 }
7398
cdcb725c 7399 if (index == 0) {
7400 dev_min = 4;
6719db6a
JB
7401 /* Divide by 2 */
7402 min_free >>= 1;
cdcb725c 7403 } else if (index == 1) {
7404 dev_min = 2;
7405 } else if (index == 2) {
6719db6a
JB
7406 /* Multiply by 2 */
7407 min_free <<= 1;
cdcb725c 7408 } else if (index == 3) {
7409 dev_min = fs_devices->rw_devices;
6719db6a 7410 do_div(min_free, dev_min);
cdcb725c 7411 }
7412
ba1bf481
JB
7413 mutex_lock(&root->fs_info->chunk_mutex);
7414 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
7bfc837d 7415 u64 dev_offset;
56bec294 7416
ba1bf481
JB
7417 /*
7418 * check to make sure we can actually find a chunk with enough
7419 * space to fit our block group in.
7420 */
7421 if (device->total_bytes > device->bytes_used + min_free) {
125ccb0a 7422 ret = find_free_dev_extent(device, min_free,
7bfc837d 7423 &dev_offset, NULL);
ba1bf481 7424 if (!ret)
cdcb725c 7425 dev_nr++;
7426
7427 if (dev_nr >= dev_min)
73e48b27 7428 break;
cdcb725c 7429
ba1bf481 7430 ret = -1;
725c8463 7431 }
edbd8d4e 7432 }
ba1bf481 7433 mutex_unlock(&root->fs_info->chunk_mutex);
edbd8d4e 7434out:
ba1bf481 7435 btrfs_put_block_group(block_group);
edbd8d4e
CM
7436 return ret;
7437}
7438
b2950863
CH
7439static int find_first_block_group(struct btrfs_root *root,
7440 struct btrfs_path *path, struct btrfs_key *key)
0b86a832 7441{
925baedd 7442 int ret = 0;
0b86a832
CM
7443 struct btrfs_key found_key;
7444 struct extent_buffer *leaf;
7445 int slot;
edbd8d4e 7446
0b86a832
CM
7447 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
7448 if (ret < 0)
925baedd
CM
7449 goto out;
7450
d397712b 7451 while (1) {
0b86a832 7452 slot = path->slots[0];
edbd8d4e 7453 leaf = path->nodes[0];
0b86a832
CM
7454 if (slot >= btrfs_header_nritems(leaf)) {
7455 ret = btrfs_next_leaf(root, path);
7456 if (ret == 0)
7457 continue;
7458 if (ret < 0)
925baedd 7459 goto out;
0b86a832 7460 break;
edbd8d4e 7461 }
0b86a832 7462 btrfs_item_key_to_cpu(leaf, &found_key, slot);
edbd8d4e 7463
0b86a832 7464 if (found_key.objectid >= key->objectid &&
925baedd
CM
7465 found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7466 ret = 0;
7467 goto out;
7468 }
0b86a832 7469 path->slots[0]++;
edbd8d4e 7470 }
925baedd 7471out:
0b86a832 7472 return ret;
edbd8d4e
CM
7473}
7474
0af3d00b
JB
7475void btrfs_put_block_group_cache(struct btrfs_fs_info *info)
7476{
7477 struct btrfs_block_group_cache *block_group;
7478 u64 last = 0;
7479
7480 while (1) {
7481 struct inode *inode;
7482
7483 block_group = btrfs_lookup_first_block_group(info, last);
7484 while (block_group) {
7485 spin_lock(&block_group->lock);
7486 if (block_group->iref)
7487 break;
7488 spin_unlock(&block_group->lock);
7489 block_group = next_block_group(info->tree_root,
7490 block_group);
7491 }
7492 if (!block_group) {
7493 if (last == 0)
7494 break;
7495 last = 0;
7496 continue;
7497 }
7498
7499 inode = block_group->inode;
7500 block_group->iref = 0;
7501 block_group->inode = NULL;
7502 spin_unlock(&block_group->lock);
7503 iput(inode);
7504 last = block_group->key.objectid + block_group->key.offset;
7505 btrfs_put_block_group(block_group);
7506 }
7507}
7508
1a40e23b
ZY
7509int btrfs_free_block_groups(struct btrfs_fs_info *info)
7510{
7511 struct btrfs_block_group_cache *block_group;
4184ea7f 7512 struct btrfs_space_info *space_info;
11833d66 7513 struct btrfs_caching_control *caching_ctl;
1a40e23b
ZY
7514 struct rb_node *n;
7515
11833d66
YZ
7516 down_write(&info->extent_commit_sem);
7517 while (!list_empty(&info->caching_block_groups)) {
7518 caching_ctl = list_entry(info->caching_block_groups.next,
7519 struct btrfs_caching_control, list);
7520 list_del(&caching_ctl->list);
7521 put_caching_control(caching_ctl);
7522 }
7523 up_write(&info->extent_commit_sem);
7524
1a40e23b
ZY
7525 spin_lock(&info->block_group_cache_lock);
7526 while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
7527 block_group = rb_entry(n, struct btrfs_block_group_cache,
7528 cache_node);
1a40e23b
ZY
7529 rb_erase(&block_group->cache_node,
7530 &info->block_group_cache_tree);
d899e052
YZ
7531 spin_unlock(&info->block_group_cache_lock);
7532
80eb234a 7533 down_write(&block_group->space_info->groups_sem);
1a40e23b 7534 list_del(&block_group->list);
80eb234a 7535 up_write(&block_group->space_info->groups_sem);
d2fb3437 7536
817d52f8 7537 if (block_group->cached == BTRFS_CACHE_STARTED)
11833d66 7538 wait_block_group_cache_done(block_group);
817d52f8 7539
3c14874a
JB
7540 /*
7541 * We haven't cached this block group, which means we could
7542 * possibly have excluded extents on this block group.
7543 */
7544 if (block_group->cached == BTRFS_CACHE_NO)
7545 free_excluded_extents(info->extent_root, block_group);
7546
817d52f8 7547 btrfs_remove_free_space_cache(block_group);
11dfe35a 7548 btrfs_put_block_group(block_group);
d899e052
YZ
7549
7550 spin_lock(&info->block_group_cache_lock);
1a40e23b
ZY
7551 }
7552 spin_unlock(&info->block_group_cache_lock);
4184ea7f
CM
7553
7554 /* now that all the block groups are freed, go through and
7555 * free all the space_info structs. This is only called during
7556 * the final stages of unmount, and so we know nobody is
7557 * using them. We call synchronize_rcu() once before we start,
7558 * just to be on the safe side.
7559 */
7560 synchronize_rcu();
7561
8929ecfa
YZ
7562 release_global_block_rsv(info);
7563
4184ea7f
CM
7564 while(!list_empty(&info->space_info)) {
7565 space_info = list_entry(info->space_info.next,
7566 struct btrfs_space_info,
7567 list);
f0486c68 7568 if (space_info->bytes_pinned > 0 ||
fb25e914
JB
7569 space_info->bytes_reserved > 0 ||
7570 space_info->bytes_may_use > 0) {
f0486c68
YZ
7571 WARN_ON(1);
7572 dump_space_info(space_info, 0, 0);
7573 }
4184ea7f
CM
7574 list_del(&space_info->list);
7575 kfree(space_info);
7576 }
1a40e23b
ZY
7577 return 0;
7578}
7579
b742bb82
YZ
7580static void __link_block_group(struct btrfs_space_info *space_info,
7581 struct btrfs_block_group_cache *cache)
7582{
7583 int index = get_block_group_index(cache);
7584
7585 down_write(&space_info->groups_sem);
7586 list_add_tail(&cache->list, &space_info->block_groups[index]);
7587 up_write(&space_info->groups_sem);
7588}
7589
9078a3e1
CM
7590int btrfs_read_block_groups(struct btrfs_root *root)
7591{
7592 struct btrfs_path *path;
7593 int ret;
9078a3e1 7594 struct btrfs_block_group_cache *cache;
be744175 7595 struct btrfs_fs_info *info = root->fs_info;
6324fbf3 7596 struct btrfs_space_info *space_info;
9078a3e1
CM
7597 struct btrfs_key key;
7598 struct btrfs_key found_key;
5f39d397 7599 struct extent_buffer *leaf;
0af3d00b
JB
7600 int need_clear = 0;
7601 u64 cache_gen;
96b5179d 7602
be744175 7603 root = info->extent_root;
9078a3e1 7604 key.objectid = 0;
0b86a832 7605 key.offset = 0;
9078a3e1 7606 btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
9078a3e1
CM
7607 path = btrfs_alloc_path();
7608 if (!path)
7609 return -ENOMEM;
026fd317 7610 path->reada = 1;
9078a3e1 7611
6c41761f 7612 cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
73bc1876 7613 if (btrfs_test_opt(root, SPACE_CACHE) &&
6c41761f 7614 btrfs_super_generation(root->fs_info->super_copy) != cache_gen)
0af3d00b 7615 need_clear = 1;
88c2ba3b
JB
7616 if (btrfs_test_opt(root, CLEAR_CACHE))
7617 need_clear = 1;
0af3d00b 7618
d397712b 7619 while (1) {
0b86a832 7620 ret = find_first_block_group(root, path, &key);
b742bb82
YZ
7621 if (ret > 0)
7622 break;
0b86a832
CM
7623 if (ret != 0)
7624 goto error;
5f39d397
CM
7625 leaf = path->nodes[0];
7626 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
8f18cf13 7627 cache = kzalloc(sizeof(*cache), GFP_NOFS);
9078a3e1 7628 if (!cache) {
0b86a832 7629 ret = -ENOMEM;
f0486c68 7630 goto error;
9078a3e1 7631 }
34d52cb6
LZ
7632 cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
7633 GFP_NOFS);
7634 if (!cache->free_space_ctl) {
7635 kfree(cache);
7636 ret = -ENOMEM;
7637 goto error;
7638 }
3e1ad54f 7639
d2fb3437 7640 atomic_set(&cache->count, 1);
c286ac48 7641 spin_lock_init(&cache->lock);
817d52f8 7642 cache->fs_info = info;
0f9dd46c 7643 INIT_LIST_HEAD(&cache->list);
fa9c0d79 7644 INIT_LIST_HEAD(&cache->cluster_list);
96303081 7645
0af3d00b
JB
7646 if (need_clear)
7647 cache->disk_cache_state = BTRFS_DC_CLEAR;
7648
5f39d397
CM
7649 read_extent_buffer(leaf, &cache->item,
7650 btrfs_item_ptr_offset(leaf, path->slots[0]),
7651 sizeof(cache->item));
9078a3e1 7652 memcpy(&cache->key, &found_key, sizeof(found_key));
0b86a832 7653
9078a3e1 7654 key.objectid = found_key.objectid + found_key.offset;
b3b4aa74 7655 btrfs_release_path(path);
0b86a832 7656 cache->flags = btrfs_block_group_flags(&cache->item);
817d52f8
JB
7657 cache->sectorsize = root->sectorsize;
7658
34d52cb6
LZ
7659 btrfs_init_free_space_ctl(cache);
7660
3c14874a
JB
7661 /*
7662 * We need to exclude the super stripes now so that the space
7663 * info has super bytes accounted for, otherwise we'll think
7664 * we have more space than we actually do.
7665 */
7666 exclude_super_stripes(root, cache);
7667
817d52f8
JB
7668 /*
7669 * check for two cases, either we are full, and therefore
7670 * don't need to bother with the caching work since we won't
7671 * find any space, or we are empty, and we can just add all
7672 * the space in and be done with it. This saves us _alot_ of
7673 * time, particularly in the full case.
7674 */
7675 if (found_key.offset == btrfs_block_group_used(&cache->item)) {
11833d66 7676 cache->last_byte_to_unpin = (u64)-1;
817d52f8 7677 cache->cached = BTRFS_CACHE_FINISHED;
1b2da372 7678 free_excluded_extents(root, cache);
817d52f8 7679 } else if (btrfs_block_group_used(&cache->item) == 0) {
11833d66 7680 cache->last_byte_to_unpin = (u64)-1;
817d52f8
JB
7681 cache->cached = BTRFS_CACHE_FINISHED;
7682 add_new_free_space(cache, root->fs_info,
7683 found_key.objectid,
7684 found_key.objectid +
7685 found_key.offset);
11833d66 7686 free_excluded_extents(root, cache);
817d52f8 7687 }
96b5179d 7688
6324fbf3
CM
7689 ret = update_space_info(info, cache->flags, found_key.offset,
7690 btrfs_block_group_used(&cache->item),
7691 &space_info);
79787eaa 7692 BUG_ON(ret); /* -ENOMEM */
6324fbf3 7693 cache->space_info = space_info;
1b2da372 7694 spin_lock(&cache->space_info->lock);
f0486c68 7695 cache->space_info->bytes_readonly += cache->bytes_super;
1b2da372
JB
7696 spin_unlock(&cache->space_info->lock);
7697
b742bb82 7698 __link_block_group(space_info, cache);
0f9dd46c
JB
7699
7700 ret = btrfs_add_block_group_cache(root->fs_info, cache);
79787eaa 7701 BUG_ON(ret); /* Logic error */
75ccf47d
CM
7702
7703 set_avail_alloc_bits(root->fs_info, cache->flags);
2b82032c 7704 if (btrfs_chunk_readonly(root, cache->key.objectid))
199c36ea 7705 set_block_group_ro(cache, 1);
9078a3e1 7706 }
b742bb82
YZ
7707
7708 list_for_each_entry_rcu(space_info, &root->fs_info->space_info, list) {
7709 if (!(get_alloc_profile(root, space_info->flags) &
7710 (BTRFS_BLOCK_GROUP_RAID10 |
7711 BTRFS_BLOCK_GROUP_RAID1 |
7712 BTRFS_BLOCK_GROUP_DUP)))
7713 continue;
7714 /*
7715 * avoid allocating from un-mirrored block group if there are
7716 * mirrored block groups.
7717 */
7718 list_for_each_entry(cache, &space_info->block_groups[3], list)
199c36ea 7719 set_block_group_ro(cache, 1);
b742bb82 7720 list_for_each_entry(cache, &space_info->block_groups[4], list)
199c36ea 7721 set_block_group_ro(cache, 1);
9078a3e1 7722 }
f0486c68
YZ
7723
7724 init_global_block_rsv(info);
0b86a832
CM
7725 ret = 0;
7726error:
9078a3e1 7727 btrfs_free_path(path);
0b86a832 7728 return ret;
9078a3e1 7729}
6324fbf3
CM
7730
7731int btrfs_make_block_group(struct btrfs_trans_handle *trans,
7732 struct btrfs_root *root, u64 bytes_used,
e17cade2 7733 u64 type, u64 chunk_objectid, u64 chunk_offset,
6324fbf3
CM
7734 u64 size)
7735{
7736 int ret;
6324fbf3
CM
7737 struct btrfs_root *extent_root;
7738 struct btrfs_block_group_cache *cache;
6324fbf3
CM
7739
7740 extent_root = root->fs_info->extent_root;
6324fbf3 7741
12fcfd22 7742 root->fs_info->last_trans_log_full_commit = trans->transid;
e02119d5 7743
8f18cf13 7744 cache = kzalloc(sizeof(*cache), GFP_NOFS);
0f9dd46c
JB
7745 if (!cache)
7746 return -ENOMEM;
34d52cb6
LZ
7747 cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
7748 GFP_NOFS);
7749 if (!cache->free_space_ctl) {
7750 kfree(cache);
7751 return -ENOMEM;
7752 }
0f9dd46c 7753
e17cade2 7754 cache->key.objectid = chunk_offset;
6324fbf3 7755 cache->key.offset = size;
d2fb3437 7756 cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
96303081 7757 cache->sectorsize = root->sectorsize;
0af3d00b 7758 cache->fs_info = root->fs_info;
96303081 7759
d2fb3437 7760 atomic_set(&cache->count, 1);
c286ac48 7761 spin_lock_init(&cache->lock);
0f9dd46c 7762 INIT_LIST_HEAD(&cache->list);
fa9c0d79 7763 INIT_LIST_HEAD(&cache->cluster_list);
0ef3e66b 7764
34d52cb6
LZ
7765 btrfs_init_free_space_ctl(cache);
7766
6324fbf3 7767 btrfs_set_block_group_used(&cache->item, bytes_used);
6324fbf3
CM
7768 btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
7769 cache->flags = type;
7770 btrfs_set_block_group_flags(&cache->item, type);
7771
11833d66 7772 cache->last_byte_to_unpin = (u64)-1;
817d52f8 7773 cache->cached = BTRFS_CACHE_FINISHED;
11833d66 7774 exclude_super_stripes(root, cache);
96303081 7775
817d52f8
JB
7776 add_new_free_space(cache, root->fs_info, chunk_offset,
7777 chunk_offset + size);
7778
11833d66
YZ
7779 free_excluded_extents(root, cache);
7780
6324fbf3
CM
7781 ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
7782 &cache->space_info);
79787eaa 7783 BUG_ON(ret); /* -ENOMEM */
c7c144db 7784 update_global_block_rsv(root->fs_info);
1b2da372
JB
7785
7786 spin_lock(&cache->space_info->lock);
f0486c68 7787 cache->space_info->bytes_readonly += cache->bytes_super;
1b2da372
JB
7788 spin_unlock(&cache->space_info->lock);
7789
b742bb82 7790 __link_block_group(cache->space_info, cache);
6324fbf3 7791
0f9dd46c 7792 ret = btrfs_add_block_group_cache(root->fs_info, cache);
79787eaa 7793 BUG_ON(ret); /* Logic error */
c286ac48 7794
6324fbf3
CM
7795 ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
7796 sizeof(cache->item));
79787eaa
JM
7797 if (ret) {
7798 btrfs_abort_transaction(trans, extent_root, ret);
7799 return ret;
7800 }
6324fbf3 7801
d18a2c44 7802 set_avail_alloc_bits(extent_root->fs_info, type);
925baedd 7803
6324fbf3
CM
7804 return 0;
7805}
1a40e23b 7806
10ea00f5
ID
7807static void clear_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
7808{
899c81ea
ID
7809 u64 extra_flags = chunk_to_extended(flags) &
7810 BTRFS_EXTENDED_PROFILE_MASK;
10ea00f5
ID
7811
7812 if (flags & BTRFS_BLOCK_GROUP_DATA)
7813 fs_info->avail_data_alloc_bits &= ~extra_flags;
7814 if (flags & BTRFS_BLOCK_GROUP_METADATA)
7815 fs_info->avail_metadata_alloc_bits &= ~extra_flags;
7816 if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
7817 fs_info->avail_system_alloc_bits &= ~extra_flags;
7818}
7819
1a40e23b
ZY
7820int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
7821 struct btrfs_root *root, u64 group_start)
7822{
7823 struct btrfs_path *path;
7824 struct btrfs_block_group_cache *block_group;
44fb5511 7825 struct btrfs_free_cluster *cluster;
0af3d00b 7826 struct btrfs_root *tree_root = root->fs_info->tree_root;
1a40e23b 7827 struct btrfs_key key;
0af3d00b 7828 struct inode *inode;
1a40e23b 7829 int ret;
10ea00f5 7830 int index;
89a55897 7831 int factor;
1a40e23b 7832
1a40e23b
ZY
7833 root = root->fs_info->extent_root;
7834
7835 block_group = btrfs_lookup_block_group(root->fs_info, group_start);
7836 BUG_ON(!block_group);
c146afad 7837 BUG_ON(!block_group->ro);
1a40e23b 7838
9f7c43c9 7839 /*
7840 * Free the reserved super bytes from this block group before
7841 * remove it.
7842 */
7843 free_excluded_extents(root, block_group);
7844
1a40e23b 7845 memcpy(&key, &block_group->key, sizeof(key));
10ea00f5 7846 index = get_block_group_index(block_group);
89a55897
JB
7847 if (block_group->flags & (BTRFS_BLOCK_GROUP_DUP |
7848 BTRFS_BLOCK_GROUP_RAID1 |
7849 BTRFS_BLOCK_GROUP_RAID10))
7850 factor = 2;
7851 else
7852 factor = 1;
1a40e23b 7853
44fb5511
CM
7854 /* make sure this block group isn't part of an allocation cluster */
7855 cluster = &root->fs_info->data_alloc_cluster;
7856 spin_lock(&cluster->refill_lock);
7857 btrfs_return_cluster_to_free_space(block_group, cluster);
7858 spin_unlock(&cluster->refill_lock);
7859
7860 /*
7861 * make sure this block group isn't part of a metadata
7862 * allocation cluster
7863 */
7864 cluster = &root->fs_info->meta_alloc_cluster;
7865 spin_lock(&cluster->refill_lock);
7866 btrfs_return_cluster_to_free_space(block_group, cluster);
7867 spin_unlock(&cluster->refill_lock);
7868
1a40e23b 7869 path = btrfs_alloc_path();
d8926bb3
MF
7870 if (!path) {
7871 ret = -ENOMEM;
7872 goto out;
7873 }
1a40e23b 7874
10b2f34d 7875 inode = lookup_free_space_inode(tree_root, block_group, path);
0af3d00b 7876 if (!IS_ERR(inode)) {
b532402e 7877 ret = btrfs_orphan_add(trans, inode);
79787eaa
JM
7878 if (ret) {
7879 btrfs_add_delayed_iput(inode);
7880 goto out;
7881 }
0af3d00b
JB
7882 clear_nlink(inode);
7883 /* One for the block groups ref */
7884 spin_lock(&block_group->lock);
7885 if (block_group->iref) {
7886 block_group->iref = 0;
7887 block_group->inode = NULL;
7888 spin_unlock(&block_group->lock);
7889 iput(inode);
7890 } else {
7891 spin_unlock(&block_group->lock);
7892 }
7893 /* One for our lookup ref */
455757c3 7894 btrfs_add_delayed_iput(inode);
0af3d00b
JB
7895 }
7896
7897 key.objectid = BTRFS_FREE_SPACE_OBJECTID;
7898 key.offset = block_group->key.objectid;
7899 key.type = 0;
7900
7901 ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
7902 if (ret < 0)
7903 goto out;
7904 if (ret > 0)
b3b4aa74 7905 btrfs_release_path(path);
0af3d00b
JB
7906 if (ret == 0) {
7907 ret = btrfs_del_item(trans, tree_root, path);
7908 if (ret)
7909 goto out;
b3b4aa74 7910 btrfs_release_path(path);
0af3d00b
JB
7911 }
7912
3dfdb934 7913 spin_lock(&root->fs_info->block_group_cache_lock);
1a40e23b
ZY
7914 rb_erase(&block_group->cache_node,
7915 &root->fs_info->block_group_cache_tree);
3dfdb934 7916 spin_unlock(&root->fs_info->block_group_cache_lock);
817d52f8 7917
80eb234a 7918 down_write(&block_group->space_info->groups_sem);
44fb5511
CM
7919 /*
7920 * we must use list_del_init so people can check to see if they
7921 * are still on the list after taking the semaphore
7922 */
7923 list_del_init(&block_group->list);
10ea00f5
ID
7924 if (list_empty(&block_group->space_info->block_groups[index]))
7925 clear_avail_alloc_bits(root->fs_info, block_group->flags);
80eb234a 7926 up_write(&block_group->space_info->groups_sem);
1a40e23b 7927
817d52f8 7928 if (block_group->cached == BTRFS_CACHE_STARTED)
11833d66 7929 wait_block_group_cache_done(block_group);
817d52f8
JB
7930
7931 btrfs_remove_free_space_cache(block_group);
7932
c146afad
YZ
7933 spin_lock(&block_group->space_info->lock);
7934 block_group->space_info->total_bytes -= block_group->key.offset;
7935 block_group->space_info->bytes_readonly -= block_group->key.offset;
89a55897 7936 block_group->space_info->disk_total -= block_group->key.offset * factor;
c146afad 7937 spin_unlock(&block_group->space_info->lock);
283bb197 7938
0af3d00b
JB
7939 memcpy(&key, &block_group->key, sizeof(key));
7940
283bb197 7941 btrfs_clear_space_info_full(root->fs_info);
c146afad 7942
fa9c0d79
CM
7943 btrfs_put_block_group(block_group);
7944 btrfs_put_block_group(block_group);
1a40e23b
ZY
7945
7946 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
7947 if (ret > 0)
7948 ret = -EIO;
7949 if (ret < 0)
7950 goto out;
7951
7952 ret = btrfs_del_item(trans, root, path);
7953out:
7954 btrfs_free_path(path);
7955 return ret;
7956}
acce952b 7957
c59021f8 7958int btrfs_init_space_info(struct btrfs_fs_info *fs_info)
7959{
7960 struct btrfs_space_info *space_info;
1aba86d6 7961 struct btrfs_super_block *disk_super;
7962 u64 features;
7963 u64 flags;
7964 int mixed = 0;
c59021f8 7965 int ret;
7966
6c41761f 7967 disk_super = fs_info->super_copy;
1aba86d6 7968 if (!btrfs_super_root(disk_super))
7969 return 1;
c59021f8 7970
1aba86d6 7971 features = btrfs_super_incompat_flags(disk_super);
7972 if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
7973 mixed = 1;
c59021f8 7974
1aba86d6 7975 flags = BTRFS_BLOCK_GROUP_SYSTEM;
7976 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
c59021f8 7977 if (ret)
1aba86d6 7978 goto out;
c59021f8 7979
1aba86d6 7980 if (mixed) {
7981 flags = BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA;
7982 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7983 } else {
7984 flags = BTRFS_BLOCK_GROUP_METADATA;
7985 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7986 if (ret)
7987 goto out;
7988
7989 flags = BTRFS_BLOCK_GROUP_DATA;
7990 ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7991 }
7992out:
c59021f8 7993 return ret;
7994}
7995
acce952b 7996int btrfs_error_unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
7997{
7998 return unpin_extent_range(root, start, end);
7999}
8000
8001int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
5378e607 8002 u64 num_bytes, u64 *actual_bytes)
acce952b 8003{
5378e607 8004 return btrfs_discard_extent(root, bytenr, num_bytes, actual_bytes);
acce952b 8005}
f7039b1d
LD
8006
8007int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range)
8008{
8009 struct btrfs_fs_info *fs_info = root->fs_info;
8010 struct btrfs_block_group_cache *cache = NULL;
8011 u64 group_trimmed;
8012 u64 start;
8013 u64 end;
8014 u64 trimmed = 0;
2cac13e4 8015 u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
f7039b1d
LD
8016 int ret = 0;
8017
2cac13e4
LB
8018 /*
8019 * try to trim all FS space, our block group may start from non-zero.
8020 */
8021 if (range->len == total_bytes)
8022 cache = btrfs_lookup_first_block_group(fs_info, range->start);
8023 else
8024 cache = btrfs_lookup_block_group(fs_info, range->start);
f7039b1d
LD
8025
8026 while (cache) {
8027 if (cache->key.objectid >= (range->start + range->len)) {
8028 btrfs_put_block_group(cache);
8029 break;
8030 }
8031
8032 start = max(range->start, cache->key.objectid);
8033 end = min(range->start + range->len,
8034 cache->key.objectid + cache->key.offset);
8035
8036 if (end - start >= range->minlen) {
8037 if (!block_group_cache_done(cache)) {
8038 ret = cache_block_group(cache, NULL, root, 0);
8039 if (!ret)
8040 wait_block_group_cache_done(cache);
8041 }
8042 ret = btrfs_trim_block_group(cache,
8043 &group_trimmed,
8044 start,
8045 end,
8046 range->minlen);
8047
8048 trimmed += group_trimmed;
8049 if (ret) {
8050 btrfs_put_block_group(cache);
8051 break;
8052 }
8053 }
8054
8055 cache = next_block_group(fs_info->tree_root, cache);
8056 }
8057
8058 range->len = trimmed;
8059 return ret;
8060}
This page took 0.945289 seconds and 5 git commands to generate.