extent-tree.c 181.4 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */
Z
Zach Brown 已提交
18
#include <linux/sched.h>
19
#include <linux/pagemap.h>
20
#include <linux/writeback.h>
21
#include <linux/blkdev.h>
22
#include <linux/sort.h>
23
#include <linux/rcupdate.h>
C
Chris Mason 已提交
24
#include "compat.h"
25
#include "hash.h"
26
#include "crc32c.h"
27 28 29
#include "ctree.h"
#include "disk-io.h"
#include "print-tree.h"
30
#include "transaction.h"
31
#include "volumes.h"
32
#include "locking.h"
33
#include "free-space-cache.h"
34

35 36
static int update_reserved_extents(struct btrfs_root *root,
				   u64 bytenr, u64 num, int reserve);
37 38 39 40
static int update_block_group(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      u64 bytenr, u64 num_bytes, int alloc,
			      int mark_free);
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				u64 bytenr, u64 num_bytes, u64 parent,
				u64 root_objectid, u64 owner_objectid,
				u64 owner_offset, int refs_to_drop,
				struct btrfs_delayed_extent_op *extra_op);
static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
				    struct extent_buffer *leaf,
				    struct btrfs_extent_item *ei);
static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      u64 parent, u64 root_objectid,
				      u64 flags, u64 owner, u64 offset,
				      struct btrfs_key *ins, int ref_mod);
static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
				     u64 parent, u64 root_objectid,
				     u64 flags, struct btrfs_disk_key *key,
				     int level, struct btrfs_key *ins);
60

J
Josef Bacik 已提交
61 62 63 64
static int do_chunk_alloc(struct btrfs_trans_handle *trans,
			  struct btrfs_root *extent_root, u64 alloc_bytes,
			  u64 flags, int force);

J
Josef Bacik 已提交
65 66 67 68 69 70 71 72 73
static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
{
	return (cache->flags & bits) == bits;
}

/*
 * this adds the block group to the fs_info rb tree for the block group
 * cache
 */
74
static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
J
Josef Bacik 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
				struct btrfs_block_group_cache *block_group)
{
	struct rb_node **p;
	struct rb_node *parent = NULL;
	struct btrfs_block_group_cache *cache;

	spin_lock(&info->block_group_cache_lock);
	p = &info->block_group_cache_tree.rb_node;

	while (*p) {
		parent = *p;
		cache = rb_entry(parent, struct btrfs_block_group_cache,
				 cache_node);
		if (block_group->key.objectid < cache->key.objectid) {
			p = &(*p)->rb_left;
		} else if (block_group->key.objectid > cache->key.objectid) {
			p = &(*p)->rb_right;
		} else {
			spin_unlock(&info->block_group_cache_lock);
			return -EEXIST;
		}
	}

	rb_link_node(&block_group->cache_node, parent, p);
	rb_insert_color(&block_group->cache_node,
			&info->block_group_cache_tree);
	spin_unlock(&info->block_group_cache_lock);

	return 0;
}

/*
 * This will return the block group at or after bytenr if contains is 0, else
 * it will return the block group that contains the bytenr
 */
static struct btrfs_block_group_cache *
block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
			      int contains)
{
	struct btrfs_block_group_cache *cache, *ret = NULL;
	struct rb_node *n;
	u64 end, start;

	spin_lock(&info->block_group_cache_lock);
	n = info->block_group_cache_tree.rb_node;

	while (n) {
		cache = rb_entry(n, struct btrfs_block_group_cache,
				 cache_node);
		end = cache->key.objectid + cache->key.offset - 1;
		start = cache->key.objectid;

		if (bytenr < start) {
			if (!contains && (!ret || start < ret->key.objectid))
				ret = cache;
			n = n->rb_left;
		} else if (bytenr > start) {
			if (contains && bytenr <= end) {
				ret = cache;
				break;
			}
			n = n->rb_right;
		} else {
			ret = cache;
			break;
		}
	}
142 143
	if (ret)
		atomic_inc(&ret->count);
J
Josef Bacik 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
	spin_unlock(&info->block_group_cache_lock);

	return ret;
}

/*
 * this is only called by cache_block_group, since we could have freed extents
 * we need to check the pinned_extents for any extents that can't be used yet
 * since their free space will be released as soon as the transaction commits.
 */
static int add_new_free_space(struct btrfs_block_group_cache *block_group,
			      struct btrfs_fs_info *info, u64 start, u64 end)
{
	u64 extent_start, extent_end, size;
	int ret;

	while (start < end) {
		ret = find_first_extent_bit(&info->pinned_extents, start,
					    &extent_start, &extent_end,
					    EXTENT_DIRTY);
		if (ret)
			break;

		if (extent_start == start) {
			start = extent_end + 1;
		} else if (extent_start > start && extent_start < end) {
			size = extent_start - start;
171 172
			ret = btrfs_add_free_space(block_group, start,
						   size);
J
Josef Bacik 已提交
173 174 175 176 177 178 179 180 181
			BUG_ON(ret);
			start = extent_end + 1;
		} else {
			break;
		}
	}

	if (start < end) {
		size = end - start;
182
		ret = btrfs_add_free_space(block_group, start, size);
J
Josef Bacik 已提交
183 184 185 186 187 188
		BUG_ON(ret);
	}

	return 0;
}

Y
Yan Zheng 已提交
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
static int remove_sb_from_cache(struct btrfs_root *root,
				struct btrfs_block_group_cache *cache)
{
	u64 bytenr;
	u64 *logical;
	int stripe_len;
	int i, nr, ret;

	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
		bytenr = btrfs_sb_offset(i);
		ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
				       cache->key.objectid, bytenr, 0,
				       &logical, &nr, &stripe_len);
		BUG_ON(ret);
		while (nr--) {
			btrfs_remove_free_space(cache, logical[nr],
						stripe_len);
		}
		kfree(logical);
	}
	return 0;
}

212 213 214 215
static int cache_block_group(struct btrfs_root *root,
			     struct btrfs_block_group_cache *block_group)
{
	struct btrfs_path *path;
216
	int ret = 0;
217
	struct btrfs_key key;
218
	struct extent_buffer *leaf;
219
	int slot;
Y
Yan Zheng 已提交
220
	u64 last;
221

222 223 224
	if (!block_group)
		return 0;

225 226 227 228
	root = root->fs_info->extent_root;

	if (block_group->cached)
		return 0;
229

230 231 232
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
233

234
	path->reada = 2;
235 236 237 238 239 240
	/*
	 * we get into deadlocks with paths held by callers of this function.
	 * since the alloc_mutex is protecting things right now, just
	 * skip the locking here
	 */
	path->skip_locking = 1;
Y
Yan Zheng 已提交
241 242
	last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
	key.objectid = last;
243 244 245 246
	key.offset = 0;
	btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
247
		goto err;
Y
Yan Zheng 已提交
248

C
Chris Mason 已提交
249
	while (1) {
250
		leaf = path->nodes[0];
251
		slot = path->slots[0];
252
		if (slot >= btrfs_header_nritems(leaf)) {
253
			ret = btrfs_next_leaf(root, path);
254 255
			if (ret < 0)
				goto err;
J
Josef Bacik 已提交
256
			if (ret == 0)
257
				continue;
J
Josef Bacik 已提交
258
			else
259 260
				break;
		}
261
		btrfs_item_key_to_cpu(leaf, &key, slot);
J
Josef Bacik 已提交
262
		if (key.objectid < block_group->key.objectid)
263
			goto next;
J
Josef Bacik 已提交
264

265
		if (key.objectid >= block_group->key.objectid +
J
Josef Bacik 已提交
266
		    block_group->key.offset)
267
			break;
268

269
		if (btrfs_key_type(&key) == BTRFS_EXTENT_ITEM_KEY) {
J
Josef Bacik 已提交
270 271 272
			add_new_free_space(block_group, root->fs_info, last,
					   key.objectid);

273
			last = key.objectid + key.offset;
274
		}
275
next:
276 277 278
		path->slots[0]++;
	}

J
Josef Bacik 已提交
279 280 281 282
	add_new_free_space(block_group, root->fs_info, last,
			   block_group->key.objectid +
			   block_group->key.offset);

283
	block_group->cached = 1;
J
Josef Bacik 已提交
284
	remove_sb_from_cache(root, block_group);
285
	ret = 0;
286
err:
287
	btrfs_free_path(path);
288
	return ret;
289 290
}

J
Josef Bacik 已提交
291 292 293
/*
 * return the block group that starts at or after bytenr
 */
C
Chris Mason 已提交
294 295
static struct btrfs_block_group_cache *
btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
C
Chris Mason 已提交
296
{
J
Josef Bacik 已提交
297
	struct btrfs_block_group_cache *cache;
C
Chris Mason 已提交
298

J
Josef Bacik 已提交
299
	cache = block_group_cache_tree_search(info, bytenr, 0);
C
Chris Mason 已提交
300

J
Josef Bacik 已提交
301
	return cache;
C
Chris Mason 已提交
302 303
}

J
Josef Bacik 已提交
304
/*
305
 * return the block group that contains the given bytenr
J
Josef Bacik 已提交
306
 */
C
Chris Mason 已提交
307 308 309
struct btrfs_block_group_cache *btrfs_lookup_block_group(
						 struct btrfs_fs_info *info,
						 u64 bytenr)
C
Chris Mason 已提交
310
{
J
Josef Bacik 已提交
311
	struct btrfs_block_group_cache *cache;
C
Chris Mason 已提交
312

J
Josef Bacik 已提交
313
	cache = block_group_cache_tree_search(info, bytenr, 1);
314

J
Josef Bacik 已提交
315
	return cache;
C
Chris Mason 已提交
316
}
317

318
void btrfs_put_block_group(struct btrfs_block_group_cache *cache)
319 320 321 322 323
{
	if (atomic_dec_and_test(&cache->count))
		kfree(cache);
}

J
Josef Bacik 已提交
324 325
static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
						  u64 flags)
326
{
J
Josef Bacik 已提交
327 328
	struct list_head *head = &info->space_info;
	struct btrfs_space_info *found;
329 330 331 332 333

	rcu_read_lock();
	list_for_each_entry_rcu(found, head, list) {
		if (found->flags == flags) {
			rcu_read_unlock();
J
Josef Bacik 已提交
334
			return found;
335
		}
J
Josef Bacik 已提交
336
	}
337
	rcu_read_unlock();
J
Josef Bacik 已提交
338
	return NULL;
339 340
}

341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
/*
 * after adding space to the filesystem, we need to clear the full flags
 * on all the space infos.
 */
void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
{
	struct list_head *head = &info->space_info;
	struct btrfs_space_info *found;

	rcu_read_lock();
	list_for_each_entry_rcu(found, head, list)
		found->full = 0;
	rcu_read_unlock();
}

356 357 358 359 360 361 362 363 364
static u64 div_factor(u64 num, int factor)
{
	if (factor == 10)
		return num;
	num *= factor;
	do_div(num, 10);
	return num;
}

365 366
u64 btrfs_find_block_group(struct btrfs_root *root,
			   u64 search_start, u64 search_hint, int owner)
C
Chris Mason 已提交
367
{
368
	struct btrfs_block_group_cache *cache;
C
Chris Mason 已提交
369
	u64 used;
370 371
	u64 last = max(search_hint, search_start);
	u64 group_start = 0;
372
	int full_search = 0;
373
	int factor = 9;
C
Chris Mason 已提交
374
	int wrapped = 0;
375
again:
376 377
	while (1) {
		cache = btrfs_lookup_first_block_group(root->fs_info, last);
J
Josef Bacik 已提交
378 379
		if (!cache)
			break;
380

381
		spin_lock(&cache->lock);
382 383 384
		last = cache->key.objectid + cache->key.offset;
		used = btrfs_block_group_used(&cache->item);

385 386
		if ((full_search || !cache->ro) &&
		    block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
387
			if (used + cache->pinned + cache->reserved <
388 389
			    div_factor(cache->key.offset, factor)) {
				group_start = cache->key.objectid;
390
				spin_unlock(&cache->lock);
391
				btrfs_put_block_group(cache);
392 393
				goto found;
			}
394
		}
395
		spin_unlock(&cache->lock);
396
		btrfs_put_block_group(cache);
397
		cond_resched();
C
Chris Mason 已提交
398
	}
C
Chris Mason 已提交
399 400 401 402 403 404
	if (!wrapped) {
		last = search_start;
		wrapped = 1;
		goto again;
	}
	if (!full_search && factor < 10) {
C
Chris Mason 已提交
405
		last = search_start;
406
		full_search = 1;
C
Chris Mason 已提交
407
		factor = 10;
408 409
		goto again;
	}
C
Chris Mason 已提交
410
found:
411
	return group_start;
412
}
J
Josef Bacik 已提交
413

414
/* simple helper to search for an existing extent at a given offset */
Z
Zheng Yan 已提交
415
int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
416 417 418
{
	int ret;
	struct btrfs_key key;
Z
Zheng Yan 已提交
419
	struct btrfs_path *path;
420

Z
Zheng Yan 已提交
421 422
	path = btrfs_alloc_path();
	BUG_ON(!path);
423 424 425 426 427
	key.objectid = start;
	key.offset = len;
	btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
	ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
				0, 0);
Z
Zheng Yan 已提交
428
	btrfs_free_path(path);
429 430 431
	return ret;
}

432 433 434 435 436 437 438 439 440 441 442 443 444 445
/*
 * Back reference rules.  Back refs have three main goals:
 *
 * 1) differentiate between all holders of references to an extent so that
 *    when a reference is dropped we can make sure it was a valid reference
 *    before freeing the extent.
 *
 * 2) Provide enough information to quickly find the holders of an extent
 *    if we notice a given block is corrupted or bad.
 *
 * 3) Make it easy to migrate blocks for FS shrinking or storage pool
 *    maintenance.  This is actually the same as #2, but with a slightly
 *    different use case.
 *
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
 * There are two kinds of back refs. The implicit back refs is optimized
 * for pointers in non-shared tree blocks. For a given pointer in a block,
 * back refs of this kind provide information about the block's owner tree
 * and the pointer's key. These information allow us to find the block by
 * b-tree searching. The full back refs is for pointers in tree blocks not
 * referenced by their owner trees. The location of tree block is recorded
 * in the back refs. Actually the full back refs is generic, and can be
 * used in all cases the implicit back refs is used. The major shortcoming
 * of the full back refs is its overhead. Every time a tree block gets
 * COWed, we have to update back refs entry for all pointers in it.
 *
 * For a newly allocated tree block, we use implicit back refs for
 * pointers in it. This means most tree related operations only involve
 * implicit back refs. For a tree block created in old transaction, the
 * only way to drop a reference to it is COW it. So we can detect the
 * event that tree block loses its owner tree's reference and do the
 * back refs conversion.
 *
 * When a tree block is COW'd through a tree, there are four cases:
 *
 * The reference count of the block is one and the tree is the block's
 * owner tree. Nothing to do in this case.
 *
 * The reference count of the block is one and the tree is not the
 * block's owner tree. In this case, full back refs is used for pointers
 * in the block. Remove these full back refs, add implicit back refs for
 * every pointers in the new block.
 *
 * The reference count of the block is greater than one and the tree is
 * the block's owner tree. In this case, implicit back refs is used for
 * pointers in the block. Add full back refs for every pointers in the
 * block, increase lower level extents' reference counts. The original
 * implicit back refs are entailed to the new block.
 *
 * The reference count of the block is greater than one and the tree is
 * not the block's owner tree. Add implicit back refs for every pointer in
 * the new block, increase lower level extents' reference count.
 *
 * Back Reference Key composing:
 *
 * The key objectid corresponds to the first byte in the extent,
 * The key type is used to differentiate between types of back refs.
 * There are different meanings of the key offset for different types
 * of back refs.
 *
491 492 493
 * File extents can be referenced by:
 *
 * - multiple snapshots, subvolumes, or different generations in one subvol
Z
Zheng Yan 已提交
494
 * - different files inside a single subvolume
495 496
 * - different offsets inside a file (bookend extents in file.c)
 *
497
 * The extent ref structure for the implicit back refs has fields for:
498 499 500
 *
 * - Objectid of the subvolume root
 * - objectid of the file holding the reference
501 502
 * - original offset in the file
 * - how many bookend extents
503
 *
504 505
 * The key offset for the implicit back refs is hash of the first
 * three fields.
506
 *
507
 * The extent ref structure for the full back refs has field for:
508
 *
509
 * - number of pointers in the tree leaf
510
 *
511 512
 * The key offset for the implicit back refs is the first byte of
 * the tree leaf
513
 *
514 515
 * When a file extent is allocated, The implicit back refs is used.
 * the fields are filled in:
516
 *
517
 *     (root_key.objectid, inode objectid, offset in file, 1)
518
 *
519 520
 * When a file extent is removed file truncation, we find the
 * corresponding implicit back refs and check the following fields:
521
 *
522
 *     (btrfs_header_owner(leaf), inode objectid, offset in file)
523
 *
524
 * Btree extents can be referenced by:
525
 *
526
 * - Different subvolumes
527
 *
528 529 530 531
 * Both the implicit back refs and the full back refs for tree blocks
 * only consist of key. The key offset for the implicit back refs is
 * objectid of block's owner tree. The key offset for the full back refs
 * is the first byte of parent block.
532
 *
533 534 535
 * When implicit back refs is used, information about the lowest key and
 * level of the tree block are required. These information are stored in
 * tree block info structure.
536
 */
Z
Zheng Yan 已提交
537

538 539 540 541 542
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root,
				  struct btrfs_path *path,
				  u64 owner, u32 extra_size)
543
{
544 545 546 547 548
	struct btrfs_extent_item *item;
	struct btrfs_extent_item_v0 *ei0;
	struct btrfs_extent_ref_v0 *ref0;
	struct btrfs_tree_block_info *bi;
	struct extent_buffer *leaf;
549
	struct btrfs_key key;
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
	struct btrfs_key found_key;
	u32 new_size = sizeof(*item);
	u64 refs;
	int ret;

	leaf = path->nodes[0];
	BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));

	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
	ei0 = btrfs_item_ptr(leaf, path->slots[0],
			     struct btrfs_extent_item_v0);
	refs = btrfs_extent_refs_v0(leaf, ei0);

	if (owner == (u64)-1) {
		while (1) {
			if (path->slots[0] >= btrfs_header_nritems(leaf)) {
				ret = btrfs_next_leaf(root, path);
				if (ret < 0)
					return ret;
				BUG_ON(ret > 0);
				leaf = path->nodes[0];
			}
			btrfs_item_key_to_cpu(leaf, &found_key,
					      path->slots[0]);
			BUG_ON(key.objectid != found_key.objectid);
			if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
				path->slots[0]++;
				continue;
			}
			ref0 = btrfs_item_ptr(leaf, path->slots[0],
					      struct btrfs_extent_ref_v0);
			owner = btrfs_ref_objectid_v0(leaf, ref0);
			break;
		}
	}
	btrfs_release_path(root, path);

	if (owner < BTRFS_FIRST_FREE_OBJECTID)
		new_size += sizeof(*bi);

	new_size -= sizeof(*ei0);
	ret = btrfs_search_slot(trans, root, &key, path,
				new_size + extra_size, 1);
	if (ret < 0)
		return ret;
	BUG_ON(ret);

	ret = btrfs_extend_item(trans, root, path, new_size);
	BUG_ON(ret);

	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	btrfs_set_extent_refs(leaf, item, refs);
	/* FIXME: get real generation */
	btrfs_set_extent_generation(leaf, item, 0);
	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
		btrfs_set_extent_flags(leaf, item,
				       BTRFS_EXTENT_FLAG_TREE_BLOCK |
				       BTRFS_BLOCK_FLAG_FULL_BACKREF);
		bi = (struct btrfs_tree_block_info *)(item + 1);
		/* FIXME: get first key of the block */
		memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
		btrfs_set_tree_block_level(leaf, bi, (int)owner);
	} else {
		btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
	}
	btrfs_mark_buffer_dirty(leaf);
	return 0;
}
#endif

static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
{
	u32 high_crc = ~(u32)0;
	u32 low_crc = ~(u32)0;
	__le64 lenum;

	lenum = cpu_to_le64(root_objectid);
	high_crc = btrfs_crc32c(high_crc, &lenum, sizeof(lenum));
	lenum = cpu_to_le64(owner);
	low_crc = btrfs_crc32c(low_crc, &lenum, sizeof(lenum));
	lenum = cpu_to_le64(offset);
	low_crc = btrfs_crc32c(low_crc, &lenum, sizeof(lenum));

	return ((u64)high_crc << 31) ^ (u64)low_crc;
}

static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
				     struct btrfs_extent_data_ref *ref)
{
	return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
				    btrfs_extent_data_ref_objectid(leaf, ref),
				    btrfs_extent_data_ref_offset(leaf, ref));
}

static int match_extent_data_ref(struct extent_buffer *leaf,
				 struct btrfs_extent_data_ref *ref,
				 u64 root_objectid, u64 owner, u64 offset)
{
	if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
	    btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
	    btrfs_extent_data_ref_offset(leaf, ref) != offset)
		return 0;
	return 1;
}

static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
					   struct btrfs_root *root,
					   struct btrfs_path *path,
					   u64 bytenr, u64 parent,
					   u64 root_objectid,
					   u64 owner, u64 offset)
{
	struct btrfs_key key;
	struct btrfs_extent_data_ref *ref;
Z
Zheng Yan 已提交
665
	struct extent_buffer *leaf;
666
	u32 nritems;
667
	int ret;
668 669
	int recow;
	int err = -ENOENT;
670

Z
Zheng Yan 已提交
671
	key.objectid = bytenr;
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
	if (parent) {
		key.type = BTRFS_SHARED_DATA_REF_KEY;
		key.offset = parent;
	} else {
		key.type = BTRFS_EXTENT_DATA_REF_KEY;
		key.offset = hash_extent_data_ref(root_objectid,
						  owner, offset);
	}
again:
	recow = 0;
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
	if (ret < 0) {
		err = ret;
		goto fail;
	}
Z
Zheng Yan 已提交
687

688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	if (parent) {
		if (!ret)
			return 0;
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
		key.type = BTRFS_EXTENT_REF_V0_KEY;
		btrfs_release_path(root, path);
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
		if (ret < 0) {
			err = ret;
			goto fail;
		}
		if (!ret)
			return 0;
#endif
		goto fail;
Z
Zheng Yan 已提交
703 704 705
	}

	leaf = path->nodes[0];
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
	nritems = btrfs_header_nritems(leaf);
	while (1) {
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				err = ret;
			if (ret)
				goto fail;

			leaf = path->nodes[0];
			nritems = btrfs_header_nritems(leaf);
			recow = 1;
		}

		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
		if (key.objectid != bytenr ||
		    key.type != BTRFS_EXTENT_DATA_REF_KEY)
			goto fail;

		ref = btrfs_item_ptr(leaf, path->slots[0],
				     struct btrfs_extent_data_ref);

		if (match_extent_data_ref(leaf, ref, root_objectid,
					  owner, offset)) {
			if (recow) {
				btrfs_release_path(root, path);
				goto again;
			}
			err = 0;
			break;
		}
		path->slots[0]++;
Z
Zheng Yan 已提交
738
	}
739 740
fail:
	return err;
Z
Zheng Yan 已提交
741 742
}

743 744 745 746 747 748
static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
					   struct btrfs_root *root,
					   struct btrfs_path *path,
					   u64 bytenr, u64 parent,
					   u64 root_objectid, u64 owner,
					   u64 offset, int refs_to_add)
Z
Zheng Yan 已提交
749 750 751
{
	struct btrfs_key key;
	struct extent_buffer *leaf;
752
	u32 size;
Z
Zheng Yan 已提交
753 754
	u32 num_refs;
	int ret;
755 756

	key.objectid = bytenr;
757 758 759 760 761 762 763 764 765 766
	if (parent) {
		key.type = BTRFS_SHARED_DATA_REF_KEY;
		key.offset = parent;
		size = sizeof(struct btrfs_shared_data_ref);
	} else {
		key.type = BTRFS_EXTENT_DATA_REF_KEY;
		key.offset = hash_extent_data_ref(root_objectid,
						  owner, offset);
		size = sizeof(struct btrfs_extent_data_ref);
	}
767

768 769 770 771 772 773 774
	ret = btrfs_insert_empty_item(trans, root, path, &key, size);
	if (ret && ret != -EEXIST)
		goto fail;

	leaf = path->nodes[0];
	if (parent) {
		struct btrfs_shared_data_ref *ref;
Z
Zheng Yan 已提交
775
		ref = btrfs_item_ptr(leaf, path->slots[0],
776 777 778 779 780 781 782
				     struct btrfs_shared_data_ref);
		if (ret == 0) {
			btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
		} else {
			num_refs = btrfs_shared_data_ref_count(leaf, ref);
			num_refs += refs_to_add;
			btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
Z
Zheng Yan 已提交
783
		}
784 785 786 787 788 789 790 791 792 793 794 795 796 797
	} else {
		struct btrfs_extent_data_ref *ref;
		while (ret == -EEXIST) {
			ref = btrfs_item_ptr(leaf, path->slots[0],
					     struct btrfs_extent_data_ref);
			if (match_extent_data_ref(leaf, ref, root_objectid,
						  owner, offset))
				break;
			btrfs_release_path(root, path);
			key.offset++;
			ret = btrfs_insert_empty_item(trans, root, path, &key,
						      size);
			if (ret && ret != -EEXIST)
				goto fail;
Z
Zheng Yan 已提交
798

799 800 801 802 803 804 805 806 807 808 809 810 811 812
			leaf = path->nodes[0];
		}
		ref = btrfs_item_ptr(leaf, path->slots[0],
				     struct btrfs_extent_data_ref);
		if (ret == 0) {
			btrfs_set_extent_data_ref_root(leaf, ref,
						       root_objectid);
			btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
			btrfs_set_extent_data_ref_offset(leaf, ref, offset);
			btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
		} else {
			num_refs = btrfs_extent_data_ref_count(leaf, ref);
			num_refs += refs_to_add;
			btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
Z
Zheng Yan 已提交
813 814
		}
	}
815 816 817
	btrfs_mark_buffer_dirty(leaf);
	ret = 0;
fail:
818 819
	btrfs_release_path(root, path);
	return ret;
820 821
}

822 823 824 825
static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
					   struct btrfs_root *root,
					   struct btrfs_path *path,
					   int refs_to_drop)
Z
Zheng Yan 已提交
826
{
827 828 829
	struct btrfs_key key;
	struct btrfs_extent_data_ref *ref1 = NULL;
	struct btrfs_shared_data_ref *ref2 = NULL;
Z
Zheng Yan 已提交
830
	struct extent_buffer *leaf;
831
	u32 num_refs = 0;
Z
Zheng Yan 已提交
832 833 834
	int ret = 0;

	leaf = path->nodes[0];
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

	if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
		ref1 = btrfs_item_ptr(leaf, path->slots[0],
				      struct btrfs_extent_data_ref);
		num_refs = btrfs_extent_data_ref_count(leaf, ref1);
	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
		ref2 = btrfs_item_ptr(leaf, path->slots[0],
				      struct btrfs_shared_data_ref);
		num_refs = btrfs_shared_data_ref_count(leaf, ref2);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	} else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
		struct btrfs_extent_ref_v0 *ref0;
		ref0 = btrfs_item_ptr(leaf, path->slots[0],
				      struct btrfs_extent_ref_v0);
		num_refs = btrfs_ref_count_v0(leaf, ref0);
#endif
	} else {
		BUG();
	}

856 857
	BUG_ON(num_refs < refs_to_drop);
	num_refs -= refs_to_drop;
858

Z
Zheng Yan 已提交
859 860 861
	if (num_refs == 0) {
		ret = btrfs_del_item(trans, root, path);
	} else {
862 863 864 865 866 867 868 869 870 871 872 873
		if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
			btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
		else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
			btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
		else {
			struct btrfs_extent_ref_v0 *ref0;
			ref0 = btrfs_item_ptr(leaf, path->slots[0],
					struct btrfs_extent_ref_v0);
			btrfs_set_ref_count_v0(leaf, ref0, num_refs);
		}
#endif
Z
Zheng Yan 已提交
874 875 876 877 878
		btrfs_mark_buffer_dirty(leaf);
	}
	return ret;
}

879 880 881
static noinline u32 extent_data_ref_count(struct btrfs_root *root,
					  struct btrfs_path *path,
					  struct btrfs_extent_inline_ref *iref)
882
{
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
	struct btrfs_key key;
	struct extent_buffer *leaf;
	struct btrfs_extent_data_ref *ref1;
	struct btrfs_shared_data_ref *ref2;
	u32 num_refs = 0;

	leaf = path->nodes[0];
	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
	if (iref) {
		if (btrfs_extent_inline_ref_type(leaf, iref) ==
		    BTRFS_EXTENT_DATA_REF_KEY) {
			ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
			num_refs = btrfs_extent_data_ref_count(leaf, ref1);
		} else {
			ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
			num_refs = btrfs_shared_data_ref_count(leaf, ref2);
		}
	} else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
		ref1 = btrfs_item_ptr(leaf, path->slots[0],
				      struct btrfs_extent_data_ref);
		num_refs = btrfs_extent_data_ref_count(leaf, ref1);
	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
		ref2 = btrfs_item_ptr(leaf, path->slots[0],
				      struct btrfs_shared_data_ref);
		num_refs = btrfs_shared_data_ref_count(leaf, ref2);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	} else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
		struct btrfs_extent_ref_v0 *ref0;
		ref0 = btrfs_item_ptr(leaf, path->slots[0],
				      struct btrfs_extent_ref_v0);
		num_refs = btrfs_ref_count_v0(leaf, ref0);
C
Chris Mason 已提交
914
#endif
915 916 917 918 919
	} else {
		WARN_ON(1);
	}
	return num_refs;
}
920

921 922 923 924 925
static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path,
					  u64 bytenr, u64 parent,
					  u64 root_objectid)
926
{
927
	struct btrfs_key key;
928 929
	int ret;

930 931 932 933 934 935 936
	key.objectid = bytenr;
	if (parent) {
		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
		key.offset = parent;
	} else {
		key.type = BTRFS_TREE_BLOCK_REF_KEY;
		key.offset = root_objectid;
937 938
	}

939 940 941 942 943 944 945 946 947 948 949
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
	if (ret > 0)
		ret = -ENOENT;
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	if (ret == -ENOENT && parent) {
		btrfs_release_path(root, path);
		key.type = BTRFS_EXTENT_REF_V0_KEY;
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
		if (ret > 0)
			ret = -ENOENT;
	}
950
#endif
951
	return ret;
952 953
}

954 955 956 957 958
static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path,
					  u64 bytenr, u64 parent,
					  u64 root_objectid)
Z
Zheng Yan 已提交
959
{
960
	struct btrfs_key key;
Z
Zheng Yan 已提交
961 962
	int ret;

963 964 965 966 967 968 969 970 971 972 973
	key.objectid = bytenr;
	if (parent) {
		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
		key.offset = parent;
	} else {
		key.type = BTRFS_TREE_BLOCK_REF_KEY;
		key.offset = root_objectid;
	}

	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
	btrfs_release_path(root, path);
Z
Zheng Yan 已提交
974 975 976
	return ret;
}

977
static inline int extent_ref_type(u64 parent, u64 owner)
Z
Zheng Yan 已提交
978
{
979 980 981 982 983 984 985 986 987 988 989 990 991
	int type;
	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
		if (parent > 0)
			type = BTRFS_SHARED_BLOCK_REF_KEY;
		else
			type = BTRFS_TREE_BLOCK_REF_KEY;
	} else {
		if (parent > 0)
			type = BTRFS_SHARED_DATA_REF_KEY;
		else
			type = BTRFS_EXTENT_DATA_REF_KEY;
	}
	return type;
Z
Zheng Yan 已提交
992
}
993

994
static int find_next_key(struct btrfs_path *path, struct btrfs_key *key)
995

C
Chris Mason 已提交
996
{
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	int level;
	BUG_ON(!path->keep_locks);
	for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
		if (!path->nodes[level])
			break;
		btrfs_assert_tree_locked(path->nodes[level]);
		if (path->slots[level] + 1 >=
		    btrfs_header_nritems(path->nodes[level]))
			continue;
		if (level == 0)
			btrfs_item_key_to_cpu(path->nodes[level], key,
					      path->slots[level] + 1);
		else
			btrfs_node_key_to_cpu(path->nodes[level], key,
					      path->slots[level] + 1);
		return 0;
	}
	return 1;
}
C
Chris Mason 已提交
1016

1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
/*
 * look for inline back ref. if back ref is found, *ref_ret is set
 * to the address of inline back ref, and 0 is returned.
 *
 * if back ref isn't found, *ref_ret is set to the address where it
 * should be inserted, and -ENOENT is returned.
 *
 * if insert is true and there are too many inline back refs, the path
 * points to the extent item, and -EAGAIN is returned.
 *
 * NOTE: inline back refs are ordered in the same way that back ref
 *	 items in the tree are ordered.
 */
static noinline_for_stack
int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 struct btrfs_extent_inline_ref **ref_ret,
				 u64 bytenr, u64 num_bytes,
				 u64 parent, u64 root_objectid,
				 u64 owner, u64 offset, int insert)
{
	struct btrfs_key key;
	struct extent_buffer *leaf;
	struct btrfs_extent_item *ei;
	struct btrfs_extent_inline_ref *iref;
	u64 flags;
	u64 item_size;
	unsigned long ptr;
	unsigned long end;
	int extra_size;
	int type;
	int want;
	int ret;
	int err = 0;
1052

1053
	key.objectid = bytenr;
Z
Zheng Yan 已提交
1054
	key.type = BTRFS_EXTENT_ITEM_KEY;
1055
	key.offset = num_bytes;
Z
Zheng Yan 已提交
1056

1057 1058 1059 1060 1061 1062 1063 1064
	want = extent_ref_type(parent, owner);
	if (insert) {
		extra_size = btrfs_extent_inline_ref_size(want);
		if (owner >= BTRFS_FIRST_FREE_OBJECTID)
			path->keep_locks = 1;
	} else
		extra_size = -1;
	ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
1065
	if (ret < 0) {
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
		err = ret;
		goto out;
	}
	BUG_ON(ret);

	leaf = path->nodes[0];
	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	if (item_size < sizeof(*ei)) {
		if (!insert) {
			err = -ENOENT;
			goto out;
		}
		ret = convert_extent_item_v0(trans, root, path, owner,
					     extra_size);
		if (ret < 0) {
			err = ret;
			goto out;
		}
		leaf = path->nodes[0];
		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
	}
#endif
	BUG_ON(item_size < sizeof(*ei));

	if (owner < BTRFS_FIRST_FREE_OBJECTID && insert &&
	    item_size + extra_size >= BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
		err = -EAGAIN;
		goto out;
	}

	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	flags = btrfs_extent_flags(leaf, ei);

	ptr = (unsigned long)(ei + 1);
	end = (unsigned long)ei + item_size;

	if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
		ptr += sizeof(struct btrfs_tree_block_info);
		BUG_ON(ptr > end);
	} else {
		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
	}

	err = -ENOENT;
	while (1) {
		if (ptr >= end) {
			WARN_ON(ptr > end);
			break;
		}
		iref = (struct btrfs_extent_inline_ref *)ptr;
		type = btrfs_extent_inline_ref_type(leaf, iref);
		if (want < type)
			break;
		if (want > type) {
			ptr += btrfs_extent_inline_ref_size(type);
			continue;
		}

		if (type == BTRFS_EXTENT_DATA_REF_KEY) {
			struct btrfs_extent_data_ref *dref;
			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
			if (match_extent_data_ref(leaf, dref, root_objectid,
						  owner, offset)) {
				err = 0;
				break;
			}
			if (hash_extent_data_ref_item(leaf, dref) <
			    hash_extent_data_ref(root_objectid, owner, offset))
				break;
		} else {
			u64 ref_offset;
			ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
			if (parent > 0) {
				if (parent == ref_offset) {
					err = 0;
					break;
				}
				if (ref_offset < parent)
					break;
			} else {
				if (root_objectid == ref_offset) {
					err = 0;
					break;
				}
				if (ref_offset < root_objectid)
					break;
			}
		}
		ptr += btrfs_extent_inline_ref_size(type);
	}
	if (err == -ENOENT && insert) {
		if (item_size + extra_size >=
		    BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
			err = -EAGAIN;
			goto out;
		}
		/*
		 * To add new inline back ref, we have to make sure
		 * there is no corresponding back ref item.
		 * For simplicity, we just do not add new inline back
		 * ref if there is any kind of item for this block
		 */
		if (owner >= BTRFS_FIRST_FREE_OBJECTID &&
		    find_next_key(path, &key) == 0 && key.objectid == bytenr) {
			err = -EAGAIN;
			goto out;
		}
	}
	*ref_ret = (struct btrfs_extent_inline_ref *)ptr;
out:
	if (insert && owner >= BTRFS_FIRST_FREE_OBJECTID) {
		path->keep_locks = 0;
		btrfs_unlock_up_safe(path, 1);
	}
	return err;
}

/*
 * helper to add new inline back ref
 */
static noinline_for_stack
int setup_inline_extent_backref(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				struct btrfs_path *path,
				struct btrfs_extent_inline_ref *iref,
				u64 parent, u64 root_objectid,
				u64 owner, u64 offset, int refs_to_add,
				struct btrfs_delayed_extent_op *extent_op)
{
	struct extent_buffer *leaf;
	struct btrfs_extent_item *ei;
	unsigned long ptr;
	unsigned long end;
	unsigned long item_offset;
	u64 refs;
	int size;
	int type;
	int ret;

	leaf = path->nodes[0];
	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	item_offset = (unsigned long)iref - (unsigned long)ei;

	type = extent_ref_type(parent, owner);
	size = btrfs_extent_inline_ref_size(type);

	ret = btrfs_extend_item(trans, root, path, size);
	BUG_ON(ret);

	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	refs = btrfs_extent_refs(leaf, ei);
	refs += refs_to_add;
	btrfs_set_extent_refs(leaf, ei, refs);
	if (extent_op)
		__run_delayed_extent_op(extent_op, leaf, ei);

	ptr = (unsigned long)ei + item_offset;
	end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
	if (ptr < end - size)
		memmove_extent_buffer(leaf, ptr + size, ptr,
				      end - size - ptr);

	iref = (struct btrfs_extent_inline_ref *)ptr;
	btrfs_set_extent_inline_ref_type(leaf, iref, type);
	if (type == BTRFS_EXTENT_DATA_REF_KEY) {
		struct btrfs_extent_data_ref *dref;
		dref = (struct btrfs_extent_data_ref *)(&iref->offset);
		btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
		btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
		btrfs_set_extent_data_ref_offset(leaf, dref, offset);
		btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
	} else if (type == BTRFS_SHARED_DATA_REF_KEY) {
		struct btrfs_shared_data_ref *sref;
		sref = (struct btrfs_shared_data_ref *)(iref + 1);
		btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
	} else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
	} else {
		btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
	}
	btrfs_mark_buffer_dirty(leaf);
	return 0;
}

static int lookup_extent_backref(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 struct btrfs_extent_inline_ref **ref_ret,
				 u64 bytenr, u64 num_bytes, u64 parent,
				 u64 root_objectid, u64 owner, u64 offset)
{
	int ret;

	ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
					   bytenr, num_bytes, parent,
					   root_objectid, owner, offset, 0);
	if (ret != -ENOENT)
1265
		return ret;
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275

	btrfs_release_path(root, path);
	*ref_ret = NULL;

	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
		ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
					    root_objectid);
	} else {
		ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
					     root_objectid, owner, offset);
1276
	}
1277 1278
	return ret;
}
Z
Zheng Yan 已提交
1279

1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
/*
 * helper to update/remove inline back ref
 */
static noinline_for_stack
int update_inline_extent_backref(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 struct btrfs_extent_inline_ref *iref,
				 int refs_to_mod,
				 struct btrfs_delayed_extent_op *extent_op)
{
	struct extent_buffer *leaf;
	struct btrfs_extent_item *ei;
	struct btrfs_extent_data_ref *dref = NULL;
	struct btrfs_shared_data_ref *sref = NULL;
	unsigned long ptr;
	unsigned long end;
	u32 item_size;
	int size;
	int type;
	int ret;
	u64 refs;

	leaf = path->nodes[0];
	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	refs = btrfs_extent_refs(leaf, ei);
	WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
	refs += refs_to_mod;
	btrfs_set_extent_refs(leaf, ei, refs);
	if (extent_op)
		__run_delayed_extent_op(extent_op, leaf, ei);

	type = btrfs_extent_inline_ref_type(leaf, iref);

	if (type == BTRFS_EXTENT_DATA_REF_KEY) {
		dref = (struct btrfs_extent_data_ref *)(&iref->offset);
		refs = btrfs_extent_data_ref_count(leaf, dref);
	} else if (type == BTRFS_SHARED_DATA_REF_KEY) {
		sref = (struct btrfs_shared_data_ref *)(iref + 1);
		refs = btrfs_shared_data_ref_count(leaf, sref);
	} else {
		refs = 1;
		BUG_ON(refs_to_mod != -1);
1323
	}
Z
Zheng Yan 已提交
1324

1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
	BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
	refs += refs_to_mod;

	if (refs > 0) {
		if (type == BTRFS_EXTENT_DATA_REF_KEY)
			btrfs_set_extent_data_ref_count(leaf, dref, refs);
		else
			btrfs_set_shared_data_ref_count(leaf, sref, refs);
	} else {
		size =  btrfs_extent_inline_ref_size(type);
		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
		ptr = (unsigned long)iref;
		end = (unsigned long)ei + item_size;
		if (ptr + size < end)
			memmove_extent_buffer(leaf, ptr, ptr + size,
					      end - ptr - size);
		item_size -= size;
		ret = btrfs_truncate_item(trans, root, path, item_size, 1);
		BUG_ON(ret);
	}
	btrfs_mark_buffer_dirty(leaf);
	return 0;
}

static noinline_for_stack
int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 u64 bytenr, u64 num_bytes, u64 parent,
				 u64 root_objectid, u64 owner,
				 u64 offset, int refs_to_add,
				 struct btrfs_delayed_extent_op *extent_op)
{
	struct btrfs_extent_inline_ref *iref;
	int ret;

	ret = lookup_inline_extent_backref(trans, root, path, &iref,
					   bytenr, num_bytes, parent,
					   root_objectid, owner, offset, 1);
	if (ret == 0) {
		BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
		ret = update_inline_extent_backref(trans, root, path, iref,
						   refs_to_add, extent_op);
	} else if (ret == -ENOENT) {
		ret = setup_inline_extent_backref(trans, root, path, iref,
						  parent, root_objectid,
						  owner, offset, refs_to_add,
						  extent_op);
1373
	}
1374 1375
	return ret;
}
Z
Zheng Yan 已提交
1376

1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
static int insert_extent_backref(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 u64 bytenr, u64 parent, u64 root_objectid,
				 u64 owner, u64 offset, int refs_to_add)
{
	int ret;
	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
		BUG_ON(refs_to_add != 1);
		ret = insert_tree_block_ref(trans, root, path, bytenr,
					    parent, root_objectid);
	} else {
		ret = insert_extent_data_ref(trans, root, path, bytenr,
					     parent, root_objectid,
					     owner, offset, refs_to_add);
	}
	return ret;
}
1395

1396 1397 1398 1399 1400 1401 1402
static int remove_extent_backref(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 struct btrfs_extent_inline_ref *iref,
				 int refs_to_drop, int is_data)
{
	int ret;
1403

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
	BUG_ON(!is_data && refs_to_drop != 1);
	if (iref) {
		ret = update_inline_extent_backref(trans, root, path, iref,
						   -refs_to_drop, NULL);
	} else if (is_data) {
		ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
	} else {
		ret = btrfs_del_item(trans, root, path);
	}
	return ret;
}

#ifdef BIO_RW_DISCARD
static void btrfs_issue_discard(struct block_device *bdev,
				u64 start, u64 len)
{
	blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL);
}
#endif

static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
				u64 num_bytes)
{
#ifdef BIO_RW_DISCARD
	int ret;
	u64 map_length = num_bytes;
	struct btrfs_multi_bio *multi = NULL;

	/* Tell the block device(s) that the sectors can be discarded */
	ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
			      bytenr, &map_length, &multi, 0);
	if (!ret) {
		struct btrfs_bio_stripe *stripe = multi->stripes;
		int i;

		if (map_length > num_bytes)
			map_length = num_bytes;

		for (i = 0; i < multi->num_stripes; i++, stripe++) {
			btrfs_issue_discard(stripe->dev->bdev,
					    stripe->physical,
					    map_length);
		}
		kfree(multi);
	}

	return ret;
#else
	return 0;
#endif
}

int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
			 struct btrfs_root *root,
			 u64 bytenr, u64 num_bytes, u64 parent,
			 u64 root_objectid, u64 owner, u64 offset)
{
	int ret;
	BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
	       root_objectid == BTRFS_TREE_LOG_OBJECTID);

	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
		ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
					parent, root_objectid, (int)owner,
					BTRFS_ADD_DELAYED_REF, NULL);
	} else {
		ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
					parent, root_objectid, owner, offset,
					BTRFS_ADD_DELAYED_REF, NULL);
	}
	return ret;
}

static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root,
				  u64 bytenr, u64 num_bytes,
				  u64 parent, u64 root_objectid,
				  u64 owner, u64 offset, int refs_to_add,
				  struct btrfs_delayed_extent_op *extent_op)
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_extent_item *item;
	u64 refs;
	int ret;
	int err = 0;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	path->reada = 1;
	path->leave_spinning = 1;
	/* this will setup the path even if it fails to insert the back ref */
	ret = insert_inline_extent_backref(trans, root->fs_info->extent_root,
					   path, bytenr, num_bytes, parent,
					   root_objectid, owner, offset,
					   refs_to_add, extent_op);
	if (ret == 0)
		goto out;

	if (ret != -EAGAIN) {
		err = ret;
		goto out;
	}

	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	refs = btrfs_extent_refs(leaf, item);
	btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
	if (extent_op)
		__run_delayed_extent_op(extent_op, leaf, item);
1516

1517
	btrfs_mark_buffer_dirty(leaf);
1518 1519 1520
	btrfs_release_path(root->fs_info->extent_root, path);

	path->reada = 1;
1521 1522
	path->leave_spinning = 1;

1523 1524
	/* now insert the actual backref */
	ret = insert_extent_backref(trans, root->fs_info->extent_root,
1525 1526
				    path, bytenr, parent, root_objectid,
				    owner, offset, refs_to_add);
1527
	BUG_ON(ret);
1528
out:
1529
	btrfs_free_path(path);
1530
	return err;
1531 1532
}

1533 1534 1535 1536 1537
static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				struct btrfs_delayed_ref_node *node,
				struct btrfs_delayed_extent_op *extent_op,
				int insert_reserved)
1538
{
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
	int ret = 0;
	struct btrfs_delayed_data_ref *ref;
	struct btrfs_key ins;
	u64 parent = 0;
	u64 ref_root = 0;
	u64 flags = 0;

	ins.objectid = node->bytenr;
	ins.offset = node->num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;

	ref = btrfs_delayed_node_to_data_ref(node);
	if (node->type == BTRFS_SHARED_DATA_REF_KEY)
		parent = ref->parent;
	else
		ref_root = ref->root;

	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
		if (extent_op) {
			BUG_ON(extent_op->update_key);
			flags |= extent_op->flags_to_set;
		}
		ret = alloc_reserved_file_extent(trans, root,
						 parent, ref_root, flags,
						 ref->objectid, ref->offset,
						 &ins, node->ref_mod);
		update_reserved_extents(root, ins.objectid, ins.offset, 0);
	} else if (node->action == BTRFS_ADD_DELAYED_REF) {
		ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
					     node->num_bytes, parent,
					     ref_root, ref->objectid,
					     ref->offset, node->ref_mod,
					     extent_op);
	} else if (node->action == BTRFS_DROP_DELAYED_REF) {
		ret = __btrfs_free_extent(trans, root, node->bytenr,
					  node->num_bytes, parent,
					  ref_root, ref->objectid,
					  ref->offset, node->ref_mod,
					  extent_op);
	} else {
		BUG();
	}
	return ret;
}

static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
				    struct extent_buffer *leaf,
				    struct btrfs_extent_item *ei)
{
	u64 flags = btrfs_extent_flags(leaf, ei);
	if (extent_op->update_flags) {
		flags |= extent_op->flags_to_set;
		btrfs_set_extent_flags(leaf, ei, flags);
	}

	if (extent_op->update_key) {
		struct btrfs_tree_block_info *bi;
		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
		bi = (struct btrfs_tree_block_info *)(ei + 1);
		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
	}
}

static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_delayed_ref_node *node,
				 struct btrfs_delayed_extent_op *extent_op)
{
	struct btrfs_key key;
	struct btrfs_path *path;
	struct btrfs_extent_item *ei;
	struct extent_buffer *leaf;
	u32 item_size;
1612
	int ret;
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
	int err = 0;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = node->bytenr;
	key.type = BTRFS_EXTENT_ITEM_KEY;
	key.offset = node->num_bytes;

	path->reada = 1;
	path->leave_spinning = 1;
	ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key,
				path, 0, 1);
	if (ret < 0) {
		err = ret;
		goto out;
	}
	if (ret > 0) {
		err = -EIO;
		goto out;
	}

	leaf = path->nodes[0];
	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	if (item_size < sizeof(*ei)) {
		ret = convert_extent_item_v0(trans, root->fs_info->extent_root,
					     path, (u64)-1, 0);
		if (ret < 0) {
			err = ret;
			goto out;
		}
		leaf = path->nodes[0];
		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
	}
#endif
	BUG_ON(item_size < sizeof(*ei));
	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
	__run_delayed_extent_op(extent_op, leaf, ei);
1653

1654 1655 1656 1657
	btrfs_mark_buffer_dirty(leaf);
out:
	btrfs_free_path(path);
	return err;
1658 1659
}

1660 1661 1662 1663 1664
static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				struct btrfs_delayed_ref_node *node,
				struct btrfs_delayed_extent_op *extent_op,
				int insert_reserved)
1665 1666
{
	int ret = 0;
1667 1668 1669 1670
	struct btrfs_delayed_tree_ref *ref;
	struct btrfs_key ins;
	u64 parent = 0;
	u64 ref_root = 0;
1671

1672 1673 1674
	ins.objectid = node->bytenr;
	ins.offset = node->num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;
1675

1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
	ref = btrfs_delayed_node_to_tree_ref(node);
	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
		parent = ref->parent;
	else
		ref_root = ref->root;

	BUG_ON(node->ref_mod != 1);
	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
		BUG_ON(!extent_op || !extent_op->update_flags ||
		       !extent_op->update_key);
		ret = alloc_reserved_tree_block(trans, root,
						parent, ref_root,
						extent_op->flags_to_set,
						&extent_op->key,
						ref->level, &ins);
		update_reserved_extents(root, ins.objectid, ins.offset, 0);
	} else if (node->action == BTRFS_ADD_DELAYED_REF) {
		ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
					     node->num_bytes, parent, ref_root,
					     ref->level, 0, 1, extent_op);
	} else if (node->action == BTRFS_DROP_DELAYED_REF) {
		ret = __btrfs_free_extent(trans, root, node->bytenr,
					  node->num_bytes, parent, ref_root,
					  ref->level, 0, 1, extent_op);
	} else {
		BUG();
	}
1703 1704 1705
	return ret;
}

1706

1707
/* helper function to actually process a single delayed ref entry */
1708 1709 1710 1711 1712
static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root,
			       struct btrfs_delayed_ref_node *node,
			       struct btrfs_delayed_extent_op *extent_op,
			       int insert_reserved)
1713 1714
{
	int ret;
1715
	if (btrfs_delayed_ref_is_head(node)) {
1716 1717 1718 1719 1720 1721 1722
		struct btrfs_delayed_ref_head *head;
		/*
		 * we've hit the end of the chain and we were supposed
		 * to insert this extent into the tree.  But, it got
		 * deleted before we ever needed to insert it, so all
		 * we have to do is clean up the accounting
		 */
1723 1724
		BUG_ON(extent_op);
		head = btrfs_delayed_node_to_head(node);
1725
		if (insert_reserved) {
1726 1727 1728 1729 1730 1731 1732 1733
			if (head->is_data) {
				ret = btrfs_del_csums(trans, root,
						      node->bytenr,
						      node->num_bytes);
				BUG_ON(ret);
			}
			btrfs_update_pinned_extents(root, node->bytenr,
						    node->num_bytes, 1);
1734 1735 1736 1737 1738 1739 1740
			update_reserved_extents(root, node->bytenr,
						node->num_bytes, 0);
		}
		mutex_unlock(&head->mutex);
		return 0;
	}

1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
	if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
	    node->type == BTRFS_SHARED_BLOCK_REF_KEY)
		ret = run_delayed_tree_ref(trans, root, node, extent_op,
					   insert_reserved);
	else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
		 node->type == BTRFS_SHARED_DATA_REF_KEY)
		ret = run_delayed_data_ref(trans, root, node, extent_op,
					   insert_reserved);
	else
		BUG();
	return ret;
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
}

static noinline struct btrfs_delayed_ref_node *
select_delayed_ref(struct btrfs_delayed_ref_head *head)
{
	struct rb_node *node;
	struct btrfs_delayed_ref_node *ref;
	int action = BTRFS_ADD_DELAYED_REF;
again:
	/*
	 * select delayed ref of type BTRFS_ADD_DELAYED_REF first.
	 * this prevents ref count from going down to zero when
	 * there still are pending delayed ref.
	 */
	node = rb_prev(&head->node.rb_node);
	while (1) {
		if (!node)
			break;
		ref = rb_entry(node, struct btrfs_delayed_ref_node,
				rb_node);
		if (ref->bytenr != head->node.bytenr)
			break;
1774
		if (ref->action == action)
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
			return ref;
		node = rb_prev(node);
	}
	if (action == BTRFS_ADD_DELAYED_REF) {
		action = BTRFS_DROP_DELAYED_REF;
		goto again;
	}
	return NULL;
}

1785 1786 1787
static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
				       struct btrfs_root *root,
				       struct list_head *cluster)
1788 1789 1790 1791
{
	struct btrfs_delayed_ref_root *delayed_refs;
	struct btrfs_delayed_ref_node *ref;
	struct btrfs_delayed_ref_head *locked_ref = NULL;
1792
	struct btrfs_delayed_extent_op *extent_op;
1793
	int ret;
1794
	int count = 0;
1795 1796 1797 1798 1799
	int must_insert_reserved = 0;

	delayed_refs = &trans->transaction->delayed_refs;
	while (1) {
		if (!locked_ref) {
1800 1801
			/* pick a new head ref from the cluster list */
			if (list_empty(cluster))
1802 1803
				break;

1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
			locked_ref = list_entry(cluster->next,
				     struct btrfs_delayed_ref_head, cluster);

			/* grab the lock that says we are going to process
			 * all the refs for this head */
			ret = btrfs_delayed_ref_lock(trans, locked_ref);

			/*
			 * we may have dropped the spin lock to get the head
			 * mutex lock, and that might have given someone else
			 * time to free the head.  If that's true, it has been
			 * removed from our list and we can move on.
			 */
			if (ret == -EAGAIN) {
				locked_ref = NULL;
				count++;
				continue;
1821 1822
			}
		}
1823

1824 1825 1826 1827 1828 1829
		/*
		 * record the must insert reserved flag before we
		 * drop the spin lock.
		 */
		must_insert_reserved = locked_ref->must_insert_reserved;
		locked_ref->must_insert_reserved = 0;
1830

1831 1832 1833
		extent_op = locked_ref->extent_op;
		locked_ref->extent_op = NULL;

1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844
		/*
		 * locked_ref is the head node, so we have to go one
		 * node back for any delayed ref updates
		 */
		ref = select_delayed_ref(locked_ref);
		if (!ref) {
			/* All delayed refs have been processed, Go ahead
			 * and send the head node to run_one_delayed_ref,
			 * so that any accounting fixes can happen
			 */
			ref = &locked_ref->node;
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863

			if (extent_op && must_insert_reserved) {
				kfree(extent_op);
				extent_op = NULL;
			}

			if (extent_op) {
				spin_unlock(&delayed_refs->lock);

				ret = run_delayed_extent_op(trans, root,
							    ref, extent_op);
				BUG_ON(ret);
				kfree(extent_op);

				cond_resched();
				spin_lock(&delayed_refs->lock);
				continue;
			}

1864
			list_del_init(&locked_ref->cluster);
1865 1866
			locked_ref = NULL;
		}
C
Chris Mason 已提交
1867

1868 1869 1870
		ref->in_tree = 0;
		rb_erase(&ref->rb_node, &delayed_refs->root);
		delayed_refs->num_entries--;
1871

1872
		spin_unlock(&delayed_refs->lock);
1873

1874
		ret = run_one_delayed_ref(trans, root, ref, extent_op,
1875 1876
					  must_insert_reserved);
		BUG_ON(ret);
1877

1878 1879
		btrfs_put_delayed_ref(ref);
		kfree(extent_op);
1880
		count++;
1881

1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
		cond_resched();
		spin_lock(&delayed_refs->lock);
	}
	return count;
}

/*
 * this starts processing the delayed reference count updates and
 * extent insertions we have queued up so far.  count can be
 * 0, which means to process everything in the tree at the start
 * of the run (but not newly added entries), or it can be some target
 * number you'd like to process.
 */
int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root, unsigned long count)
{
	struct rb_node *node;
	struct btrfs_delayed_ref_root *delayed_refs;
	struct btrfs_delayed_ref_node *ref;
	struct list_head cluster;
	int ret;
	int run_all = count == (unsigned long)-1;
	int run_most = 0;

	if (root == root->fs_info->extent_root)
		root = root->fs_info->tree_root;

	delayed_refs = &trans->transaction->delayed_refs;
	INIT_LIST_HEAD(&cluster);
again:
	spin_lock(&delayed_refs->lock);
	if (count == 0) {
		count = delayed_refs->num_entries * 2;
		run_most = 1;
	}
	while (1) {
		if (!(run_all || run_most) &&
		    delayed_refs->num_heads_ready < 64)
			break;
1921

1922
		/*
1923 1924 1925 1926
		 * go find something we can process in the rbtree.  We start at
		 * the beginning of the tree, and then build a cluster
		 * of refs to process starting at the first one we are able to
		 * lock
1927
		 */
1928 1929 1930
		ret = btrfs_find_ref_cluster(trans, &cluster,
					     delayed_refs->run_delayed_start);
		if (ret)
1931 1932
			break;

1933 1934 1935 1936 1937 1938 1939
		ret = run_clustered_refs(trans, root, &cluster);
		BUG_ON(ret < 0);

		count -= min_t(unsigned long, ret, count);

		if (count == 0)
			break;
1940
	}
1941

1942 1943
	if (run_all) {
		node = rb_first(&delayed_refs->root);
1944
		if (!node)
1945
			goto out;
1946
		count = (unsigned long)-1;
1947

1948 1949 1950 1951 1952
		while (node) {
			ref = rb_entry(node, struct btrfs_delayed_ref_node,
				       rb_node);
			if (btrfs_delayed_ref_is_head(ref)) {
				struct btrfs_delayed_ref_head *head;
1953

1954 1955 1956 1957 1958 1959 1960 1961
				head = btrfs_delayed_node_to_head(ref);
				atomic_inc(&ref->refs);

				spin_unlock(&delayed_refs->lock);
				mutex_lock(&head->mutex);
				mutex_unlock(&head->mutex);

				btrfs_put_delayed_ref(ref);
1962
				cond_resched();
1963 1964 1965 1966 1967 1968 1969
				goto again;
			}
			node = rb_next(node);
		}
		spin_unlock(&delayed_refs->lock);
		schedule_timeout(1);
		goto again;
1970
	}
1971
out:
1972
	spin_unlock(&delayed_refs->lock);
1973 1974 1975
	return 0;
}

1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				u64 bytenr, u64 num_bytes, u64 flags,
				int is_data)
{
	struct btrfs_delayed_extent_op *extent_op;
	int ret;

	extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
	if (!extent_op)
		return -ENOMEM;

	extent_op->flags_to_set = flags;
	extent_op->update_flags = 1;
	extent_op->update_key = 0;
	extent_op->is_data = is_data ? 1 : 0;

	ret = btrfs_add_delayed_extent_op(trans, bytenr, num_bytes, extent_op);
	if (ret)
		kfree(extent_op);
	return ret;
}

static noinline int check_delayed_ref(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      struct btrfs_path *path,
				      u64 objectid, u64 offset, u64 bytenr)
{
	struct btrfs_delayed_ref_head *head;
	struct btrfs_delayed_ref_node *ref;
	struct btrfs_delayed_data_ref *data_ref;
	struct btrfs_delayed_ref_root *delayed_refs;
	struct rb_node *node;
	int ret = 0;

	ret = -ENOENT;
	delayed_refs = &trans->transaction->delayed_refs;
	spin_lock(&delayed_refs->lock);
	head = btrfs_find_delayed_ref_head(trans, bytenr);
	if (!head)
		goto out;

	if (!mutex_trylock(&head->mutex)) {
		atomic_inc(&head->node.refs);
		spin_unlock(&delayed_refs->lock);

		btrfs_release_path(root->fs_info->extent_root, path);

		mutex_lock(&head->mutex);
		mutex_unlock(&head->mutex);
		btrfs_put_delayed_ref(&head->node);
		return -EAGAIN;
	}

	node = rb_prev(&head->node.rb_node);
	if (!node)
		goto out_unlock;

	ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);

	if (ref->bytenr != bytenr)
		goto out_unlock;

	ret = 1;
	if (ref->type != BTRFS_EXTENT_DATA_REF_KEY)
		goto out_unlock;

	data_ref = btrfs_delayed_node_to_data_ref(ref);

	node = rb_prev(node);
	if (node) {
		ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
		if (ref->bytenr == bytenr)
			goto out_unlock;
	}

	if (data_ref->root != root->root_key.objectid ||
	    data_ref->objectid != objectid || data_ref->offset != offset)
		goto out_unlock;

	ret = 0;
out_unlock:
	mutex_unlock(&head->mutex);
out:
	spin_unlock(&delayed_refs->lock);
	return ret;
}

static noinline int check_committed_ref(struct btrfs_trans_handle *trans,
					struct btrfs_root *root,
					struct btrfs_path *path,
					u64 objectid, u64 offset, u64 bytenr)
2068 2069
{
	struct btrfs_root *extent_root = root->fs_info->extent_root;
2070
	struct extent_buffer *leaf;
2071 2072 2073
	struct btrfs_extent_data_ref *ref;
	struct btrfs_extent_inline_ref *iref;
	struct btrfs_extent_item *ei;
2074
	struct btrfs_key key;
2075
	u32 item_size;
2076
	int ret;
2077

2078
	key.objectid = bytenr;
Z
Zheng Yan 已提交
2079
	key.offset = (u64)-1;
2080
	key.type = BTRFS_EXTENT_ITEM_KEY;
2081 2082 2083 2084 2085

	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
	if (ret < 0)
		goto out;
	BUG_ON(ret == 0);
Y
Yan Zheng 已提交
2086 2087 2088

	ret = -ENOENT;
	if (path->slots[0] == 0)
Z
Zheng Yan 已提交
2089
		goto out;
2090

Z
Zheng Yan 已提交
2091
	path->slots[0]--;
2092
	leaf = path->nodes[0];
2093
	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2094

2095
	if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
2096
		goto out;
2097

2098 2099 2100 2101 2102 2103 2104 2105 2106
	ret = 1;
	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	if (item_size < sizeof(*ei)) {
		WARN_ON(item_size != sizeof(struct btrfs_extent_item_v0));
		goto out;
	}
#endif
	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2107

2108 2109 2110
	if (item_size != sizeof(*ei) +
	    btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY))
		goto out;
2111

2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
	if (btrfs_extent_generation(leaf, ei) <=
	    btrfs_root_last_snapshot(&root->root_item))
		goto out;

	iref = (struct btrfs_extent_inline_ref *)(ei + 1);
	if (btrfs_extent_inline_ref_type(leaf, iref) !=
	    BTRFS_EXTENT_DATA_REF_KEY)
		goto out;

	ref = (struct btrfs_extent_data_ref *)(&iref->offset);
	if (btrfs_extent_refs(leaf, ei) !=
	    btrfs_extent_data_ref_count(leaf, ref) ||
	    btrfs_extent_data_ref_root(leaf, ref) !=
	    root->root_key.objectid ||
	    btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
	    btrfs_extent_data_ref_offset(leaf, ref) != offset)
		goto out;

	ret = 0;
out:
	return ret;
}

int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root,
			  u64 objectid, u64 offset, u64 bytenr)
{
	struct btrfs_path *path;
	int ret;
	int ret2;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOENT;

	do {
		ret = check_committed_ref(trans, root, path, objectid,
					  offset, bytenr);
		if (ret && ret != -ENOENT)
2151
			goto out;
Y
Yan Zheng 已提交
2152

2153 2154 2155 2156 2157 2158 2159
		ret2 = check_delayed_ref(trans, root, path, objectid,
					 offset, bytenr);
	} while (ret2 == -EAGAIN);

	if (ret2 && ret2 != -ENOENT) {
		ret = ret2;
		goto out;
2160
	}
2161 2162 2163

	if (ret != -ENOENT || ret2 != -ENOENT)
		ret = 0;
2164
out:
Y
Yan Zheng 已提交
2165
	btrfs_free_path(path);
2166
	return ret;
2167
}
C
Chris Mason 已提交
2168

2169
#if 0
Z
Zheng Yan 已提交
2170 2171
int btrfs_cache_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		    struct extent_buffer *buf, u32 nr_extents)
C
Chris Mason 已提交
2172
{
2173
	struct btrfs_key key;
2174
	struct btrfs_file_extent_item *fi;
Z
Zheng Yan 已提交
2175 2176
	u64 root_gen;
	u32 nritems;
C
Chris Mason 已提交
2177
	int i;
2178
	int level;
Z
Zheng Yan 已提交
2179
	int ret = 0;
Z
Zheng Yan 已提交
2180
	int shared = 0;
2181

2182
	if (!root->ref_cows)
2183
		return 0;
2184

Z
Zheng Yan 已提交
2185 2186 2187 2188 2189 2190 2191 2192
	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
		shared = 0;
		root_gen = root->root_key.offset;
	} else {
		shared = 1;
		root_gen = trans->transid - 1;
	}

2193
	level = btrfs_header_level(buf);
2194
	nritems = btrfs_header_nritems(buf);
C
Chris Mason 已提交
2195

Z
Zheng Yan 已提交
2196
	if (level == 0) {
Y
Yan Zheng 已提交
2197 2198 2199
		struct btrfs_leaf_ref *ref;
		struct btrfs_extent_info *info;

Z
Zheng Yan 已提交
2200
		ref = btrfs_alloc_leaf_ref(root, nr_extents);
Y
Yan Zheng 已提交
2201
		if (!ref) {
Z
Zheng Yan 已提交
2202
			ret = -ENOMEM;
Y
Yan Zheng 已提交
2203 2204 2205
			goto out;
		}

Z
Zheng Yan 已提交
2206
		ref->root_gen = root_gen;
Y
Yan Zheng 已提交
2207 2208 2209
		ref->bytenr = buf->start;
		ref->owner = btrfs_header_owner(buf);
		ref->generation = btrfs_header_generation(buf);
Z
Zheng Yan 已提交
2210
		ref->nritems = nr_extents;
Y
Yan Zheng 已提交
2211
		info = ref->extents;
2212

Z
Zheng Yan 已提交
2213
		for (i = 0; nr_extents > 0 && i < nritems; i++) {
Y
Yan Zheng 已提交
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234
			u64 disk_bytenr;
			btrfs_item_key_to_cpu(buf, &key, i);
			if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
				continue;
			fi = btrfs_item_ptr(buf, i,
					    struct btrfs_file_extent_item);
			if (btrfs_file_extent_type(buf, fi) ==
			    BTRFS_FILE_EXTENT_INLINE)
				continue;
			disk_bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
			if (disk_bytenr == 0)
				continue;

			info->bytenr = disk_bytenr;
			info->num_bytes =
				btrfs_file_extent_disk_num_bytes(buf, fi);
			info->objectid = key.objectid;
			info->offset = key.offset;
			info++;
		}

Z
Zheng Yan 已提交
2235
		ret = btrfs_add_leaf_ref(root, ref, shared);
Y
Yan Zheng 已提交
2236 2237 2238 2239 2240 2241 2242 2243
		if (ret == -EEXIST && shared) {
			struct btrfs_leaf_ref *old;
			old = btrfs_lookup_leaf_ref(root, ref->bytenr);
			BUG_ON(!old);
			btrfs_remove_leaf_ref(root, old);
			btrfs_free_leaf_ref(root, old);
			ret = btrfs_add_leaf_ref(root, ref, shared);
		}
Y
Yan Zheng 已提交
2244
		WARN_ON(ret);
2245
		btrfs_free_leaf_ref(root, ref);
Y
Yan Zheng 已提交
2246 2247
	}
out:
Z
Zheng Yan 已提交
2248 2249 2250
	return ret;
}

2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261
/* when a block goes through cow, we update the reference counts of
 * everything that block points to.  The internal pointers of the block
 * can be in just about any order, and it is likely to have clusters of
 * things that are close together and clusters of things that are not.
 *
 * To help reduce the seeks that come with updating all of these reference
 * counts, sort them by byte number before actual updates are done.
 *
 * struct refsort is used to match byte number to slot in the btree block.
 * we sort based on the byte number and then use the slot to actually
 * find the item.
2262 2263 2264 2265 2266
 *
 * struct refsort is smaller than strcut btrfs_item and smaller than
 * struct btrfs_key_ptr.  Since we're currently limited to the page size
 * for a btree block, there's no way for a kmalloc of refsorts for a
 * single node to be bigger than a page.
2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
 */
struct refsort {
	u64 bytenr;
	u32 slot;
};

/*
 * for passing into sort()
 */
static int refsort_cmp(const void *a_void, const void *b_void)
{
	const struct refsort *a = a_void;
	const struct refsort *b = b_void;

	if (a->bytenr < b->bytenr)
		return -1;
	if (a->bytenr > b->bytenr)
		return 1;
	return 0;
}
2287
#endif
2288

2289
static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
2290
			   struct btrfs_root *root,
2291 2292
			   struct extent_buffer *buf,
			   int full_backref, int inc)
Z
Zheng Yan 已提交
2293 2294
{
	u64 bytenr;
2295 2296
	u64 num_bytes;
	u64 parent;
Z
Zheng Yan 已提交
2297 2298 2299 2300 2301 2302 2303 2304
	u64 ref_root;
	u32 nritems;
	struct btrfs_key key;
	struct btrfs_file_extent_item *fi;
	int i;
	int level;
	int ret = 0;
	int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
2305
			    u64, u64, u64, u64, u64, u64);
Z
Zheng Yan 已提交
2306 2307 2308 2309 2310

	ref_root = btrfs_header_owner(buf);
	nritems = btrfs_header_nritems(buf);
	level = btrfs_header_level(buf);

2311 2312
	if (!root->ref_cows && level == 0)
		return 0;
Z
Zheng Yan 已提交
2313

2314 2315 2316 2317
	if (inc)
		process_func = btrfs_inc_extent_ref;
	else
		process_func = btrfs_free_extent;
Z
Zheng Yan 已提交
2318

2319 2320 2321 2322 2323 2324
	if (full_backref)
		parent = buf->start;
	else
		parent = 0;

	for (i = 0; i < nritems; i++) {
Z
Zheng Yan 已提交
2325
		if (level == 0) {
2326
			btrfs_item_key_to_cpu(buf, &key, i);
Z
Zheng Yan 已提交
2327 2328
			if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
				continue;
2329
			fi = btrfs_item_ptr(buf, i,
Z
Zheng Yan 已提交
2330 2331 2332 2333 2334 2335 2336
					    struct btrfs_file_extent_item);
			if (btrfs_file_extent_type(buf, fi) ==
			    BTRFS_FILE_EXTENT_INLINE)
				continue;
			bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
			if (bytenr == 0)
				continue;
2337 2338 2339 2340 2341 2342

			num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
			key.offset -= btrfs_file_extent_offset(buf, fi);
			ret = process_func(trans, root, bytenr, num_bytes,
					   parent, ref_root, key.objectid,
					   key.offset);
Z
Zheng Yan 已提交
2343 2344 2345
			if (ret)
				goto fail;
		} else {
2346 2347 2348 2349
			bytenr = btrfs_node_blockptr(buf, i);
			num_bytes = btrfs_level_size(root, level - 1);
			ret = process_func(trans, root, bytenr, num_bytes,
					   parent, ref_root, level - 1, 0);
Z
Zheng Yan 已提交
2350 2351 2352 2353 2354 2355
			if (ret)
				goto fail;
		}
	}
	return 0;
fail:
2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369
	BUG();
	return ret;
}

int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		  struct extent_buffer *buf, int full_backref)
{
	return __btrfs_mod_ref(trans, root, buf, full_backref, 1);
}

int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		  struct extent_buffer *buf, int full_backref)
{
	return __btrfs_mod_ref(trans, root, buf, full_backref, 0);
Z
Zheng Yan 已提交
2370 2371
}

C
Chris Mason 已提交
2372 2373 2374 2375 2376 2377 2378
static int write_one_cache_group(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path,
				 struct btrfs_block_group_cache *cache)
{
	int ret;
	struct btrfs_root *extent_root = root->fs_info->extent_root;
2379 2380
	unsigned long bi;
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2381 2382

	ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
2383 2384
	if (ret < 0)
		goto fail;
C
Chris Mason 已提交
2385
	BUG_ON(ret);
2386 2387 2388 2389 2390

	leaf = path->nodes[0];
	bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
	write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
2391
	btrfs_release_path(extent_root, path);
2392
fail:
C
Chris Mason 已提交
2393 2394 2395 2396 2397 2398
	if (ret)
		return ret;
	return 0;

}

2399 2400
int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
C
Chris Mason 已提交
2401
{
J
Josef Bacik 已提交
2402 2403
	struct btrfs_block_group_cache *cache, *entry;
	struct rb_node *n;
C
Chris Mason 已提交
2404 2405 2406
	int err = 0;
	int werr = 0;
	struct btrfs_path *path;
2407
	u64 last = 0;
C
Chris Mason 已提交
2408 2409 2410 2411 2412

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

C
Chris Mason 已提交
2413
	while (1) {
J
Josef Bacik 已提交
2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425
		cache = NULL;
		spin_lock(&root->fs_info->block_group_cache_lock);
		for (n = rb_first(&root->fs_info->block_group_cache_tree);
		     n; n = rb_next(n)) {
			entry = rb_entry(n, struct btrfs_block_group_cache,
					 cache_node);
			if (entry->dirty) {
				cache = entry;
				break;
			}
		}
		spin_unlock(&root->fs_info->block_group_cache_lock);
2426

J
Josef Bacik 已提交
2427
		if (!cache)
2428
			break;
J
Josef Bacik 已提交
2429

2430
		cache->dirty = 0;
J
Josef Bacik 已提交
2431 2432
		last += cache->key.offset;

2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
		err = write_one_cache_group(trans, root,
					    path, cache);
		/*
		 * if we fail to write the cache group, we want
		 * to keep it marked dirty in hopes that a later
		 * write will work
		 */
		if (err) {
			werr = err;
			continue;
C
Chris Mason 已提交
2443 2444 2445 2446 2447 2448
		}
	}
	btrfs_free_path(path);
	return werr;
}

2449 2450 2451 2452 2453 2454 2455 2456 2457
int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
{
	struct btrfs_block_group_cache *block_group;
	int readonly = 0;

	block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
	if (!block_group || block_group->ro)
		readonly = 1;
	if (block_group)
2458
		btrfs_put_block_group(block_group);
2459 2460 2461
	return readonly;
}

2462 2463 2464 2465 2466 2467 2468 2469
static int update_space_info(struct btrfs_fs_info *info, u64 flags,
			     u64 total_bytes, u64 bytes_used,
			     struct btrfs_space_info **space_info)
{
	struct btrfs_space_info *found;

	found = __find_space_info(info, flags);
	if (found) {
2470
		spin_lock(&found->lock);
2471 2472
		found->total_bytes += total_bytes;
		found->bytes_used += bytes_used;
2473
		found->full = 0;
2474
		spin_unlock(&found->lock);
2475 2476 2477
		*space_info = found;
		return 0;
	}
Y
Yan Zheng 已提交
2478
	found = kzalloc(sizeof(*found), GFP_NOFS);
2479 2480 2481
	if (!found)
		return -ENOMEM;

J
Josef Bacik 已提交
2482
	INIT_LIST_HEAD(&found->block_groups);
2483
	init_rwsem(&found->groups_sem);
J
Josef Bacik 已提交
2484
	spin_lock_init(&found->lock);
2485 2486 2487 2488
	found->flags = flags;
	found->total_bytes = total_bytes;
	found->bytes_used = bytes_used;
	found->bytes_pinned = 0;
2489
	found->bytes_reserved = 0;
Y
Yan Zheng 已提交
2490
	found->bytes_readonly = 0;
J
Josef Bacik 已提交
2491
	found->bytes_delalloc = 0;
2492
	found->full = 0;
C
Chris Mason 已提交
2493
	found->force_alloc = 0;
2494
	*space_info = found;
2495
	list_add_rcu(&found->list, &info->space_info);
2496 2497 2498
	return 0;
}

2499 2500 2501
static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
{
	u64 extra_flags = flags & (BTRFS_BLOCK_GROUP_RAID0 |
2502
				   BTRFS_BLOCK_GROUP_RAID1 |
C
Chris Mason 已提交
2503
				   BTRFS_BLOCK_GROUP_RAID10 |
2504
				   BTRFS_BLOCK_GROUP_DUP);
2505 2506 2507 2508 2509 2510 2511 2512 2513
	if (extra_flags) {
		if (flags & BTRFS_BLOCK_GROUP_DATA)
			fs_info->avail_data_alloc_bits |= extra_flags;
		if (flags & BTRFS_BLOCK_GROUP_METADATA)
			fs_info->avail_metadata_alloc_bits |= extra_flags;
		if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
			fs_info->avail_system_alloc_bits |= extra_flags;
	}
}
2514

Y
Yan Zheng 已提交
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
static void set_block_group_readonly(struct btrfs_block_group_cache *cache)
{
	spin_lock(&cache->space_info->lock);
	spin_lock(&cache->lock);
	if (!cache->ro) {
		cache->space_info->bytes_readonly += cache->key.offset -
					btrfs_block_group_used(&cache->item);
		cache->ro = 1;
	}
	spin_unlock(&cache->lock);
	spin_unlock(&cache->space_info->lock);
}

Y
Yan Zheng 已提交
2528
u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
2529
{
Y
Yan Zheng 已提交
2530
	u64 num_devices = root->fs_info->fs_devices->rw_devices;
2531 2532 2533 2534 2535 2536

	if (num_devices == 1)
		flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0);
	if (num_devices < 4)
		flags &= ~BTRFS_BLOCK_GROUP_RAID10;

2537 2538
	if ((flags & BTRFS_BLOCK_GROUP_DUP) &&
	    (flags & (BTRFS_BLOCK_GROUP_RAID1 |
2539
		      BTRFS_BLOCK_GROUP_RAID10))) {
2540
		flags &= ~BTRFS_BLOCK_GROUP_DUP;
2541
	}
2542 2543

	if ((flags & BTRFS_BLOCK_GROUP_RAID1) &&
2544
	    (flags & BTRFS_BLOCK_GROUP_RAID10)) {
2545
		flags &= ~BTRFS_BLOCK_GROUP_RAID1;
2546
	}
2547 2548 2549 2550 2551 2552 2553 2554 2555

	if ((flags & BTRFS_BLOCK_GROUP_RAID0) &&
	    ((flags & BTRFS_BLOCK_GROUP_RAID1) |
	     (flags & BTRFS_BLOCK_GROUP_RAID10) |
	     (flags & BTRFS_BLOCK_GROUP_DUP)))
		flags &= ~BTRFS_BLOCK_GROUP_RAID0;
	return flags;
}

J
Josef Bacik 已提交
2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
static u64 btrfs_get_alloc_profile(struct btrfs_root *root, u64 data)
{
	struct btrfs_fs_info *info = root->fs_info;
	u64 alloc_profile;

	if (data) {
		alloc_profile = info->avail_data_alloc_bits &
			info->data_alloc_profile;
		data = BTRFS_BLOCK_GROUP_DATA | alloc_profile;
	} else if (root == root->fs_info->chunk_root) {
		alloc_profile = info->avail_system_alloc_bits &
			info->system_alloc_profile;
		data = BTRFS_BLOCK_GROUP_SYSTEM | alloc_profile;
	} else {
		alloc_profile = info->avail_metadata_alloc_bits &
			info->metadata_alloc_profile;
		data = BTRFS_BLOCK_GROUP_METADATA | alloc_profile;
	}

	return btrfs_reduce_alloc_profile(root, data);
}

void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *inode)
{
	u64 alloc_target;

	alloc_target = btrfs_get_alloc_profile(root, 1);
	BTRFS_I(inode)->space_info = __find_space_info(root->fs_info,
						       alloc_target);
}

/*
 * for now this just makes sure we have at least 5% of our metadata space free
 * for use.
 */
int btrfs_check_metadata_free_space(struct btrfs_root *root)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_space_info *meta_sinfo;
	u64 alloc_target, thresh;
2596
	int committed = 0, ret;
J
Josef Bacik 已提交
2597 2598 2599 2600 2601

	/* get the space info for where the metadata will live */
	alloc_target = btrfs_get_alloc_profile(root, 0);
	meta_sinfo = __find_space_info(info, alloc_target);

2602
again:
J
Josef Bacik 已提交
2603
	spin_lock(&meta_sinfo->lock);
2604 2605 2606 2607
	if (!meta_sinfo->full)
		thresh = meta_sinfo->total_bytes * 80;
	else
		thresh = meta_sinfo->total_bytes * 95;
J
Josef Bacik 已提交
2608 2609 2610 2611 2612

	do_div(thresh, 100);

	if (meta_sinfo->bytes_used + meta_sinfo->bytes_reserved +
	    meta_sinfo->bytes_pinned + meta_sinfo->bytes_readonly > thresh) {
2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626
		struct btrfs_trans_handle *trans;
		if (!meta_sinfo->full) {
			meta_sinfo->force_alloc = 1;
			spin_unlock(&meta_sinfo->lock);

			trans = btrfs_start_transaction(root, 1);
			if (!trans)
				return -ENOMEM;

			ret = do_chunk_alloc(trans, root->fs_info->extent_root,
					     2 * 1024 * 1024, alloc_target, 0);
			btrfs_end_transaction(trans, root);
			goto again;
		}
J
Josef Bacik 已提交
2627
		spin_unlock(&meta_sinfo->lock);
2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638

		if (!committed) {
			committed = 1;
			trans = btrfs_join_transaction(root, 1);
			if (!trans)
				return -ENOMEM;
			ret = btrfs_commit_transaction(trans, root);
			if (ret)
				return ret;
			goto again;
		}
J
Josef Bacik 已提交
2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
		return -ENOSPC;
	}
	spin_unlock(&meta_sinfo->lock);

	return 0;
}

/*
 * This will check the space that the inode allocates from to make sure we have
 * enough space for bytes.
 */
int btrfs_check_data_free_space(struct btrfs_root *root, struct inode *inode,
				u64 bytes)
{
	struct btrfs_space_info *data_sinfo;
2654
	int ret = 0, committed = 0;
J
Josef Bacik 已提交
2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666

	/* make sure bytes are sectorsize aligned */
	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);

	data_sinfo = BTRFS_I(inode)->space_info;
again:
	/* make sure we have enough space to handle the data first */
	spin_lock(&data_sinfo->lock);
	if (data_sinfo->total_bytes - data_sinfo->bytes_used -
	    data_sinfo->bytes_delalloc - data_sinfo->bytes_reserved -
	    data_sinfo->bytes_pinned - data_sinfo->bytes_readonly -
	    data_sinfo->bytes_may_use < bytes) {
2667 2668
		struct btrfs_trans_handle *trans;

J
Josef Bacik 已提交
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692
		/*
		 * if we don't have enough free bytes in this space then we need
		 * to alloc a new chunk.
		 */
		if (!data_sinfo->full) {
			u64 alloc_target;

			data_sinfo->force_alloc = 1;
			spin_unlock(&data_sinfo->lock);

			alloc_target = btrfs_get_alloc_profile(root, 1);
			trans = btrfs_start_transaction(root, 1);
			if (!trans)
				return -ENOMEM;

			ret = do_chunk_alloc(trans, root->fs_info->extent_root,
					     bytes + 2 * 1024 * 1024,
					     alloc_target, 0);
			btrfs_end_transaction(trans, root);
			if (ret)
				return ret;
			goto again;
		}
		spin_unlock(&data_sinfo->lock);
2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705

		/* commit the current transaction and try again */
		if (!committed) {
			committed = 1;
			trans = btrfs_join_transaction(root, 1);
			if (!trans)
				return -ENOMEM;
			ret = btrfs_commit_transaction(trans, root);
			if (ret)
				return ret;
			goto again;
		}

J
Josef Bacik 已提交
2706 2707 2708
		printk(KERN_ERR "no space left, need %llu, %llu delalloc bytes"
		       ", %llu bytes_used, %llu bytes_reserved, "
		       "%llu bytes_pinned, %llu bytes_readonly, %llu may use"
2709 2710 2711 2712 2713 2714 2715 2716
		       "%llu total\n", (unsigned long long)bytes,
		       (unsigned long long)data_sinfo->bytes_delalloc,
		       (unsigned long long)data_sinfo->bytes_used,
		       (unsigned long long)data_sinfo->bytes_reserved,
		       (unsigned long long)data_sinfo->bytes_pinned,
		       (unsigned long long)data_sinfo->bytes_readonly,
		       (unsigned long long)data_sinfo->bytes_may_use,
		       (unsigned long long)data_sinfo->total_bytes);
J
Josef Bacik 已提交
2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786
		return -ENOSPC;
	}
	data_sinfo->bytes_may_use += bytes;
	BTRFS_I(inode)->reserved_bytes += bytes;
	spin_unlock(&data_sinfo->lock);

	return btrfs_check_metadata_free_space(root);
}

/*
 * if there was an error for whatever reason after calling
 * btrfs_check_data_free_space, call this so we can cleanup the counters.
 */
void btrfs_free_reserved_data_space(struct btrfs_root *root,
				    struct inode *inode, u64 bytes)
{
	struct btrfs_space_info *data_sinfo;

	/* make sure bytes are sectorsize aligned */
	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);

	data_sinfo = BTRFS_I(inode)->space_info;
	spin_lock(&data_sinfo->lock);
	data_sinfo->bytes_may_use -= bytes;
	BTRFS_I(inode)->reserved_bytes -= bytes;
	spin_unlock(&data_sinfo->lock);
}

/* called when we are adding a delalloc extent to the inode's io_tree */
void btrfs_delalloc_reserve_space(struct btrfs_root *root, struct inode *inode,
				  u64 bytes)
{
	struct btrfs_space_info *data_sinfo;

	/* get the space info for where this inode will be storing its data */
	data_sinfo = BTRFS_I(inode)->space_info;

	/* make sure we have enough space to handle the data first */
	spin_lock(&data_sinfo->lock);
	data_sinfo->bytes_delalloc += bytes;

	/*
	 * we are adding a delalloc extent without calling
	 * btrfs_check_data_free_space first.  This happens on a weird
	 * writepage condition, but shouldn't hurt our accounting
	 */
	if (unlikely(bytes > BTRFS_I(inode)->reserved_bytes)) {
		data_sinfo->bytes_may_use -= BTRFS_I(inode)->reserved_bytes;
		BTRFS_I(inode)->reserved_bytes = 0;
	} else {
		data_sinfo->bytes_may_use -= bytes;
		BTRFS_I(inode)->reserved_bytes -= bytes;
	}

	spin_unlock(&data_sinfo->lock);
}

/* called when we are clearing an delalloc extent from the inode's io_tree */
void btrfs_delalloc_free_space(struct btrfs_root *root, struct inode *inode,
			      u64 bytes)
{
	struct btrfs_space_info *info;

	info = BTRFS_I(inode)->space_info;

	spin_lock(&info->lock);
	info->bytes_delalloc -= bytes;
	spin_unlock(&info->lock);
}

2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799
static void force_metadata_allocation(struct btrfs_fs_info *info)
{
	struct list_head *head = &info->space_info;
	struct btrfs_space_info *found;

	rcu_read_lock();
	list_for_each_entry_rcu(found, head, list) {
		if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
			found->force_alloc = 1;
	}
	rcu_read_unlock();
}

2800 2801
static int do_chunk_alloc(struct btrfs_trans_handle *trans,
			  struct btrfs_root *extent_root, u64 alloc_bytes,
C
Chris Mason 已提交
2802
			  u64 flags, int force)
2803 2804
{
	struct btrfs_space_info *space_info;
2805
	struct btrfs_fs_info *fs_info = extent_root->fs_info;
2806
	u64 thresh;
Y
Yan Zheng 已提交
2807 2808
	int ret = 0;

2809
	mutex_lock(&fs_info->chunk_mutex);
2810

Y
Yan Zheng 已提交
2811
	flags = btrfs_reduce_alloc_profile(extent_root, flags);
2812

2813
	space_info = __find_space_info(extent_root->fs_info, flags);
2814 2815 2816 2817 2818
	if (!space_info) {
		ret = update_space_info(extent_root->fs_info, flags,
					0, 0, &space_info);
		BUG_ON(ret);
	}
2819 2820
	BUG_ON(!space_info);

2821
	spin_lock(&space_info->lock);
C
Chris Mason 已提交
2822 2823 2824 2825
	if (space_info->force_alloc) {
		force = 1;
		space_info->force_alloc = 0;
	}
2826 2827
	if (space_info->full) {
		spin_unlock(&space_info->lock);
2828
		goto out;
2829
	}
2830

Y
Yan Zheng 已提交
2831 2832
	thresh = space_info->total_bytes - space_info->bytes_readonly;
	thresh = div_factor(thresh, 6);
C
Chris Mason 已提交
2833
	if (!force &&
2834
	   (space_info->bytes_used + space_info->bytes_pinned +
2835 2836
	    space_info->bytes_reserved + alloc_bytes) < thresh) {
		spin_unlock(&space_info->lock);
2837
		goto out;
2838 2839 2840
	}
	spin_unlock(&space_info->lock);

2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852
	/*
	 * if we're doing a data chunk, go ahead and make sure that
	 * we keep a reasonable number of metadata chunks allocated in the
	 * FS as well.
	 */
	if (flags & BTRFS_BLOCK_GROUP_DATA) {
		fs_info->data_chunk_allocations++;
		if (!(fs_info->data_chunk_allocations %
		      fs_info->metadata_ratio))
			force_metadata_allocation(fs_info);
	}

Y
Yan Zheng 已提交
2853
	ret = btrfs_alloc_chunk(trans, extent_root, flags);
C
Chris Mason 已提交
2854
	if (ret)
2855
		space_info->full = 1;
2856
out:
Y
Yan Zheng 已提交
2857
	mutex_unlock(&extent_root->fs_info->chunk_mutex);
J
Josef Bacik 已提交
2858
	return ret;
2859 2860
}

C
Chris Mason 已提交
2861 2862
static int update_block_group(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
2863
			      u64 bytenr, u64 num_bytes, int alloc,
2864
			      int mark_free)
C
Chris Mason 已提交
2865 2866 2867
{
	struct btrfs_block_group_cache *cache;
	struct btrfs_fs_info *info = root->fs_info;
2868
	u64 total = num_bytes;
C
Chris Mason 已提交
2869
	u64 old_val;
2870
	u64 byte_in_group;
C
Chris Mason 已提交
2871

2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
	/* block accounting for super block */
	spin_lock(&info->delalloc_lock);
	old_val = btrfs_super_bytes_used(&info->super_copy);
	if (alloc)
		old_val += num_bytes;
	else
		old_val -= num_bytes;
	btrfs_set_super_bytes_used(&info->super_copy, old_val);

	/* block accounting for root item */
	old_val = btrfs_root_used(&root->root_item);
	if (alloc)
		old_val += num_bytes;
	else
		old_val -= num_bytes;
	btrfs_set_root_used(&root->root_item, old_val);
	spin_unlock(&info->delalloc_lock);

C
Chris Mason 已提交
2890
	while (total) {
2891
		cache = btrfs_lookup_block_group(info, bytenr);
2892
		if (!cache)
C
Chris Mason 已提交
2893
			return -1;
2894 2895
		byte_in_group = bytenr - cache->key.objectid;
		WARN_ON(byte_in_group > cache->key.offset);
C
Chris Mason 已提交
2896

2897
		spin_lock(&cache->space_info->lock);
2898
		spin_lock(&cache->lock);
J
Josef Bacik 已提交
2899
		cache->dirty = 1;
C
Chris Mason 已提交
2900
		old_val = btrfs_block_group_used(&cache->item);
2901
		num_bytes = min(total, cache->key.offset - byte_in_group);
C
Chris Mason 已提交
2902
		if (alloc) {
2903
			old_val += num_bytes;
2904
			cache->space_info->bytes_used += num_bytes;
Y
Yan Zheng 已提交
2905
			if (cache->ro)
Y
Yan Zheng 已提交
2906
				cache->space_info->bytes_readonly -= num_bytes;
2907 2908
			btrfs_set_block_group_used(&cache->item, old_val);
			spin_unlock(&cache->lock);
2909
			spin_unlock(&cache->space_info->lock);
C
Chris Mason 已提交
2910
		} else {
2911
			old_val -= num_bytes;
2912
			cache->space_info->bytes_used -= num_bytes;
Y
Yan Zheng 已提交
2913 2914
			if (cache->ro)
				cache->space_info->bytes_readonly += num_bytes;
2915 2916
			btrfs_set_block_group_used(&cache->item, old_val);
			spin_unlock(&cache->lock);
2917
			spin_unlock(&cache->space_info->lock);
2918
			if (mark_free) {
J
Josef Bacik 已提交
2919
				int ret;
2920 2921 2922 2923 2924

				ret = btrfs_discard_extent(root, bytenr,
							   num_bytes);
				WARN_ON(ret);

J
Josef Bacik 已提交
2925 2926
				ret = btrfs_add_free_space(cache, bytenr,
							   num_bytes);
2927
				WARN_ON(ret);
2928
			}
C
Chris Mason 已提交
2929
		}
2930
		btrfs_put_block_group(cache);
2931 2932
		total -= num_bytes;
		bytenr += num_bytes;
C
Chris Mason 已提交
2933 2934 2935
	}
	return 0;
}
2936

2937 2938
static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
{
J
Josef Bacik 已提交
2939
	struct btrfs_block_group_cache *cache;
2940
	u64 bytenr;
J
Josef Bacik 已提交
2941 2942 2943

	cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
	if (!cache)
2944
		return 0;
J
Josef Bacik 已提交
2945

2946
	bytenr = cache->key.objectid;
2947
	btrfs_put_block_group(cache);
2948 2949

	return bytenr;
2950 2951
}

2952
int btrfs_update_pinned_extents(struct btrfs_root *root,
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965
				u64 bytenr, u64 num, int pin)
{
	u64 len;
	struct btrfs_block_group_cache *cache;
	struct btrfs_fs_info *fs_info = root->fs_info;

	if (pin) {
		set_extent_dirty(&fs_info->pinned_extents,
				bytenr, bytenr + num - 1, GFP_NOFS);
	} else {
		clear_extent_dirty(&fs_info->pinned_extents,
				bytenr, bytenr + num - 1, GFP_NOFS);
	}
2966

2967 2968
	while (num > 0) {
		cache = btrfs_lookup_block_group(fs_info, bytenr);
2969 2970 2971
		BUG_ON(!cache);
		len = min(num, cache->key.offset -
			  (bytenr - cache->key.objectid));
2972
		if (pin) {
2973
			spin_lock(&cache->space_info->lock);
2974 2975 2976 2977
			spin_lock(&cache->lock);
			cache->pinned += len;
			cache->space_info->bytes_pinned += len;
			spin_unlock(&cache->lock);
2978
			spin_unlock(&cache->space_info->lock);
2979 2980
			fs_info->total_pinned += len;
		} else {
2981
			spin_lock(&cache->space_info->lock);
2982 2983 2984 2985
			spin_lock(&cache->lock);
			cache->pinned -= len;
			cache->space_info->bytes_pinned -= len;
			spin_unlock(&cache->lock);
2986
			spin_unlock(&cache->space_info->lock);
2987
			fs_info->total_pinned -= len;
2988 2989
			if (cache->cached)
				btrfs_add_free_space(cache, bytenr, len);
2990
		}
2991
		btrfs_put_block_group(cache);
2992 2993 2994 2995 2996
		bytenr += len;
		num -= len;
	}
	return 0;
}
C
Chris Mason 已提交
2997

2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
static int update_reserved_extents(struct btrfs_root *root,
				   u64 bytenr, u64 num, int reserve)
{
	u64 len;
	struct btrfs_block_group_cache *cache;
	struct btrfs_fs_info *fs_info = root->fs_info;

	while (num > 0) {
		cache = btrfs_lookup_block_group(fs_info, bytenr);
		BUG_ON(!cache);
		len = min(num, cache->key.offset -
			  (bytenr - cache->key.objectid));
3010 3011 3012

		spin_lock(&cache->space_info->lock);
		spin_lock(&cache->lock);
3013 3014 3015 3016 3017 3018 3019
		if (reserve) {
			cache->reserved += len;
			cache->space_info->bytes_reserved += len;
		} else {
			cache->reserved -= len;
			cache->space_info->bytes_reserved -= len;
		}
3020 3021
		spin_unlock(&cache->lock);
		spin_unlock(&cache->space_info->lock);
3022
		btrfs_put_block_group(cache);
3023 3024 3025 3026 3027 3028
		bytenr += len;
		num -= len;
	}
	return 0;
}

3029
int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy)
C
Chris Mason 已提交
3030 3031
{
	u64 last = 0;
3032 3033
	u64 start;
	u64 end;
3034
	struct extent_io_tree *pinned_extents = &root->fs_info->pinned_extents;
C
Chris Mason 已提交
3035 3036
	int ret;

C
Chris Mason 已提交
3037
	while (1) {
3038 3039 3040
		ret = find_first_extent_bit(pinned_extents, last,
					    &start, &end, EXTENT_DIRTY);
		if (ret)
C
Chris Mason 已提交
3041
			break;
3042 3043
		set_extent_dirty(copy, start, end, GFP_NOFS);
		last = end + 1;
C
Chris Mason 已提交
3044 3045 3046 3047 3048 3049
	}
	return 0;
}

int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root,
3050
			       struct extent_io_tree *unpin)
3051
{
3052 3053
	u64 start;
	u64 end;
3054 3055
	int ret;

C
Chris Mason 已提交
3056
	while (1) {
3057 3058 3059
		ret = find_first_extent_bit(unpin, 0, &start, &end,
					    EXTENT_DIRTY);
		if (ret)
3060
			break;
3061 3062 3063

		ret = btrfs_discard_extent(root, start, end + 1 - start);

3064
		/* unlocks the pinned mutex */
3065
		btrfs_update_pinned_extents(root, start, end + 1 - start, 0);
3066
		clear_extent_dirty(unpin, start, end, GFP_NOFS);
3067

3068
		cond_resched();
3069
	}
3070
	return ret;
3071 3072
}

Z
Zheng Yan 已提交
3073 3074
static int pin_down_bytes(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root,
3075 3076 3077
			  struct btrfs_path *path,
			  u64 bytenr, u64 num_bytes, int is_data,
			  struct extent_buffer **must_clean)
C
Chris Mason 已提交
3078
{
3079
	int err = 0;
Z
Zheng Yan 已提交
3080
	struct extent_buffer *buf;
C
Chris Mason 已提交
3081

Z
Zheng Yan 已提交
3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100
	if (is_data)
		goto pinit;

	buf = btrfs_find_tree_block(root, bytenr, num_bytes);
	if (!buf)
		goto pinit;

	/* we can reuse a block if it hasn't been written
	 * and it is from this transaction.  We can't
	 * reuse anything from the tree log root because
	 * it has tiny sub-transactions.
	 */
	if (btrfs_buffer_uptodate(buf, 0) &&
	    btrfs_try_tree_lock(buf)) {
		u64 header_owner = btrfs_header_owner(buf);
		u64 header_transid = btrfs_header_generation(buf);
		if (header_owner != BTRFS_TREE_LOG_OBJECTID &&
		    header_transid == trans->transid &&
		    !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
3101
			*must_clean = buf;
Z
Zheng Yan 已提交
3102
			return 1;
C
Chris Mason 已提交
3103
		}
Z
Zheng Yan 已提交
3104
		btrfs_tree_unlock(buf);
C
Chris Mason 已提交
3105
	}
Z
Zheng Yan 已提交
3106 3107
	free_extent_buffer(buf);
pinit:
3108 3109
	btrfs_set_path_blocking(path);
	/* unlocks the pinned mutex */
Z
Zheng Yan 已提交
3110 3111
	btrfs_update_pinned_extents(root, bytenr, num_bytes, 1);

C
Chris Mason 已提交
3112
	BUG_ON(err < 0);
C
Chris Mason 已提交
3113 3114 3115
	return 0;
}

3116 3117 3118 3119 3120 3121 3122

static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				u64 bytenr, u64 num_bytes, u64 parent,
				u64 root_objectid, u64 owner_objectid,
				u64 owner_offset, int refs_to_drop,
				struct btrfs_delayed_extent_op *extent_op)
3123
{
C
Chris Mason 已提交
3124
	struct btrfs_key key;
3125
	struct btrfs_path *path;
3126 3127
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_root *extent_root = info->extent_root;
3128
	struct extent_buffer *leaf;
3129 3130
	struct btrfs_extent_item *ei;
	struct btrfs_extent_inline_ref *iref;
3131
	int ret;
3132
	int is_data;
3133 3134 3135
	int extent_slot = 0;
	int found_extent = 0;
	int num_to_del = 1;
3136 3137
	u32 item_size;
	u64 refs;
C
Chris Mason 已提交
3138

3139
	path = btrfs_alloc_path();
3140 3141
	if (!path)
		return -ENOMEM;
3142

3143
	path->reada = 1;
3144
	path->leave_spinning = 1;
3145 3146 3147 3148 3149 3150 3151 3152

	is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
	BUG_ON(!is_data && refs_to_drop != 1);

	ret = lookup_extent_backref(trans, extent_root, path, &iref,
				    bytenr, num_bytes, parent,
				    root_objectid, owner_objectid,
				    owner_offset);
3153
	if (ret == 0) {
3154
		extent_slot = path->slots[0];
3155 3156
		while (extent_slot >= 0) {
			btrfs_item_key_to_cpu(path->nodes[0], &key,
3157
					      extent_slot);
3158
			if (key.objectid != bytenr)
3159
				break;
3160 3161
			if (key.type == BTRFS_EXTENT_ITEM_KEY &&
			    key.offset == num_bytes) {
3162 3163 3164 3165 3166
				found_extent = 1;
				break;
			}
			if (path->slots[0] - extent_slot > 5)
				break;
3167
			extent_slot--;
3168
		}
3169 3170 3171 3172 3173
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
		item_size = btrfs_item_size_nr(path->nodes[0], extent_slot);
		if (found_extent && item_size < sizeof(*ei))
			found_extent = 0;
#endif
Z
Zheng Yan 已提交
3174
		if (!found_extent) {
3175
			BUG_ON(iref);
3176
			ret = remove_extent_backref(trans, extent_root, path,
3177 3178
						    NULL, refs_to_drop,
						    is_data);
Z
Zheng Yan 已提交
3179 3180
			BUG_ON(ret);
			btrfs_release_path(extent_root, path);
3181
			path->leave_spinning = 1;
3182 3183 3184 3185 3186

			key.objectid = bytenr;
			key.type = BTRFS_EXTENT_ITEM_KEY;
			key.offset = num_bytes;

Z
Zheng Yan 已提交
3187 3188
			ret = btrfs_search_slot(trans, extent_root,
						&key, path, -1, 1);
3189 3190
			if (ret) {
				printk(KERN_ERR "umm, got %d back from search"
C
Chris Mason 已提交
3191 3192
				       ", was looking for %llu\n", ret,
				       (unsigned long long)bytenr);
3193 3194
				btrfs_print_leaf(extent_root, path->nodes[0]);
			}
Z
Zheng Yan 已提交
3195 3196 3197
			BUG_ON(ret);
			extent_slot = path->slots[0];
		}
3198 3199 3200
	} else {
		btrfs_print_leaf(extent_root, path->nodes[0]);
		WARN_ON(1);
C
Chris Mason 已提交
3201
		printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
3202
		       "parent %llu root %llu  owner %llu offset %llu\n",
C
Chris Mason 已提交
3203
		       (unsigned long long)bytenr,
3204
		       (unsigned long long)parent,
C
Chris Mason 已提交
3205
		       (unsigned long long)root_objectid,
3206 3207
		       (unsigned long long)owner_objectid,
		       (unsigned long long)owner_offset);
3208
	}
3209 3210

	leaf = path->nodes[0];
3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240
	item_size = btrfs_item_size_nr(leaf, extent_slot);
#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
	if (item_size < sizeof(*ei)) {
		BUG_ON(found_extent || extent_slot != path->slots[0]);
		ret = convert_extent_item_v0(trans, extent_root, path,
					     owner_objectid, 0);
		BUG_ON(ret < 0);

		btrfs_release_path(extent_root, path);
		path->leave_spinning = 1;

		key.objectid = bytenr;
		key.type = BTRFS_EXTENT_ITEM_KEY;
		key.offset = num_bytes;

		ret = btrfs_search_slot(trans, extent_root, &key, path,
					-1, 1);
		if (ret) {
			printk(KERN_ERR "umm, got %d back from search"
			       ", was looking for %llu\n", ret,
			       (unsigned long long)bytenr);
			btrfs_print_leaf(extent_root, path->nodes[0]);
		}
		BUG_ON(ret);
		extent_slot = path->slots[0];
		leaf = path->nodes[0];
		item_size = btrfs_item_size_nr(leaf, extent_slot);
	}
#endif
	BUG_ON(item_size < sizeof(*ei));
3241
	ei = btrfs_item_ptr(leaf, extent_slot,
C
Chris Mason 已提交
3242
			    struct btrfs_extent_item);
3243 3244 3245 3246 3247 3248
	if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID) {
		struct btrfs_tree_block_info *bi;
		BUG_ON(item_size < sizeof(*ei) + sizeof(*bi));
		bi = (struct btrfs_tree_block_info *)(ei + 1);
		WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
	}
3249

3250
	refs = btrfs_extent_refs(leaf, ei);
3251 3252
	BUG_ON(refs < refs_to_drop);
	refs -= refs_to_drop;
3253

3254 3255 3256 3257 3258 3259
	if (refs > 0) {
		if (extent_op)
			__run_delayed_extent_op(extent_op, leaf, ei);
		/*
		 * In the case of inline back ref, reference count will
		 * be updated by remove_extent_backref
3260
		 */
3261 3262 3263 3264 3265 3266 3267 3268 3269 3270
		if (iref) {
			BUG_ON(!found_extent);
		} else {
			btrfs_set_extent_refs(leaf, ei, refs);
			btrfs_mark_buffer_dirty(leaf);
		}
		if (found_extent) {
			ret = remove_extent_backref(trans, extent_root, path,
						    iref, refs_to_drop,
						    is_data);
3271 3272
			BUG_ON(ret);
		}
3273 3274
	} else {
		int mark_free = 0;
3275
		struct extent_buffer *must_clean = NULL;
C
Chris Mason 已提交
3276

3277 3278 3279 3280 3281 3282 3283 3284 3285 3286
		if (found_extent) {
			BUG_ON(is_data && refs_to_drop !=
			       extent_data_ref_count(root, path, iref));
			if (iref) {
				BUG_ON(path->slots[0] != extent_slot);
			} else {
				BUG_ON(path->slots[0] != extent_slot + 1);
				path->slots[0] = extent_slot;
				num_to_del = 2;
			}
C
Chris Mason 已提交
3287
		}
3288

3289 3290 3291 3292 3293
		ret = pin_down_bytes(trans, root, path, bytenr,
				     num_bytes, is_data, &must_clean);
		if (ret > 0)
			mark_free = 1;
		BUG_ON(ret < 0);
3294 3295 3296 3297 3298 3299 3300 3301 3302
		/*
		 * it is going to be very rare for someone to be waiting
		 * on the block we're freeing.  del_items might need to
		 * schedule, so rather than get fancy, just force it
		 * to blocking here
		 */
		if (must_clean)
			btrfs_set_lock_blocking(must_clean);

3303 3304
		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
				      num_to_del);
Z
Zheng Yan 已提交
3305
		BUG_ON(ret);
3306
		btrfs_release_path(extent_root, path);
3307

3308 3309 3310 3311 3312 3313
		if (must_clean) {
			clean_tree_block(NULL, root, must_clean);
			btrfs_tree_unlock(must_clean);
			free_extent_buffer(must_clean);
		}

3314
		if (is_data) {
3315 3316
			ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
			BUG_ON(ret);
3317 3318 3319 3320
		} else {
			invalidate_mapping_pages(info->btree_inode->i_mapping,
			     bytenr >> PAGE_CACHE_SHIFT,
			     (bytenr + num_bytes - 1) >> PAGE_CACHE_SHIFT);
3321 3322
		}

3323 3324 3325
		ret = update_block_group(trans, root, bytenr, num_bytes, 0,
					 mark_free);
		BUG_ON(ret);
3326
	}
3327
	btrfs_free_path(path);
3328 3329 3330
	return ret;
}

3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361
/*
 * when we free an extent, it is possible (and likely) that we free the last
 * delayed ref for that extent as well.  This searches the delayed ref tree for
 * a given extent, and if there are no other delayed refs to be processed, it
 * removes it from the tree.
 */
static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root, u64 bytenr)
{
	struct btrfs_delayed_ref_head *head;
	struct btrfs_delayed_ref_root *delayed_refs;
	struct btrfs_delayed_ref_node *ref;
	struct rb_node *node;
	int ret;

	delayed_refs = &trans->transaction->delayed_refs;
	spin_lock(&delayed_refs->lock);
	head = btrfs_find_delayed_ref_head(trans, bytenr);
	if (!head)
		goto out;

	node = rb_prev(&head->node.rb_node);
	if (!node)
		goto out;

	ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);

	/* there are still entries for this ref, we can't drop it */
	if (ref->bytenr == bytenr)
		goto out;

3362 3363 3364 3365 3366 3367 3368
	if (head->extent_op) {
		if (!head->must_insert_reserved)
			goto out;
		kfree(head->extent_op);
		head->extent_op = NULL;
	}

3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381
	/*
	 * waiting for the lock here would deadlock.  If someone else has it
	 * locked they are already in the process of dropping it anyway
	 */
	if (!mutex_trylock(&head->mutex))
		goto out;

	/*
	 * at this point we have a head with no other entries.  Go
	 * ahead and process it.
	 */
	head->node.in_tree = 0;
	rb_erase(&head->node.rb_node, &delayed_refs->root);
3382

3383 3384 3385 3386 3387 3388
	delayed_refs->num_entries--;

	/*
	 * we don't take a ref on the node because we're removing it from the
	 * tree, so we just steal the ref the tree was holding.
	 */
3389 3390 3391 3392 3393
	delayed_refs->num_heads--;
	if (list_empty(&head->cluster))
		delayed_refs->num_heads_ready--;

	list_del_init(&head->cluster);
3394 3395 3396
	spin_unlock(&delayed_refs->lock);

	ret = run_one_delayed_ref(trans, root->fs_info->tree_root,
3397 3398
				  &head->node, head->extent_op,
				  head->must_insert_reserved);
3399 3400 3401 3402 3403 3404 3405 3406
	BUG_ON(ret);
	btrfs_put_delayed_ref(&head->node);
	return 0;
out:
	spin_unlock(&delayed_refs->lock);
	return 0;
}

3407
int btrfs_free_extent(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
3408 3409
		      struct btrfs_root *root,
		      u64 bytenr, u64 num_bytes, u64 parent,
3410
		      u64 root_objectid, u64 owner, u64 offset)
3411 3412 3413
{
	int ret;

3414 3415 3416 3417
	/*
	 * tree log blocks never actually go into the extent allocation
	 * tree, just update pinning info and exit early.
	 */
3418 3419
	if (root_objectid == BTRFS_TREE_LOG_OBJECTID) {
		WARN_ON(owner >= BTRFS_FIRST_FREE_OBJECTID);
3420
		/* unlocks the pinned mutex */
3421 3422 3423
		btrfs_update_pinned_extents(root, bytenr, num_bytes, 1);
		update_reserved_extents(root, bytenr, num_bytes, 0);
		ret = 0;
3424 3425 3426 3427
	} else if (owner < BTRFS_FIRST_FREE_OBJECTID) {
		ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
					parent, root_objectid, (int)owner,
					BTRFS_DROP_DELAYED_REF, NULL);
3428 3429 3430
		BUG_ON(ret);
		ret = check_ref_cleanup(trans, root, bytenr);
		BUG_ON(ret);
3431 3432 3433 3434 3435
	} else {
		ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
					parent, root_objectid, owner,
					offset, BTRFS_DROP_DELAYED_REF, NULL);
		BUG_ON(ret);
3436
	}
3437 3438 3439
	return ret;
}

3440 3441 3442 3443 3444 3445 3446
static u64 stripe_align(struct btrfs_root *root, u64 val)
{
	u64 mask = ((u64)root->stripesize - 1);
	u64 ret = (val + mask) & ~mask;
	return ret;
}

3447 3448 3449 3450
/*
 * walks the btree of allocated extents and find a hole of a given size.
 * The key ins is changed to record the hole:
 * ins->objectid == block start
3451
 * ins->flags = BTRFS_EXTENT_ITEM_KEY
3452 3453 3454
 * ins->offset == number of blocks
 * Any available blocks before search_start are skipped.
 */
C
Chris Mason 已提交
3455
static noinline int find_free_extent(struct btrfs_trans_handle *trans,
3456 3457 3458 3459 3460 3461
				     struct btrfs_root *orig_root,
				     u64 num_bytes, u64 empty_size,
				     u64 search_start, u64 search_end,
				     u64 hint_byte, struct btrfs_key *ins,
				     u64 exclude_start, u64 exclude_nr,
				     int data)
3462
{
3463
	int ret = 0;
C
Chris Mason 已提交
3464
	struct btrfs_root *root = orig_root->fs_info->extent_root;
3465
	struct btrfs_free_cluster *last_ptr = NULL;
3466
	struct btrfs_block_group_cache *block_group = NULL;
3467
	int empty_cluster = 2 * 1024 * 1024;
C
Chris Mason 已提交
3468
	int allowed_chunk_alloc = 0;
3469
	struct btrfs_space_info *space_info;
3470 3471
	int last_ptr_loop = 0;
	int loop = 0;
3472

3473
	WARN_ON(num_bytes < root->sectorsize);
3474
	btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
3475 3476
	ins->objectid = 0;
	ins->offset = 0;
3477

J
Josef Bacik 已提交
3478 3479
	space_info = __find_space_info(root->fs_info, data);

C
Chris Mason 已提交
3480 3481 3482
	if (orig_root->ref_cows || empty_size)
		allowed_chunk_alloc = 1;

3483
	if (data & BTRFS_BLOCK_GROUP_METADATA) {
3484
		last_ptr = &root->fs_info->meta_alloc_cluster;
3485 3486
		if (!btrfs_test_opt(root, SSD))
			empty_cluster = 64 * 1024;
3487 3488
	}

3489 3490 3491
	if ((data & BTRFS_BLOCK_GROUP_DATA) && btrfs_test_opt(root, SSD)) {
		last_ptr = &root->fs_info->data_alloc_cluster;
	}
J
Josef Bacik 已提交
3492

3493
	if (last_ptr) {
3494 3495 3496 3497
		spin_lock(&last_ptr->lock);
		if (last_ptr->block_group)
			hint_byte = last_ptr->window_start;
		spin_unlock(&last_ptr->lock);
3498
	}
3499

3500
	search_start = max(search_start, first_logical_byte(root, 0));
3501
	search_start = max(search_start, hint_byte);
3502

3503 3504 3505 3506 3507
	if (!last_ptr) {
		empty_cluster = 0;
		loop = 1;
	}

J
Josef Bacik 已提交
3508 3509 3510 3511 3512
	if (search_start == hint_byte) {
		block_group = btrfs_lookup_block_group(root->fs_info,
						       search_start);
		if (block_group && block_group_bits(block_group, data)) {
			down_read(&space_info->groups_sem);
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524
			if (list_empty(&block_group->list) ||
			    block_group->ro) {
				/*
				 * someone is removing this block group,
				 * we can't jump into the have_block_group
				 * target because our list pointers are not
				 * valid
				 */
				btrfs_put_block_group(block_group);
				up_read(&space_info->groups_sem);
			} else
				goto have_block_group;
J
Josef Bacik 已提交
3525
		} else if (block_group) {
3526
			btrfs_put_block_group(block_group);
J
Josef Bacik 已提交
3527
		}
3528
	}
3529

J
Josef Bacik 已提交
3530
search:
3531
	down_read(&space_info->groups_sem);
J
Josef Bacik 已提交
3532
	list_for_each_entry(block_group, &space_info->block_groups, list) {
3533
		u64 offset;
3534

J
Josef Bacik 已提交
3535 3536
		atomic_inc(&block_group->count);
		search_start = block_group->key.objectid;
3537

J
Josef Bacik 已提交
3538
have_block_group:
3539 3540 3541 3542
		if (unlikely(!block_group->cached)) {
			mutex_lock(&block_group->cache_mutex);
			ret = cache_block_group(root, block_group);
			mutex_unlock(&block_group->cache_mutex);
J
Josef Bacik 已提交
3543
			if (ret) {
3544
				btrfs_put_block_group(block_group);
3545
				break;
J
Josef Bacik 已提交
3546
			}
3547 3548 3549
		}

		if (unlikely(block_group->ro))
J
Josef Bacik 已提交
3550
			goto loop;
J
Josef Bacik 已提交
3551

3552 3553 3554 3555 3556 3557
		if (last_ptr) {
			/*
			 * the refill lock keeps out other
			 * people trying to start a new cluster
			 */
			spin_lock(&last_ptr->refill_lock);
3558 3559 3560 3561 3562 3563 3564
			if (last_ptr->block_group &&
			    (last_ptr->block_group->ro ||
			    !block_group_bits(last_ptr->block_group, data))) {
				offset = 0;
				goto refill_cluster;
			}

3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589
			offset = btrfs_alloc_from_cluster(block_group, last_ptr,
						 num_bytes, search_start);
			if (offset) {
				/* we have a block, we're done */
				spin_unlock(&last_ptr->refill_lock);
				goto checks;
			}

			spin_lock(&last_ptr->lock);
			/*
			 * whoops, this cluster doesn't actually point to
			 * this block group.  Get a ref on the block
			 * group is does point to and try again
			 */
			if (!last_ptr_loop && last_ptr->block_group &&
			    last_ptr->block_group != block_group) {

				btrfs_put_block_group(block_group);
				block_group = last_ptr->block_group;
				atomic_inc(&block_group->count);
				spin_unlock(&last_ptr->lock);
				spin_unlock(&last_ptr->refill_lock);

				last_ptr_loop = 1;
				search_start = block_group->key.objectid;
3590 3591 3592 3593 3594 3595 3596
				/*
				 * we know this block group is properly
				 * in the list because
				 * btrfs_remove_block_group, drops the
				 * cluster before it removes the block
				 * group from the list
				 */
3597 3598 3599
				goto have_block_group;
			}
			spin_unlock(&last_ptr->lock);
3600
refill_cluster:
3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642
			/*
			 * this cluster didn't work out, free it and
			 * start over
			 */
			btrfs_return_cluster_to_free_space(NULL, last_ptr);

			last_ptr_loop = 0;

			/* allocate a cluster in this block group */
			ret = btrfs_find_space_cluster(trans,
					       block_group, last_ptr,
					       offset, num_bytes,
					       empty_cluster + empty_size);
			if (ret == 0) {
				/*
				 * now pull our allocation out of this
				 * cluster
				 */
				offset = btrfs_alloc_from_cluster(block_group,
						  last_ptr, num_bytes,
						  search_start);
				if (offset) {
					/* we found one, proceed */
					spin_unlock(&last_ptr->refill_lock);
					goto checks;
				}
			}
			/*
			 * at this point we either didn't find a cluster
			 * or we weren't able to allocate a block from our
			 * cluster.  Free the cluster we've been trying
			 * to use, and go to the next block group
			 */
			if (loop < 2) {
				btrfs_return_cluster_to_free_space(NULL,
								   last_ptr);
				spin_unlock(&last_ptr->refill_lock);
				goto loop;
			}
			spin_unlock(&last_ptr->refill_lock);
		}

3643 3644 3645
		offset = btrfs_find_space_for_alloc(block_group, search_start,
						    num_bytes, empty_size);
		if (!offset)
J
Josef Bacik 已提交
3646
			goto loop;
3647
checks:
3648
		search_start = stripe_align(root, offset);
3649

J
Josef Bacik 已提交
3650
		/* move on to the next group */
3651 3652
		if (search_start + num_bytes >= search_end) {
			btrfs_add_free_space(block_group, offset, num_bytes);
J
Josef Bacik 已提交
3653
			goto loop;
3654
		}
3655

J
Josef Bacik 已提交
3656 3657
		/* move on to the next group */
		if (search_start + num_bytes >
3658 3659
		    block_group->key.objectid + block_group->key.offset) {
			btrfs_add_free_space(block_group, offset, num_bytes);
J
Josef Bacik 已提交
3660
			goto loop;
3661
		}
3662

J
Josef Bacik 已提交
3663 3664 3665 3666 3667
		if (exclude_nr > 0 &&
		    (search_start + num_bytes > exclude_start &&
		     search_start < exclude_start + exclude_nr)) {
			search_start = exclude_start + exclude_nr;

3668
			btrfs_add_free_space(block_group, offset, num_bytes);
J
Josef Bacik 已提交
3669 3670 3671
			/*
			 * if search_start is still in this block group
			 * then we just re-search this block group
3672
			 */
J
Josef Bacik 已提交
3673 3674
			if (search_start >= block_group->key.objectid &&
			    search_start < (block_group->key.objectid +
3675
					    block_group->key.offset))
J
Josef Bacik 已提交
3676 3677
				goto have_block_group;
			goto loop;
J
Josef Bacik 已提交
3678
		}
3679

J
Josef Bacik 已提交
3680 3681
		ins->objectid = search_start;
		ins->offset = num_bytes;
3682

3683 3684 3685 3686 3687
		if (offset < search_start)
			btrfs_add_free_space(block_group, offset,
					     search_start - offset);
		BUG_ON(offset > search_start);

J
Josef Bacik 已提交
3688 3689 3690
		/* we are all good, lets return */
		break;
loop:
3691
		btrfs_put_block_group(block_group);
J
Josef Bacik 已提交
3692 3693 3694
	}
	up_read(&space_info->groups_sem);

3695 3696 3697 3698 3699 3700 3701 3702 3703 3704
	/* loop == 0, try to find a clustered alloc in every block group
	 * loop == 1, try again after forcing a chunk allocation
	 * loop == 2, set empty_size and empty_cluster to 0 and try again
	 */
	if (!ins->objectid && loop < 3 &&
	    (empty_size || empty_cluster || allowed_chunk_alloc)) {
		if (loop >= 2) {
			empty_size = 0;
			empty_cluster = 0;
		}
J
Josef Bacik 已提交
3705 3706 3707 3708 3709 3710 3711 3712 3713

		if (allowed_chunk_alloc) {
			ret = do_chunk_alloc(trans, root, num_bytes +
					     2 * 1024 * 1024, data, 1);
			allowed_chunk_alloc = 0;
		} else {
			space_info->force_alloc = 1;
		}

3714 3715
		if (loop < 3) {
			loop++;
J
Josef Bacik 已提交
3716
			goto search;
3717
		}
J
Josef Bacik 已提交
3718 3719 3720
		ret = -ENOSPC;
	} else if (!ins->objectid) {
		ret = -ENOSPC;
3721
	}
3722

3723 3724 3725
	/* we found what we needed */
	if (ins->objectid) {
		if (!(data & BTRFS_BLOCK_GROUP_DATA))
3726
			trans->block_group = block_group->key.objectid;
J
Josef Bacik 已提交
3727

3728
		btrfs_put_block_group(block_group);
3729
		ret = 0;
C
Chris Mason 已提交
3730 3731
	}

C
Chris Mason 已提交
3732
	return ret;
3733
}
3734

J
Josef Bacik 已提交
3735 3736 3737 3738
static void dump_space_info(struct btrfs_space_info *info, u64 bytes)
{
	struct btrfs_block_group_cache *cache;

C
Chris Mason 已提交
3739 3740 3741 3742
	printk(KERN_INFO "space_info has %llu free, is %sfull\n",
	       (unsigned long long)(info->total_bytes - info->bytes_used -
				    info->bytes_pinned - info->bytes_reserved),
	       (info->full) ? "" : "not ");
J
Josef Bacik 已提交
3743
	printk(KERN_INFO "space_info total=%llu, pinned=%llu, delalloc=%llu,"
3744 3745 3746 3747 3748 3749
	       " may_use=%llu, used=%llu\n",
	       (unsigned long long)info->total_bytes,
	       (unsigned long long)info->bytes_pinned,
	       (unsigned long long)info->bytes_delalloc,
	       (unsigned long long)info->bytes_may_use,
	       (unsigned long long)info->bytes_used);
J
Josef Bacik 已提交
3750

3751
	down_read(&info->groups_sem);
Q
Qinghuang Feng 已提交
3752
	list_for_each_entry(cache, &info->block_groups, list) {
J
Josef Bacik 已提交
3753
		spin_lock(&cache->lock);
C
Chris Mason 已提交
3754 3755 3756 3757 3758 3759 3760
		printk(KERN_INFO "block group %llu has %llu bytes, %llu used "
		       "%llu pinned %llu reserved\n",
		       (unsigned long long)cache->key.objectid,
		       (unsigned long long)cache->key.offset,
		       (unsigned long long)btrfs_block_group_used(&cache->item),
		       (unsigned long long)cache->pinned,
		       (unsigned long long)cache->reserved);
J
Josef Bacik 已提交
3761 3762 3763
		btrfs_dump_free_space(cache, bytes);
		spin_unlock(&cache->lock);
	}
3764
	up_read(&info->groups_sem);
J
Josef Bacik 已提交
3765
}
3766

3767 3768 3769 3770 3771 3772
static int __btrfs_reserve_extent(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root,
				  u64 num_bytes, u64 min_alloc_size,
				  u64 empty_size, u64 hint_byte,
				  u64 search_end, struct btrfs_key *ins,
				  u64 data)
3773 3774
{
	int ret;
3775
	u64 search_start = 0;
3776
	struct btrfs_fs_info *info = root->fs_info;
3777

J
Josef Bacik 已提交
3778
	data = btrfs_get_alloc_profile(root, data);
3779
again:
C
Chris Mason 已提交
3780 3781 3782 3783 3784
	/*
	 * the only place that sets empty_size is btrfs_realloc_node, which
	 * is not called recursively on allocations
	 */
	if (empty_size || root->ref_cows) {
3785
		if (!(data & BTRFS_BLOCK_GROUP_METADATA)) {
3786
			ret = do_chunk_alloc(trans, root->fs_info->extent_root,
C
Chris Mason 已提交
3787 3788 3789 3790
				     2 * 1024 * 1024,
				     BTRFS_BLOCK_GROUP_METADATA |
				     (info->metadata_alloc_profile &
				      info->avail_metadata_alloc_bits), 0);
3791 3792
		}
		ret = do_chunk_alloc(trans, root->fs_info->extent_root,
C
Chris Mason 已提交
3793
				     num_bytes + 2 * 1024 * 1024, data, 0);
3794
	}
3795

3796 3797 3798
	WARN_ON(num_bytes < root->sectorsize);
	ret = find_free_extent(trans, root, num_bytes, empty_size,
			       search_start, search_end, hint_byte, ins,
3799 3800
			       trans->alloc_exclude_start,
			       trans->alloc_exclude_nr, data);
3801

3802 3803
	if (ret == -ENOSPC && num_bytes > min_alloc_size) {
		num_bytes = num_bytes >> 1;
J
Josef Bacik 已提交
3804
		num_bytes = num_bytes & ~(root->sectorsize - 1);
3805
		num_bytes = max(num_bytes, min_alloc_size);
C
Chris Mason 已提交
3806 3807
		do_chunk_alloc(trans, root->fs_info->extent_root,
			       num_bytes, data, 1);
3808 3809
		goto again;
	}
3810
	if (ret) {
J
Josef Bacik 已提交
3811 3812 3813
		struct btrfs_space_info *sinfo;

		sinfo = __find_space_info(root->fs_info, data);
C
Chris Mason 已提交
3814 3815 3816
		printk(KERN_ERR "btrfs allocation failed flags %llu, "
		       "wanted %llu\n", (unsigned long long)data,
		       (unsigned long long)num_bytes);
J
Josef Bacik 已提交
3817
		dump_space_info(sinfo, num_bytes);
3818 3819
		BUG();
	}
J
Josef Bacik 已提交
3820 3821

	return ret;
3822 3823
}

3824 3825
int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len)
{
J
Josef Bacik 已提交
3826
	struct btrfs_block_group_cache *cache;
3827
	int ret = 0;
J
Josef Bacik 已提交
3828 3829 3830

	cache = btrfs_lookup_block_group(root->fs_info, start);
	if (!cache) {
C
Chris Mason 已提交
3831 3832
		printk(KERN_ERR "Unable to find block group for %llu\n",
		       (unsigned long long)start);
J
Josef Bacik 已提交
3833 3834
		return -ENOSPC;
	}
3835 3836 3837

	ret = btrfs_discard_extent(root, start, len);

J
Josef Bacik 已提交
3838
	btrfs_add_free_space(cache, start, len);
3839
	btrfs_put_block_group(cache);
Z
Zheng Yan 已提交
3840
	update_reserved_extents(root, start, len, 0);
3841 3842

	return ret;
3843 3844
}

3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855
int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root,
				  u64 num_bytes, u64 min_alloc_size,
				  u64 empty_size, u64 hint_byte,
				  u64 search_end, struct btrfs_key *ins,
				  u64 data)
{
	int ret;
	ret = __btrfs_reserve_extent(trans, root, num_bytes, min_alloc_size,
				     empty_size, hint_byte, search_end, ins,
				     data);
3856
	update_reserved_extents(root, ins->objectid, ins->offset, 1);
3857 3858 3859
	return ret;
}

3860 3861 3862 3863 3864
static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      u64 parent, u64 root_objectid,
				      u64 flags, u64 owner, u64 offset,
				      struct btrfs_key *ins, int ref_mod)
3865 3866
{
	int ret;
3867
	struct btrfs_fs_info *fs_info = root->fs_info;
3868
	struct btrfs_extent_item *extent_item;
3869
	struct btrfs_extent_inline_ref *iref;
3870
	struct btrfs_path *path;
3871 3872 3873
	struct extent_buffer *leaf;
	int type;
	u32 size;
3874

3875 3876 3877 3878
	if (parent > 0)
		type = BTRFS_SHARED_DATA_REF_KEY;
	else
		type = BTRFS_EXTENT_DATA_REF_KEY;
3879

3880
	size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
3881 3882 3883

	path = btrfs_alloc_path();
	BUG_ON(!path);
3884

3885
	path->leave_spinning = 1;
3886 3887
	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
				      ins, size);
C
Chris Mason 已提交
3888
	BUG_ON(ret);
J
Josef Bacik 已提交
3889

3890 3891
	leaf = path->nodes[0];
	extent_item = btrfs_item_ptr(leaf, path->slots[0],
3892
				     struct btrfs_extent_item);
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912
	btrfs_set_extent_refs(leaf, extent_item, ref_mod);
	btrfs_set_extent_generation(leaf, extent_item, trans->transid);
	btrfs_set_extent_flags(leaf, extent_item,
			       flags | BTRFS_EXTENT_FLAG_DATA);

	iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
	btrfs_set_extent_inline_ref_type(leaf, iref, type);
	if (parent > 0) {
		struct btrfs_shared_data_ref *ref;
		ref = (struct btrfs_shared_data_ref *)(iref + 1);
		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
		btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
	} else {
		struct btrfs_extent_data_ref *ref;
		ref = (struct btrfs_extent_data_ref *)(&iref->offset);
		btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
		btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
		btrfs_set_extent_data_ref_offset(leaf, ref, offset);
		btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
	}
3913 3914

	btrfs_mark_buffer_dirty(path->nodes[0]);
3915
	btrfs_free_path(path);
3916

3917 3918
	ret = update_block_group(trans, root, ins->objectid, ins->offset,
				 1, 0);
3919
	if (ret) {
C
Chris Mason 已提交
3920 3921 3922
		printk(KERN_ERR "btrfs update block group failed for %llu "
		       "%llu\n", (unsigned long long)ins->objectid,
		       (unsigned long long)ins->offset);
3923 3924
		BUG();
	}
3925 3926 3927
	return ret;
}

3928 3929 3930 3931 3932
static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
				     u64 parent, u64 root_objectid,
				     u64 flags, struct btrfs_disk_key *key,
				     int level, struct btrfs_key *ins)
3933 3934
{
	int ret;
3935 3936 3937 3938 3939 3940 3941
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct btrfs_extent_item *extent_item;
	struct btrfs_tree_block_info *block_info;
	struct btrfs_extent_inline_ref *iref;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	u32 size = sizeof(*extent_item) + sizeof(*block_info) + sizeof(*iref);
3942

3943 3944
	path = btrfs_alloc_path();
	BUG_ON(!path);
3945

3946 3947 3948
	path->leave_spinning = 1;
	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
				      ins, size);
3949
	BUG_ON(ret);
3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000

	leaf = path->nodes[0];
	extent_item = btrfs_item_ptr(leaf, path->slots[0],
				     struct btrfs_extent_item);
	btrfs_set_extent_refs(leaf, extent_item, 1);
	btrfs_set_extent_generation(leaf, extent_item, trans->transid);
	btrfs_set_extent_flags(leaf, extent_item,
			       flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
	block_info = (struct btrfs_tree_block_info *)(extent_item + 1);

	btrfs_set_tree_block_key(leaf, block_info, key);
	btrfs_set_tree_block_level(leaf, block_info, level);

	iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
	if (parent > 0) {
		BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
		btrfs_set_extent_inline_ref_type(leaf, iref,
						 BTRFS_SHARED_BLOCK_REF_KEY);
		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
	} else {
		btrfs_set_extent_inline_ref_type(leaf, iref,
						 BTRFS_TREE_BLOCK_REF_KEY);
		btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
	}

	btrfs_mark_buffer_dirty(leaf);
	btrfs_free_path(path);

	ret = update_block_group(trans, root, ins->objectid, ins->offset,
				 1, 0);
	if (ret) {
		printk(KERN_ERR "btrfs update block group failed for %llu "
		       "%llu\n", (unsigned long long)ins->objectid,
		       (unsigned long long)ins->offset);
		BUG();
	}
	return ret;
}

int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
				     u64 root_objectid, u64 owner,
				     u64 offset, struct btrfs_key *ins)
{
	int ret;

	BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);

	ret = btrfs_add_delayed_data_ref(trans, ins->objectid, ins->offset,
					 0, root_objectid, owner, offset,
					 BTRFS_ADD_DELAYED_EXTENT, NULL);
4001 4002
	return ret;
}
4003 4004 4005 4006 4007 4008

/*
 * this is used by the tree logging recovery code.  It records that
 * an extent has been allocated and makes sure to clear the free
 * space cache bits as well
 */
4009 4010 4011 4012
int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   u64 root_objectid, u64 owner, u64 offset,
				   struct btrfs_key *ins)
4013 4014 4015 4016 4017
{
	int ret;
	struct btrfs_block_group_cache *block_group;

	block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
4018
	mutex_lock(&block_group->cache_mutex);
4019
	cache_block_group(root, block_group);
4020
	mutex_unlock(&block_group->cache_mutex);
4021

4022 4023
	ret = btrfs_remove_free_space(block_group, ins->objectid,
				      ins->offset);
J
Josef Bacik 已提交
4024
	BUG_ON(ret);
4025
	btrfs_put_block_group(block_group);
4026 4027
	ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
					 0, owner, offset, ins, 1);
4028 4029 4030
	return ret;
}

4031 4032 4033 4034 4035 4036 4037
/*
 * finds a free extent and does all the dirty work required for allocation
 * returns the key for the extent through ins, and a tree buffer for
 * the first block of the extent through buf.
 *
 * returns 0 if everything worked, non-zero otherwise.
 */
4038 4039 4040 4041 4042 4043
static int alloc_tree_block(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    u64 num_bytes, u64 parent, u64 root_objectid,
			    struct btrfs_disk_key *key, int level,
			    u64 empty_size, u64 hint_byte, u64 search_end,
			    struct btrfs_key *ins)
4044 4045
{
	int ret;
4046 4047 4048 4049 4050
	u64 flags = 0;

	ret = __btrfs_reserve_extent(trans, root, num_bytes, num_bytes,
				     empty_size, hint_byte, search_end,
				     ins, 0);
4051
	BUG_ON(ret);
4052 4053 4054 4055 4056 4057 4058 4059 4060

	if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
		if (parent == 0)
			parent = ins->objectid;
		flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
	} else
		BUG_ON(parent > 0);

	update_reserved_extents(root, ins->objectid, ins->offset, 1);
4061
	if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
		struct btrfs_delayed_extent_op *extent_op;
		extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
		BUG_ON(!extent_op);
		if (key)
			memcpy(&extent_op->key, key, sizeof(extent_op->key));
		else
			memset(&extent_op->key, 0, sizeof(extent_op->key));
		extent_op->flags_to_set = flags;
		extent_op->update_key = 1;
		extent_op->update_flags = 1;
		extent_op->is_data = 0;

		ret = btrfs_add_delayed_tree_ref(trans, ins->objectid,
					ins->offset, parent, root_objectid,
					level, BTRFS_ADD_DELAYED_EXTENT,
					extent_op);
4078 4079
		BUG_ON(ret);
	}
4080
	return ret;
4081
}
4082 4083 4084

struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
					    struct btrfs_root *root,
4085 4086
					    u64 bytenr, u32 blocksize,
					    int level)
4087 4088 4089 4090 4091 4092 4093
{
	struct extent_buffer *buf;

	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
	if (!buf)
		return ERR_PTR(-ENOMEM);
	btrfs_set_header_generation(buf, trans->transid);
4094
	btrfs_set_buffer_lockdep_class(buf, level);
4095 4096
	btrfs_tree_lock(buf);
	clean_tree_block(trans, root, buf);
4097 4098

	btrfs_set_lock_blocking(buf);
4099
	btrfs_set_buffer_uptodate(buf);
4100

4101 4102 4103 4104 4105
	if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
		set_extent_dirty(&root->dirty_log_pages, buf->start,
			 buf->start + buf->len - 1, GFP_NOFS);
	} else {
		set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
4106
			 buf->start + buf->len - 1, GFP_NOFS);
4107
	}
4108
	trans->blocks_used++;
4109
	/* this returns a buffer locked for blocking */
4110 4111 4112
	return buf;
}

4113 4114 4115 4116
/*
 * helper function to allocate a block for a given tree
 * returns the tree buffer or NULL.
 */
4117
struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
4118 4119 4120 4121
					struct btrfs_root *root, u32 blocksize,
					u64 parent, u64 root_objectid,
					struct btrfs_disk_key *key, int level,
					u64 hint, u64 empty_size)
4122
{
C
Chris Mason 已提交
4123
	struct btrfs_key ins;
4124
	int ret;
4125
	struct extent_buffer *buf;
4126

4127 4128
	ret = alloc_tree_block(trans, root, blocksize, parent, root_objectid,
			       key, level, empty_size, hint, (u64)-1, &ins);
4129
	if (ret) {
4130 4131
		BUG_ON(ret > 0);
		return ERR_PTR(ret);
4132
	}
4133

4134 4135
	buf = btrfs_init_new_buffer(trans, root, ins.objectid,
				    blocksize, level);
4136 4137
	return buf;
}
4138

4139 4140
int btrfs_drop_leaf_ref(struct btrfs_trans_handle *trans,
			struct btrfs_root *root, struct extent_buffer *leaf)
4141
{
4142 4143
	u64 disk_bytenr;
	u64 num_bytes;
4144
	struct btrfs_key key;
4145
	struct btrfs_file_extent_item *fi;
4146
	u32 nritems;
4147 4148 4149
	int i;
	int ret;

4150 4151
	BUG_ON(!btrfs_is_leaf(leaf));
	nritems = btrfs_header_nritems(leaf);
4152

4153
	for (i = 0; i < nritems; i++) {
4154
		cond_resched();
4155
		btrfs_item_key_to_cpu(leaf, &key, i);
4156 4157

		/* only extents have references, skip everything else */
4158
		if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
4159
			continue;
4160

4161
		fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
4162 4163

		/* inline extents live in the btree, they don't have refs */
4164 4165
		if (btrfs_file_extent_type(leaf, fi) ==
		    BTRFS_FILE_EXTENT_INLINE)
4166
			continue;
4167

4168
		disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
4169 4170

		/* holes don't have refs */
4171
		if (disk_bytenr == 0)
C
Chris Mason 已提交
4172
			continue;
C
Chris Mason 已提交
4173

4174 4175 4176
		num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
		ret = btrfs_free_extent(trans, root, disk_bytenr, num_bytes,
					leaf->start, 0, key.objectid, 0);
Z
Zheng Yan 已提交
4177
		BUG_ON(ret);
4178 4179 4180 4181
	}
	return 0;
}

4182 4183
#if 0

C
Chris Mason 已提交
4184
static noinline int cache_drop_leaf_ref(struct btrfs_trans_handle *trans,
4185 4186
					struct btrfs_root *root,
					struct btrfs_leaf_ref *ref)
Y
Yan Zheng 已提交
4187 4188 4189
{
	int i;
	int ret;
4190 4191 4192 4193 4194
	struct btrfs_extent_info *info;
	struct refsort *sorted;

	if (ref->nritems == 0)
		return 0;
Y
Yan Zheng 已提交
4195

4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206
	sorted = kmalloc(sizeof(*sorted) * ref->nritems, GFP_NOFS);
	for (i = 0; i < ref->nritems; i++) {
		sorted[i].bytenr = ref->extents[i].bytenr;
		sorted[i].slot = i;
	}
	sort(sorted, ref->nritems, sizeof(struct refsort), refsort_cmp, NULL);

	/*
	 * the items in the ref were sorted when the ref was inserted
	 * into the ref cache, so this is already in order
	 */
Y
Yan Zheng 已提交
4207
	for (i = 0; i < ref->nritems; i++) {
4208
		info = ref->extents + sorted[i].slot;
4209
		ret = btrfs_free_extent(trans, root, info->bytenr,
Z
Zheng Yan 已提交
4210 4211
					  info->num_bytes, ref->bytenr,
					  ref->owner, ref->generation,
4212
					  info->objectid, 0);
C
Chris Mason 已提交
4213 4214 4215 4216 4217

		atomic_inc(&root->fs_info->throttle_gen);
		wake_up(&root->fs_info->transaction_throttle);
		cond_resched();

Y
Yan Zheng 已提交
4218 4219 4220 4221
		BUG_ON(ret);
		info++;
	}

4222
	kfree(sorted);
Y
Yan Zheng 已提交
4223 4224 4225
	return 0;
}

4226

4227 4228
static int drop_snap_lookup_refcount(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root, u64 start,
C
Chris Mason 已提交
4229
				     u64 len, u32 *refs)
4230
{
C
Chris Mason 已提交
4231
	int ret;
4232

4233
	ret = btrfs_lookup_extent_refs(trans, root, start, len, refs);
4234 4235
	BUG_ON(ret);

C
Chris Mason 已提交
4236
#if 0 /* some debugging code in case we see problems here */
4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256
	/* if the refs count is one, it won't get increased again.  But
	 * if the ref count is > 1, someone may be decreasing it at
	 * the same time we are.
	 */
	if (*refs != 1) {
		struct extent_buffer *eb = NULL;
		eb = btrfs_find_create_tree_block(root, start, len);
		if (eb)
			btrfs_tree_lock(eb);

		mutex_lock(&root->fs_info->alloc_mutex);
		ret = lookup_extent_ref(NULL, root, start, len, refs);
		BUG_ON(ret);
		mutex_unlock(&root->fs_info->alloc_mutex);

		if (eb) {
			btrfs_tree_unlock(eb);
			free_extent_buffer(eb);
		}
		if (*refs == 1) {
C
Chris Mason 已提交
4257 4258
			printk(KERN_ERR "btrfs block %llu went down to one "
			       "during drop_snap\n", (unsigned long long)start);
4259 4260 4261 4262 4263
		}

	}
#endif

4264
	cond_resched();
C
Chris Mason 已提交
4265
	return ret;
4266 4267
}

4268

4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341
/*
 * this is used while deleting old snapshots, and it drops the refs
 * on a whole subtree starting from a level 1 node.
 *
 * The idea is to sort all the leaf pointers, and then drop the
 * ref on all the leaves in order.  Most of the time the leaves
 * will have ref cache entries, so no leaf IOs will be required to
 * find the extents they have references on.
 *
 * For each leaf, any references it has are also dropped in order
 *
 * This ends up dropping the references in something close to optimal
 * order for reading and modifying the extent allocation tree.
 */
static noinline int drop_level_one_refs(struct btrfs_trans_handle *trans,
					struct btrfs_root *root,
					struct btrfs_path *path)
{
	u64 bytenr;
	u64 root_owner;
	u64 root_gen;
	struct extent_buffer *eb = path->nodes[1];
	struct extent_buffer *leaf;
	struct btrfs_leaf_ref *ref;
	struct refsort *sorted = NULL;
	int nritems = btrfs_header_nritems(eb);
	int ret;
	int i;
	int refi = 0;
	int slot = path->slots[1];
	u32 blocksize = btrfs_level_size(root, 0);
	u32 refs;

	if (nritems == 0)
		goto out;

	root_owner = btrfs_header_owner(eb);
	root_gen = btrfs_header_generation(eb);
	sorted = kmalloc(sizeof(*sorted) * nritems, GFP_NOFS);

	/*
	 * step one, sort all the leaf pointers so we don't scribble
	 * randomly into the extent allocation tree
	 */
	for (i = slot; i < nritems; i++) {
		sorted[refi].bytenr = btrfs_node_blockptr(eb, i);
		sorted[refi].slot = i;
		refi++;
	}

	/*
	 * nritems won't be zero, but if we're picking up drop_snapshot
	 * after a crash, slot might be > 0, so double check things
	 * just in case.
	 */
	if (refi == 0)
		goto out;

	sort(sorted, refi, sizeof(struct refsort), refsort_cmp, NULL);

	/*
	 * the first loop frees everything the leaves point to
	 */
	for (i = 0; i < refi; i++) {
		u64 ptr_gen;

		bytenr = sorted[i].bytenr;

		/*
		 * check the reference count on this leaf.  If it is > 1
		 * we just decrement it below and don't update any
		 * of the refs the leaf points to.
		 */
4342 4343
		ret = drop_snap_lookup_refcount(trans, root, bytenr,
						blocksize, &refs);
4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393
		BUG_ON(ret);
		if (refs != 1)
			continue;

		ptr_gen = btrfs_node_ptr_generation(eb, sorted[i].slot);

		/*
		 * the leaf only had one reference, which means the
		 * only thing pointing to this leaf is the snapshot
		 * we're deleting.  It isn't possible for the reference
		 * count to increase again later
		 *
		 * The reference cache is checked for the leaf,
		 * and if found we'll be able to drop any refs held by
		 * the leaf without needing to read it in.
		 */
		ref = btrfs_lookup_leaf_ref(root, bytenr);
		if (ref && ref->generation != ptr_gen) {
			btrfs_free_leaf_ref(root, ref);
			ref = NULL;
		}
		if (ref) {
			ret = cache_drop_leaf_ref(trans, root, ref);
			BUG_ON(ret);
			btrfs_remove_leaf_ref(root, ref);
			btrfs_free_leaf_ref(root, ref);
		} else {
			/*
			 * the leaf wasn't in the reference cache, so
			 * we have to read it.
			 */
			leaf = read_tree_block(root, bytenr, blocksize,
					       ptr_gen);
			ret = btrfs_drop_leaf_ref(trans, root, leaf);
			BUG_ON(ret);
			free_extent_buffer(leaf);
		}
		atomic_inc(&root->fs_info->throttle_gen);
		wake_up(&root->fs_info->transaction_throttle);
		cond_resched();
	}

	/*
	 * run through the loop again to free the refs on the leaves.
	 * This is faster than doing it in the loop above because
	 * the leaves are likely to be clustered together.  We end up
	 * working in nice chunks on the extent allocation tree.
	 */
	for (i = 0; i < refi; i++) {
		bytenr = sorted[i].bytenr;
4394
		ret = btrfs_free_extent(trans, root, bytenr,
4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415
					blocksize, eb->start,
					root_owner, root_gen, 0, 1);
		BUG_ON(ret);

		atomic_inc(&root->fs_info->throttle_gen);
		wake_up(&root->fs_info->transaction_throttle);
		cond_resched();
	}
out:
	kfree(sorted);

	/*
	 * update the path to show we've processed the entire level 1
	 * node.  This will get saved into the root's drop_snapshot_progress
	 * field so these drops are not repeated again if this transaction
	 * commits.
	 */
	path->slots[1] = nritems;
	return 0;
}

C
Chris Mason 已提交
4416 4417 4418 4419
/*
 * helper function for drop_snapshot, this walks down the tree dropping ref
 * counts as it goes.
 */
C
Chris Mason 已提交
4420
static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
4421 4422
				   struct btrfs_root *root,
				   struct btrfs_path *path, int *level)
C
Chris Mason 已提交
4423
{
4424 4425 4426
	u64 root_owner;
	u64 root_gen;
	u64 bytenr;
4427
	u64 ptr_gen;
4428 4429
	struct extent_buffer *next;
	struct extent_buffer *cur;
4430
	struct extent_buffer *parent;
4431
	u32 blocksize;
C
Chris Mason 已提交
4432 4433 4434
	int ret;
	u32 refs;

4435 4436
	WARN_ON(*level < 0);
	WARN_ON(*level >= BTRFS_MAX_LEVEL);
4437
	ret = drop_snap_lookup_refcount(trans, root, path->nodes[*level]->start,
4438
				path->nodes[*level]->len, &refs);
C
Chris Mason 已提交
4439 4440 4441
	BUG_ON(ret);
	if (refs > 1)
		goto out;
4442

C
Chris Mason 已提交
4443 4444 4445
	/*
	 * walk down to the last node level and free all the leaves
	 */
C
Chris Mason 已提交
4446
	while (*level >= 0) {
4447 4448
		WARN_ON(*level < 0);
		WARN_ON(*level >= BTRFS_MAX_LEVEL);
C
Chris Mason 已提交
4449
		cur = path->nodes[*level];
4450

4451
		if (btrfs_header_level(cur) != *level)
C
Chris Mason 已提交
4452
			WARN_ON(1);
4453

4454
		if (path->slots[*level] >=
4455
		    btrfs_header_nritems(cur))
C
Chris Mason 已提交
4456
			break;
4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467

		/* the new code goes down to level 1 and does all the
		 * leaves pointed to that node in bulk.  So, this check
		 * for level 0 will always be false.
		 *
		 * But, the disk format allows the drop_snapshot_progress
		 * field in the root to leave things in a state where
		 * a leaf will need cleaning up here.  If someone crashes
		 * with the old code and then boots with the new code,
		 * we might find a leaf here.
		 */
4468
		if (*level == 0) {
4469
			ret = btrfs_drop_leaf_ref(trans, root, cur);
4470 4471 4472
			BUG_ON(ret);
			break;
		}
4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483

		/*
		 * once we get to level one, process the whole node
		 * at once, including everything below it.
		 */
		if (*level == 1) {
			ret = drop_level_one_refs(trans, root, path);
			BUG_ON(ret);
			break;
		}

4484
		bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
4485
		ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
4486
		blocksize = btrfs_level_size(root, *level - 1);
4487

4488 4489
		ret = drop_snap_lookup_refcount(trans, root, bytenr,
						blocksize, &refs);
4490
		BUG_ON(ret);
4491 4492 4493 4494 4495 4496 4497

		/*
		 * if there is more than one reference, we don't need
		 * to read that node to drop any references it has.  We
		 * just drop the ref we hold on that node and move on to the
		 * next slot in this level.
		 */
4498
		if (refs != 1) {
4499 4500 4501
			parent = path->nodes[*level];
			root_owner = btrfs_header_owner(parent);
			root_gen = btrfs_header_generation(parent);
C
Chris Mason 已提交
4502
			path->slots[*level]++;
4503

4504
			ret = btrfs_free_extent(trans, root, bytenr,
Z
Zheng Yan 已提交
4505
						blocksize, parent->start,
4506 4507
						root_owner, root_gen,
						*level - 1, 1);
C
Chris Mason 已提交
4508
			BUG_ON(ret);
4509 4510 4511

			atomic_inc(&root->fs_info->throttle_gen);
			wake_up(&root->fs_info->transaction_throttle);
C
Chris Mason 已提交
4512
			cond_resched();
4513

C
Chris Mason 已提交
4514 4515
			continue;
		}
4516

4517
		/*
4518 4519
		 * we need to keep freeing things in the next level down.
		 * read the block and loop around to process it
4520
		 */
4521
		next = read_tree_block(root, bytenr, blocksize, ptr_gen);
4522
		WARN_ON(*level <= 0);
C
Chris Mason 已提交
4523
		if (path->nodes[*level-1])
4524
			free_extent_buffer(path->nodes[*level-1]);
C
Chris Mason 已提交
4525
		path->nodes[*level-1] = next;
4526
		*level = btrfs_header_level(next);
C
Chris Mason 已提交
4527
		path->slots[*level] = 0;
C
Chris Mason 已提交
4528
		cond_resched();
C
Chris Mason 已提交
4529 4530
	}
out:
4531 4532
	WARN_ON(*level < 0);
	WARN_ON(*level >= BTRFS_MAX_LEVEL);
4533 4534 4535

	if (path->nodes[*level] == root->node) {
		parent = path->nodes[*level];
Y
Yan Zheng 已提交
4536
		bytenr = path->nodes[*level]->start;
4537 4538
	} else {
		parent = path->nodes[*level + 1];
Y
Yan Zheng 已提交
4539
		bytenr = btrfs_node_blockptr(parent, path->slots[*level + 1]);
4540 4541
	}

Y
Yan Zheng 已提交
4542 4543
	blocksize = btrfs_level_size(root, *level);
	root_owner = btrfs_header_owner(parent);
4544
	root_gen = btrfs_header_generation(parent);
Y
Yan Zheng 已提交
4545

4546 4547 4548 4549
	/*
	 * cleanup and free the reference on the last node
	 * we processed
	 */
4550
	ret = btrfs_free_extent(trans, root, bytenr, blocksize,
Z
Zheng Yan 已提交
4551
				  parent->start, root_owner, root_gen,
4552
				  *level, 1);
4553
	free_extent_buffer(path->nodes[*level]);
C
Chris Mason 已提交
4554
	path->nodes[*level] = NULL;
4555

C
Chris Mason 已提交
4556 4557
	*level += 1;
	BUG_ON(ret);
4558

4559
	cond_resched();
C
Chris Mason 已提交
4560 4561
	return 0;
}
4562
#endif
C
Chris Mason 已提交
4563

Y
Yan Zheng 已提交
4564 4565 4566 4567 4568
/*
 * helper function for drop_subtree, this function is similar to
 * walk_down_tree. The main difference is that it checks reference
 * counts while tree blocks are locked.
 */
4569 4570 4571
static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct btrfs_path *path, int *level)
Y
Yan Zheng 已提交
4572 4573 4574 4575 4576 4577
{
	struct extent_buffer *next;
	struct extent_buffer *cur;
	struct extent_buffer *parent;
	u64 bytenr;
	u64 ptr_gen;
4578 4579
	u64 refs;
	u64 flags;
Y
Yan Zheng 已提交
4580 4581 4582 4583
	u32 blocksize;
	int ret;

	cur = path->nodes[*level];
4584 4585
	ret = btrfs_lookup_extent_info(trans, root, cur->start, cur->len,
				       &refs, &flags);
Y
Yan Zheng 已提交
4586 4587 4588 4589
	BUG_ON(ret);
	if (refs > 1)
		goto out;

4590 4591
	BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));

Y
Yan Zheng 已提交
4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610
	while (*level >= 0) {
		cur = path->nodes[*level];
		if (*level == 0) {
			ret = btrfs_drop_leaf_ref(trans, root, cur);
			BUG_ON(ret);
			clean_tree_block(trans, root, cur);
			break;
		}
		if (path->slots[*level] >= btrfs_header_nritems(cur)) {
			clean_tree_block(trans, root, cur);
			break;
		}

		bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
		blocksize = btrfs_level_size(root, *level - 1);
		ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);

		next = read_tree_block(root, bytenr, blocksize, ptr_gen);
		btrfs_tree_lock(next);
4611
		btrfs_set_lock_blocking(next);
Y
Yan Zheng 已提交
4612

4613 4614
		ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
					       &refs, &flags);
Y
Yan Zheng 已提交
4615 4616 4617 4618
		BUG_ON(ret);
		if (refs > 1) {
			parent = path->nodes[*level];
			ret = btrfs_free_extent(trans, root, bytenr,
4619 4620 4621
						blocksize, parent->start,
						btrfs_header_owner(parent),
						*level - 1, 0);
Y
Yan Zheng 已提交
4622 4623 4624 4625 4626 4627 4628
			BUG_ON(ret);
			path->slots[*level]++;
			btrfs_tree_unlock(next);
			free_extent_buffer(next);
			continue;
		}

4629 4630
		BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));

Y
Yan Zheng 已提交
4631 4632 4633 4634 4635 4636 4637
		*level = btrfs_header_level(next);
		path->nodes[*level] = next;
		path->slots[*level] = 0;
		path->locks[*level] = 1;
		cond_resched();
	}
out:
4638 4639 4640 4641
	if (path->nodes[*level] == root->node)
		parent = path->nodes[*level];
	else
		parent = path->nodes[*level + 1];
Y
Yan Zheng 已提交
4642 4643 4644
	bytenr = path->nodes[*level]->start;
	blocksize = path->nodes[*level]->len;

4645 4646
	ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent->start,
				btrfs_header_owner(parent), *level, 0);
Y
Yan Zheng 已提交
4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659
	BUG_ON(ret);

	if (path->locks[*level]) {
		btrfs_tree_unlock(path->nodes[*level]);
		path->locks[*level] = 0;
	}
	free_extent_buffer(path->nodes[*level]);
	path->nodes[*level] = NULL;
	*level += 1;
	cond_resched();
	return 0;
}

C
Chris Mason 已提交
4660 4661 4662 4663 4664
/*
 * helper for dropping snapshots.  This walks back up the tree in the path
 * to find the first node higher up where we haven't yet gone through
 * all the slots
 */
C
Chris Mason 已提交
4665
static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
4666
				 struct btrfs_root *root,
Y
Yan Zheng 已提交
4667 4668
				 struct btrfs_path *path,
				 int *level, int max_level)
C
Chris Mason 已提交
4669
{
4670
	struct btrfs_root_item *root_item = &root->root_item;
C
Chris Mason 已提交
4671 4672 4673
	int i;
	int slot;
	int ret;
4674

Y
Yan Zheng 已提交
4675
	for (i = *level; i < max_level && path->nodes[i]; i++) {
C
Chris Mason 已提交
4676
		slot = path->slots[i];
4677
		if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
4678 4679 4680 4681 4682 4683
			/*
			 * there is more work to do in this level.
			 * Update the drop_progress marker to reflect
			 * the work we've done so far, and then bump
			 * the slot number
			 */
C
Chris Mason 已提交
4684
			path->slots[i]++;
4685
			WARN_ON(*level == 0);
4686 4687 4688 4689 4690 4691 4692
			if (max_level == BTRFS_MAX_LEVEL) {
				btrfs_node_key(path->nodes[i],
					       &root_item->drop_progress,
					       path->slots[i]);
				root_item->drop_level = i;
			}
			*level = i;
C
Chris Mason 已提交
4693 4694
			return 0;
		} else {
Z
Zheng Yan 已提交
4695
			struct extent_buffer *parent;
4696 4697 4698 4699 4700

			/*
			 * this whole node is done, free our reference
			 * on it and go up one level
			 */
Z
Zheng Yan 已提交
4701 4702 4703 4704 4705
			if (path->nodes[*level] == root->node)
				parent = path->nodes[*level];
			else
				parent = path->nodes[*level + 1];

4706
			clean_tree_block(trans, root, path->nodes[i]);
4707
			ret = btrfs_free_extent(trans, root,
4708 4709 4710 4711 4712
						path->nodes[i]->start,
						path->nodes[i]->len,
						parent->start,
						btrfs_header_owner(parent),
						*level, 0);
4713
			BUG_ON(ret);
Y
Yan Zheng 已提交
4714
			if (path->locks[*level]) {
4715 4716
				btrfs_tree_unlock(path->nodes[i]);
				path->locks[i] = 0;
Y
Yan Zheng 已提交
4717
			}
4718 4719
			free_extent_buffer(path->nodes[i]);
			path->nodes[i] = NULL;
C
Chris Mason 已提交
4720 4721 4722 4723 4724 4725
			*level = i + 1;
		}
	}
	return 1;
}

C
Chris Mason 已提交
4726 4727 4728 4729 4730
/*
 * drop the reference count on the tree rooted at 'snap'.  This traverses
 * the tree freeing any blocks that have a ref count of zero after being
 * decremented.
 */
4731
int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
4732
			*root)
C
Chris Mason 已提交
4733
{
4734
	int ret = 0;
C
Chris Mason 已提交
4735
	int wret;
C
Chris Mason 已提交
4736
	int level;
4737
	struct btrfs_path *path;
4738
	int update_count;
4739
	struct btrfs_root_item *root_item = &root->root_item;
C
Chris Mason 已提交
4740

4741 4742
	path = btrfs_alloc_path();
	BUG_ON(!path);
C
Chris Mason 已提交
4743

4744
	level = btrfs_header_level(root->node);
4745
	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
4746 4747
		path->nodes[level] = btrfs_lock_root_node(root);
		btrfs_set_lock_blocking(path->nodes[level]);
4748
		path->slots[level] = 0;
4749
		path->locks[level] = 1;
4750 4751
	} else {
		struct btrfs_key key;
4752 4753
		struct btrfs_disk_key found_key;
		struct extent_buffer *node;
4754

4755
		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
4756 4757
		level = root_item->drop_level;
		path->lowest_level = level;
4758
		wret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4759
		if (wret < 0) {
4760 4761 4762
			ret = wret;
			goto out;
		}
4763 4764 4765 4766
		node = path->nodes[level];
		btrfs_node_key(node, &found_key, path->slots[level]);
		WARN_ON(memcmp(&found_key, &root_item->drop_progress,
			       sizeof(found_key)));
4767 4768 4769 4770
		/*
		 * unlock our path, this is safe because only this
		 * function is allowed to delete this snapshot
		 */
4771
		btrfs_unlock_up_safe(path, 0);
4772
	}
C
Chris Mason 已提交
4773
	while (1) {
4774
		unsigned long update;
4775
		wret = walk_down_tree(trans, root, path, &level);
C
Chris Mason 已提交
4776
		if (wret > 0)
C
Chris Mason 已提交
4777
			break;
C
Chris Mason 已提交
4778 4779 4780
		if (wret < 0)
			ret = wret;

Y
Yan Zheng 已提交
4781 4782
		wret = walk_up_tree(trans, root, path, &level,
				    BTRFS_MAX_LEVEL);
C
Chris Mason 已提交
4783
		if (wret > 0)
C
Chris Mason 已提交
4784
			break;
C
Chris Mason 已提交
4785 4786
		if (wret < 0)
			ret = wret;
4787 4788
		if (trans->transaction->in_commit ||
		    trans->transaction->delayed_refs.flushing) {
4789 4790 4791
			ret = -EAGAIN;
			break;
		}
4792 4793 4794 4795 4796 4797 4798 4799
		for (update_count = 0; update_count < 16; update_count++) {
			update = trans->delayed_ref_updates;
			trans->delayed_ref_updates = 0;
			if (update)
				btrfs_run_delayed_refs(trans, root, update);
			else
				break;
		}
C
Chris Mason 已提交
4800
	}
4801
out:
4802
	btrfs_free_path(path);
C
Chris Mason 已提交
4803
	return ret;
C
Chris Mason 已提交
4804
}
C
Chris Mason 已提交
4805

Y
Yan Zheng 已提交
4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819
int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
			struct btrfs_root *root,
			struct extent_buffer *node,
			struct extent_buffer *parent)
{
	struct btrfs_path *path;
	int level;
	int parent_level;
	int ret = 0;
	int wret;

	path = btrfs_alloc_path();
	BUG_ON(!path);

4820
	btrfs_assert_tree_locked(parent);
Y
Yan Zheng 已提交
4821 4822 4823 4824 4825
	parent_level = btrfs_header_level(parent);
	extent_buffer_get(parent);
	path->nodes[parent_level] = parent;
	path->slots[parent_level] = btrfs_header_nritems(parent);

4826
	btrfs_assert_tree_locked(node);
Y
Yan Zheng 已提交
4827 4828 4829 4830 4831 4832
	level = btrfs_header_level(node);
	extent_buffer_get(node);
	path->nodes[level] = node;
	path->slots[level] = 0;

	while (1) {
4833
		wret = walk_down_tree(trans, root, path, &level);
Y
Yan Zheng 已提交
4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849
		if (wret < 0)
			ret = wret;
		if (wret != 0)
			break;

		wret = walk_up_tree(trans, root, path, &level, parent_level);
		if (wret < 0)
			ret = wret;
		if (wret != 0)
			break;
	}

	btrfs_free_path(path);
	return ret;
}

4850
#if 0
4851 4852 4853 4854 4855 4856
static unsigned long calc_ra(unsigned long start, unsigned long last,
			     unsigned long nr)
{
	return min(last, start + nr - 1);
}

C
Chris Mason 已提交
4857
static noinline int relocate_inode_pages(struct inode *inode, u64 start,
4858
					 u64 len)
4859 4860 4861
{
	u64 page_start;
	u64 page_end;
Z
Zheng Yan 已提交
4862
	unsigned long first_index;
4863 4864 4865
	unsigned long last_index;
	unsigned long i;
	struct page *page;
4866
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4867
	struct file_ra_state *ra;
4868
	struct btrfs_ordered_extent *ordered;
Z
Zheng Yan 已提交
4869 4870 4871
	unsigned int total_read = 0;
	unsigned int total_dirty = 0;
	int ret = 0;
4872 4873

	ra = kzalloc(sizeof(*ra), GFP_NOFS);
4874 4875

	mutex_lock(&inode->i_mutex);
Z
Zheng Yan 已提交
4876
	first_index = start >> PAGE_CACHE_SHIFT;
4877 4878
	last_index = (start + len - 1) >> PAGE_CACHE_SHIFT;

Z
Zheng Yan 已提交
4879 4880 4881 4882 4883
	/* make sure the dirty trick played by the caller work */
	ret = invalidate_inode_pages2_range(inode->i_mapping,
					    first_index, last_index);
	if (ret)
		goto out_unlock;
4884

4885
	file_ra_state_init(ra, inode->i_mapping);
4886

Z
Zheng Yan 已提交
4887 4888
	for (i = first_index ; i <= last_index; i++) {
		if (total_read % ra->ra_pages == 0) {
4889
			btrfs_force_ra(inode->i_mapping, ra, NULL, i,
Z
Zheng Yan 已提交
4890
				       calc_ra(i, last_index, ra->ra_pages));
4891 4892
		}
		total_read++;
4893 4894
again:
		if (((u64)i << PAGE_CACHE_SHIFT) > i_size_read(inode))
Z
Zheng Yan 已提交
4895
			BUG_ON(1);
4896
		page = grab_cache_page(inode->i_mapping, i);
4897
		if (!page) {
Z
Zheng Yan 已提交
4898
			ret = -ENOMEM;
4899
			goto out_unlock;
4900
		}
4901 4902 4903 4904 4905 4906
		if (!PageUptodate(page)) {
			btrfs_readpage(NULL, page);
			lock_page(page);
			if (!PageUptodate(page)) {
				unlock_page(page);
				page_cache_release(page);
Z
Zheng Yan 已提交
4907
				ret = -EIO;
4908 4909 4910
				goto out_unlock;
			}
		}
4911
		wait_on_page_writeback(page);
4912

4913 4914
		page_start = (u64)page->index << PAGE_CACHE_SHIFT;
		page_end = page_start + PAGE_CACHE_SIZE - 1;
4915
		lock_extent(io_tree, page_start, page_end, GFP_NOFS);
4916

4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927
		ordered = btrfs_lookup_ordered_extent(inode, page_start);
		if (ordered) {
			unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
			unlock_page(page);
			page_cache_release(page);
			btrfs_start_ordered_extent(inode, ordered, 1);
			btrfs_put_ordered_extent(ordered);
			goto again;
		}
		set_page_extent_mapped(page);

Z
Zheng Yan 已提交
4928 4929 4930
		if (i == first_index)
			set_extent_bits(io_tree, page_start, page_end,
					EXTENT_BOUNDARY, GFP_NOFS);
4931
		btrfs_set_extent_delalloc(inode, page_start, page_end);
Z
Zheng Yan 已提交
4932

4933
		set_page_dirty(page);
Z
Zheng Yan 已提交
4934
		total_dirty++;
4935

4936
		unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
4937 4938 4939 4940 4941
		unlock_page(page);
		page_cache_release(page);
	}

out_unlock:
4942
	kfree(ra);
4943
	mutex_unlock(&inode->i_mutex);
Z
Zheng Yan 已提交
4944 4945
	balance_dirty_pages_ratelimited_nr(inode->i_mapping, total_dirty);
	return ret;
4946 4947
}

C
Chris Mason 已提交
4948
static noinline int relocate_data_extent(struct inode *reloc_inode,
Z
Zheng Yan 已提交
4949 4950 4951 4952 4953 4954
					 struct btrfs_key *extent_key,
					 u64 offset)
{
	struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
	struct extent_map_tree *em_tree = &BTRFS_I(reloc_inode)->extent_tree;
	struct extent_map *em;
Y
Yan Zheng 已提交
4955 4956
	u64 start = extent_key->objectid - offset;
	u64 end = start + extent_key->offset - 1;
4957

Z
Zheng Yan 已提交
4958 4959
	em = alloc_extent_map(GFP_NOFS);
	BUG_ON(!em || IS_ERR(em));
4960

Y
Yan Zheng 已提交
4961
	em->start = start;
Z
Zheng Yan 已提交
4962
	em->len = extent_key->offset;
C
Chris Mason 已提交
4963
	em->block_len = extent_key->offset;
Z
Zheng Yan 已提交
4964 4965 4966 4967 4968
	em->block_start = extent_key->objectid;
	em->bdev = root->fs_info->fs_devices->latest_bdev;
	set_bit(EXTENT_FLAG_PINNED, &em->flags);

	/* setup extent map to cheat btrfs_readpage */
Y
Yan Zheng 已提交
4969
	lock_extent(&BTRFS_I(reloc_inode)->io_tree, start, end, GFP_NOFS);
Z
Zheng Yan 已提交
4970 4971 4972 4973 4974 4975 4976
	while (1) {
		int ret;
		spin_lock(&em_tree->lock);
		ret = add_extent_mapping(em_tree, em);
		spin_unlock(&em_tree->lock);
		if (ret != -EEXIST) {
			free_extent_map(em);
4977 4978
			break;
		}
Y
Yan Zheng 已提交
4979
		btrfs_drop_extent_cache(reloc_inode, start, end, 0);
4980
	}
Y
Yan Zheng 已提交
4981
	unlock_extent(&BTRFS_I(reloc_inode)->io_tree, start, end, GFP_NOFS);
4982

Y
Yan Zheng 已提交
4983
	return relocate_inode_pages(reloc_inode, start, extent_key->offset);
Z
Zheng Yan 已提交
4984
}
4985

Z
Zheng Yan 已提交
4986 4987 4988 4989 4990 4991 4992 4993 4994
struct btrfs_ref_path {
	u64 extent_start;
	u64 nodes[BTRFS_MAX_LEVEL];
	u64 root_objectid;
	u64 root_generation;
	u64 owner_objectid;
	u32 num_refs;
	int lowest_level;
	int current_level;
Y
Yan Zheng 已提交
4995 4996 4997 4998
	int shared_level;

	struct btrfs_key node_keys[BTRFS_MAX_LEVEL];
	u64 new_nodes[BTRFS_MAX_LEVEL];
Z
Zheng Yan 已提交
4999
};
5000

Z
Zheng Yan 已提交
5001
struct disk_extent {
C
Chris Mason 已提交
5002
	u64 ram_bytes;
Z
Zheng Yan 已提交
5003 5004 5005 5006
	u64 disk_bytenr;
	u64 disk_num_bytes;
	u64 offset;
	u64 num_bytes;
C
Chris Mason 已提交
5007 5008 5009
	u8 compression;
	u8 encryption;
	u16 other_encoding;
Z
Zheng Yan 已提交
5010
};
5011

Z
Zheng Yan 已提交
5012 5013 5014 5015 5016 5017
static int is_cowonly_root(u64 root_objectid)
{
	if (root_objectid == BTRFS_ROOT_TREE_OBJECTID ||
	    root_objectid == BTRFS_EXTENT_TREE_OBJECTID ||
	    root_objectid == BTRFS_CHUNK_TREE_OBJECTID ||
	    root_objectid == BTRFS_DEV_TREE_OBJECTID ||
5018 5019
	    root_objectid == BTRFS_TREE_LOG_OBJECTID ||
	    root_objectid == BTRFS_CSUM_TREE_OBJECTID)
Z
Zheng Yan 已提交
5020 5021 5022
		return 1;
	return 0;
}
5023

C
Chris Mason 已提交
5024
static noinline int __next_ref_path(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037
				    struct btrfs_root *extent_root,
				    struct btrfs_ref_path *ref_path,
				    int first_time)
{
	struct extent_buffer *leaf;
	struct btrfs_path *path;
	struct btrfs_extent_ref *ref;
	struct btrfs_key key;
	struct btrfs_key found_key;
	u64 bytenr;
	u32 nritems;
	int level;
	int ret = 1;
5038

Z
Zheng Yan 已提交
5039 5040 5041
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
5042

Z
Zheng Yan 已提交
5043 5044 5045
	if (first_time) {
		ref_path->lowest_level = -1;
		ref_path->current_level = -1;
Y
Yan Zheng 已提交
5046
		ref_path->shared_level = -1;
Z
Zheng Yan 已提交
5047 5048 5049 5050 5051 5052 5053 5054
		goto walk_up;
	}
walk_down:
	level = ref_path->current_level - 1;
	while (level >= -1) {
		u64 parent;
		if (level < ref_path->lowest_level)
			break;
5055

C
Chris Mason 已提交
5056
		if (level >= 0)
Z
Zheng Yan 已提交
5057
			bytenr = ref_path->nodes[level];
C
Chris Mason 已提交
5058
		else
Z
Zheng Yan 已提交
5059 5060
			bytenr = ref_path->extent_start;
		BUG_ON(bytenr == 0);
5061

Z
Zheng Yan 已提交
5062 5063 5064 5065
		parent = ref_path->nodes[level + 1];
		ref_path->nodes[level + 1] = 0;
		ref_path->current_level = level;
		BUG_ON(parent == 0);
C
Chris Mason 已提交
5066

Z
Zheng Yan 已提交
5067 5068 5069
		key.objectid = bytenr;
		key.offset = parent + 1;
		key.type = BTRFS_EXTENT_REF_KEY;
5070

Z
Zheng Yan 已提交
5071 5072
		ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 0);
		if (ret < 0)
5073
			goto out;
Z
Zheng Yan 已提交
5074
		BUG_ON(ret == 0);
5075

Z
Zheng Yan 已提交
5076 5077 5078 5079 5080 5081 5082 5083 5084 5085
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(extent_root, path);
			if (ret < 0)
				goto out;
			if (ret > 0)
				goto next;
			leaf = path->nodes[0];
		}
C
Chris Mason 已提交
5086

Z
Zheng Yan 已提交
5087 5088
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		if (found_key.objectid == bytenr &&
Y
Yan Zheng 已提交
5089 5090 5091
		    found_key.type == BTRFS_EXTENT_REF_KEY) {
			if (level < ref_path->shared_level)
				ref_path->shared_level = level;
Z
Zheng Yan 已提交
5092
			goto found;
Y
Yan Zheng 已提交
5093
		}
Z
Zheng Yan 已提交
5094 5095 5096
next:
		level--;
		btrfs_release_path(extent_root, path);
Y
Yan Zheng 已提交
5097
		cond_resched();
Z
Zheng Yan 已提交
5098 5099 5100 5101 5102 5103 5104 5105
	}
	/* reached lowest level */
	ret = 1;
	goto out;
walk_up:
	level = ref_path->current_level;
	while (level < BTRFS_MAX_LEVEL - 1) {
		u64 ref_objectid;
C
Chris Mason 已提交
5106 5107

		if (level >= 0)
Z
Zheng Yan 已提交
5108
			bytenr = ref_path->nodes[level];
C
Chris Mason 已提交
5109
		else
Z
Zheng Yan 已提交
5110
			bytenr = ref_path->extent_start;
C
Chris Mason 已提交
5111

Z
Zheng Yan 已提交
5112
		BUG_ON(bytenr == 0);
5113

Z
Zheng Yan 已提交
5114 5115 5116
		key.objectid = bytenr;
		key.offset = 0;
		key.type = BTRFS_EXTENT_REF_KEY;
5117

Z
Zheng Yan 已提交
5118 5119 5120
		ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 0);
		if (ret < 0)
			goto out;
5121

Z
Zheng Yan 已提交
5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(extent_root, path);
			if (ret < 0)
				goto out;
			if (ret > 0) {
				/* the extent was freed by someone */
				if (ref_path->lowest_level == level)
					goto out;
				btrfs_release_path(extent_root, path);
				goto walk_down;
			}
			leaf = path->nodes[0];
		}
5137

Z
Zheng Yan 已提交
5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		if (found_key.objectid != bytenr ||
				found_key.type != BTRFS_EXTENT_REF_KEY) {
			/* the extent was freed by someone */
			if (ref_path->lowest_level == level) {
				ret = 1;
				goto out;
			}
			btrfs_release_path(extent_root, path);
			goto walk_down;
		}
found:
		ref = btrfs_item_ptr(leaf, path->slots[0],
				struct btrfs_extent_ref);
		ref_objectid = btrfs_ref_objectid(leaf, ref);
		if (ref_objectid < BTRFS_FIRST_FREE_OBJECTID) {
			if (first_time) {
				level = (int)ref_objectid;
				BUG_ON(level >= BTRFS_MAX_LEVEL);
				ref_path->lowest_level = level;
				ref_path->current_level = level;
				ref_path->nodes[level] = bytenr;
			} else {
				WARN_ON(ref_objectid != level);
			}
		} else {
			WARN_ON(level != -1);
		}
		first_time = 0;
5167

Z
Zheng Yan 已提交
5168 5169 5170 5171
		if (ref_path->lowest_level == level) {
			ref_path->owner_objectid = ref_objectid;
			ref_path->num_refs = btrfs_ref_num_refs(leaf, ref);
		}
5172

5173
		/*
Z
Zheng Yan 已提交
5174 5175
		 * the block is tree root or the block isn't in reference
		 * counted tree.
5176
		 */
Z
Zheng Yan 已提交
5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189
		if (found_key.objectid == found_key.offset ||
		    is_cowonly_root(btrfs_ref_root(leaf, ref))) {
			ref_path->root_objectid = btrfs_ref_root(leaf, ref);
			ref_path->root_generation =
				btrfs_ref_generation(leaf, ref);
			if (level < 0) {
				/* special reference from the tree log */
				ref_path->nodes[0] = found_key.offset;
				ref_path->current_level = 0;
			}
			ret = 0;
			goto out;
		}
5190

Z
Zheng Yan 已提交
5191 5192 5193 5194
		level++;
		BUG_ON(ref_path->nodes[level] != 0);
		ref_path->nodes[level] = found_key.offset;
		ref_path->current_level = level;
5195

Z
Zheng Yan 已提交
5196 5197 5198 5199 5200 5201 5202 5203 5204 5205
		/*
		 * the reference was created in the running transaction,
		 * no need to continue walking up.
		 */
		if (btrfs_ref_generation(leaf, ref) == trans->transid) {
			ref_path->root_objectid = btrfs_ref_root(leaf, ref);
			ref_path->root_generation =
				btrfs_ref_generation(leaf, ref);
			ret = 0;
			goto out;
5206 5207
		}

Z
Zheng Yan 已提交
5208
		btrfs_release_path(extent_root, path);
Y
Yan Zheng 已提交
5209
		cond_resched();
5210
	}
Z
Zheng Yan 已提交
5211 5212
	/* reached max tree level, but no tree root found. */
	BUG();
5213
out:
Z
Zheng Yan 已提交
5214 5215
	btrfs_free_path(path);
	return ret;
5216 5217
}

Z
Zheng Yan 已提交
5218 5219 5220 5221
static int btrfs_first_ref_path(struct btrfs_trans_handle *trans,
				struct btrfs_root *extent_root,
				struct btrfs_ref_path *ref_path,
				u64 extent_start)
5222
{
Z
Zheng Yan 已提交
5223 5224
	memset(ref_path, 0, sizeof(*ref_path));
	ref_path->extent_start = extent_start;
5225

Z
Zheng Yan 已提交
5226
	return __next_ref_path(trans, extent_root, ref_path, 1);
5227 5228
}

Z
Zheng Yan 已提交
5229 5230 5231
static int btrfs_next_ref_path(struct btrfs_trans_handle *trans,
			       struct btrfs_root *extent_root,
			       struct btrfs_ref_path *ref_path)
5232
{
Z
Zheng Yan 已提交
5233 5234 5235
	return __next_ref_path(trans, extent_root, ref_path, 0);
}

C
Chris Mason 已提交
5236
static noinline int get_new_locations(struct inode *reloc_inode,
Z
Zheng Yan 已提交
5237 5238 5239 5240 5241 5242 5243 5244
				      struct btrfs_key *extent_key,
				      u64 offset, int no_fragment,
				      struct disk_extent **extents,
				      int *nr_extents)
{
	struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
	struct btrfs_path *path;
	struct btrfs_file_extent_item *fi;
5245
	struct extent_buffer *leaf;
Z
Zheng Yan 已提交
5246 5247 5248 5249
	struct disk_extent *exts = *extents;
	struct btrfs_key found_key;
	u64 cur_pos;
	u64 last_byte;
5250
	u32 nritems;
Z
Zheng Yan 已提交
5251 5252 5253
	int nr = 0;
	int max = *nr_extents;
	int ret;
5254

Z
Zheng Yan 已提交
5255 5256 5257 5258 5259 5260
	WARN_ON(!no_fragment && *extents);
	if (!exts) {
		max = 1;
		exts = kmalloc(sizeof(*exts) * max, GFP_NOFS);
		if (!exts)
			return -ENOMEM;
5261
	}
5262

Z
Zheng Yan 已提交
5263 5264
	path = btrfs_alloc_path();
	BUG_ON(!path);
5265

Z
Zheng Yan 已提交
5266 5267 5268 5269 5270 5271 5272 5273 5274 5275
	cur_pos = extent_key->objectid - offset;
	last_byte = extent_key->objectid + extent_key->offset;
	ret = btrfs_lookup_file_extent(NULL, root, path, reloc_inode->i_ino,
				       cur_pos, 0);
	if (ret < 0)
		goto out;
	if (ret > 0) {
		ret = -ENOENT;
		goto out;
	}
5276

Z
Zheng Yan 已提交
5277
	while (1) {
5278 5279
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
Z
Zheng Yan 已提交
5280 5281
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(root, path);
5282 5283
			if (ret < 0)
				goto out;
Z
Zheng Yan 已提交
5284 5285
			if (ret > 0)
				break;
5286
			leaf = path->nodes[0];
5287
		}
5288 5289

		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
Z
Zheng Yan 已提交
5290 5291 5292
		if (found_key.offset != cur_pos ||
		    found_key.type != BTRFS_EXTENT_DATA_KEY ||
		    found_key.objectid != reloc_inode->i_ino)
5293 5294
			break;

Z
Zheng Yan 已提交
5295 5296 5297 5298 5299
		fi = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_file_extent_item);
		if (btrfs_file_extent_type(leaf, fi) !=
		    BTRFS_FILE_EXTENT_REG ||
		    btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
5300
			break;
Z
Zheng Yan 已提交
5301 5302 5303 5304 5305 5306 5307 5308

		if (nr == max) {
			struct disk_extent *old = exts;
			max *= 2;
			exts = kzalloc(sizeof(*exts) * max, GFP_NOFS);
			memcpy(exts, old, sizeof(*exts) * nr);
			if (old != *extents)
				kfree(old);
5309
		}
5310

Z
Zheng Yan 已提交
5311 5312 5313 5314 5315 5316
		exts[nr].disk_bytenr =
			btrfs_file_extent_disk_bytenr(leaf, fi);
		exts[nr].disk_num_bytes =
			btrfs_file_extent_disk_num_bytes(leaf, fi);
		exts[nr].offset = btrfs_file_extent_offset(leaf, fi);
		exts[nr].num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
5317 5318 5319 5320 5321
		exts[nr].ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
		exts[nr].compression = btrfs_file_extent_compression(leaf, fi);
		exts[nr].encryption = btrfs_file_extent_encryption(leaf, fi);
		exts[nr].other_encoding = btrfs_file_extent_other_encoding(leaf,
									   fi);
Y
Yan Zheng 已提交
5322 5323 5324
		BUG_ON(exts[nr].offset > 0);
		BUG_ON(exts[nr].compression || exts[nr].encryption);
		BUG_ON(exts[nr].num_bytes != exts[nr].disk_num_bytes);
5325

Z
Zheng Yan 已提交
5326 5327 5328 5329 5330 5331 5332 5333
		cur_pos += exts[nr].num_bytes;
		nr++;

		if (cur_pos + offset >= last_byte)
			break;

		if (no_fragment) {
			ret = 1;
5334
			goto out;
Z
Zheng Yan 已提交
5335 5336 5337 5338
		}
		path->slots[0]++;
	}

5339
	BUG_ON(cur_pos + offset > last_byte);
Z
Zheng Yan 已提交
5340 5341 5342
	if (cur_pos + offset < last_byte) {
		ret = -ENOENT;
		goto out;
5343 5344 5345
	}
	ret = 0;
out:
Z
Zheng Yan 已提交
5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356
	btrfs_free_path(path);
	if (ret) {
		if (exts != *extents)
			kfree(exts);
	} else {
		*extents = exts;
		*nr_extents = nr;
	}
	return ret;
}

C
Chris Mason 已提交
5357
static noinline int replace_one_extent(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373
					struct btrfs_root *root,
					struct btrfs_path *path,
					struct btrfs_key *extent_key,
					struct btrfs_key *leaf_key,
					struct btrfs_ref_path *ref_path,
					struct disk_extent *new_extents,
					int nr_extents)
{
	struct extent_buffer *leaf;
	struct btrfs_file_extent_item *fi;
	struct inode *inode = NULL;
	struct btrfs_key key;
	u64 lock_start = 0;
	u64 lock_end = 0;
	u64 num_bytes;
	u64 ext_offset;
5374
	u64 search_end = (u64)-1;
Z
Zheng Yan 已提交
5375
	u32 nritems;
5376
	int nr_scaned = 0;
Z
Zheng Yan 已提交
5377
	int extent_locked = 0;
Y
Yan Zheng 已提交
5378
	int extent_type;
Z
Zheng Yan 已提交
5379 5380
	int ret;

5381
	memcpy(&key, leaf_key, sizeof(key));
Z
Zheng Yan 已提交
5382
	if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS) {
5383 5384 5385 5386 5387 5388 5389
		if (key.objectid < ref_path->owner_objectid ||
		    (key.objectid == ref_path->owner_objectid &&
		     key.type < BTRFS_EXTENT_DATA_KEY)) {
			key.objectid = ref_path->owner_objectid;
			key.type = BTRFS_EXTENT_DATA_KEY;
			key.offset = 0;
		}
Z
Zheng Yan 已提交
5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410
	}

	while (1) {
		ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
		if (ret < 0)
			goto out;

		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
next:
		if (extent_locked && ret > 0) {
			/*
			 * the file extent item was modified by someone
			 * before the extent got locked.
			 */
			unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
				      lock_end, GFP_NOFS);
			extent_locked = 0;
		}

		if (path->slots[0] >= nritems) {
5411
			if (++nr_scaned > 2)
Z
Zheng Yan 已提交
5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429
				break;

			BUG_ON(extent_locked);
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				goto out;
			if (ret > 0)
				break;
			leaf = path->nodes[0];
			nritems = btrfs_header_nritems(leaf);
		}

		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

		if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS) {
			if ((key.objectid > ref_path->owner_objectid) ||
			    (key.objectid == ref_path->owner_objectid &&
			     key.type > BTRFS_EXTENT_DATA_KEY) ||
5430
			    key.offset >= search_end)
Z
Zheng Yan 已提交
5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449
				break;
		}

		if (inode && key.objectid != inode->i_ino) {
			BUG_ON(extent_locked);
			btrfs_release_path(root, path);
			mutex_unlock(&inode->i_mutex);
			iput(inode);
			inode = NULL;
			continue;
		}

		if (key.type != BTRFS_EXTENT_DATA_KEY) {
			path->slots[0]++;
			ret = 1;
			goto next;
		}
		fi = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_file_extent_item);
Y
Yan Zheng 已提交
5450 5451 5452
		extent_type = btrfs_file_extent_type(leaf, fi);
		if ((extent_type != BTRFS_FILE_EXTENT_REG &&
		     extent_type != BTRFS_FILE_EXTENT_PREALLOC) ||
Z
Zheng Yan 已提交
5453 5454 5455 5456 5457 5458 5459 5460 5461 5462
		    (btrfs_file_extent_disk_bytenr(leaf, fi) !=
		     extent_key->objectid)) {
			path->slots[0]++;
			ret = 1;
			goto next;
		}

		num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
		ext_offset = btrfs_file_extent_offset(leaf, fi);

5463 5464 5465 5466
		if (search_end == (u64)-1) {
			search_end = key.offset - ext_offset +
				btrfs_file_extent_ram_bytes(leaf, fi);
		}
Z
Zheng Yan 已提交
5467 5468 5469 5470 5471

		if (!extent_locked) {
			lock_start = key.offset;
			lock_end = lock_start + num_bytes - 1;
		} else {
Y
Yan Zheng 已提交
5472 5473 5474 5475 5476 5477
			if (lock_start > key.offset ||
			    lock_end + 1 < key.offset + num_bytes) {
				unlock_extent(&BTRFS_I(inode)->io_tree,
					      lock_start, lock_end, GFP_NOFS);
				extent_locked = 0;
			}
Z
Zheng Yan 已提交
5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551
		}

		if (!inode) {
			btrfs_release_path(root, path);

			inode = btrfs_iget_locked(root->fs_info->sb,
						  key.objectid, root);
			if (inode->i_state & I_NEW) {
				BTRFS_I(inode)->root = root;
				BTRFS_I(inode)->location.objectid =
					key.objectid;
				BTRFS_I(inode)->location.type =
					BTRFS_INODE_ITEM_KEY;
				BTRFS_I(inode)->location.offset = 0;
				btrfs_read_locked_inode(inode);
				unlock_new_inode(inode);
			}
			/*
			 * some code call btrfs_commit_transaction while
			 * holding the i_mutex, so we can't use mutex_lock
			 * here.
			 */
			if (is_bad_inode(inode) ||
			    !mutex_trylock(&inode->i_mutex)) {
				iput(inode);
				inode = NULL;
				key.offset = (u64)-1;
				goto skip;
			}
		}

		if (!extent_locked) {
			struct btrfs_ordered_extent *ordered;

			btrfs_release_path(root, path);

			lock_extent(&BTRFS_I(inode)->io_tree, lock_start,
				    lock_end, GFP_NOFS);
			ordered = btrfs_lookup_first_ordered_extent(inode,
								    lock_end);
			if (ordered &&
			    ordered->file_offset <= lock_end &&
			    ordered->file_offset + ordered->len > lock_start) {
				unlock_extent(&BTRFS_I(inode)->io_tree,
					      lock_start, lock_end, GFP_NOFS);
				btrfs_start_ordered_extent(inode, ordered, 1);
				btrfs_put_ordered_extent(ordered);
				key.offset += num_bytes;
				goto skip;
			}
			if (ordered)
				btrfs_put_ordered_extent(ordered);

			extent_locked = 1;
			continue;
		}

		if (nr_extents == 1) {
			/* update extent pointer in place */
			btrfs_set_file_extent_disk_bytenr(leaf, fi,
						new_extents[0].disk_bytenr);
			btrfs_set_file_extent_disk_num_bytes(leaf, fi,
						new_extents[0].disk_num_bytes);
			btrfs_mark_buffer_dirty(leaf);

			btrfs_drop_extent_cache(inode, key.offset,
						key.offset + num_bytes - 1, 0);

			ret = btrfs_inc_extent_ref(trans, root,
						new_extents[0].disk_bytenr,
						new_extents[0].disk_num_bytes,
						leaf->start,
						root->root_key.objectid,
						trans->transid,
5552
						key.objectid);
Z
Zheng Yan 已提交
5553 5554 5555 5556 5557 5558 5559 5560
			BUG_ON(ret);

			ret = btrfs_free_extent(trans, root,
						extent_key->objectid,
						extent_key->offset,
						leaf->start,
						btrfs_header_owner(leaf),
						btrfs_header_generation(leaf),
5561
						key.objectid, 0);
Z
Zheng Yan 已提交
5562 5563 5564 5565 5566
			BUG_ON(ret);

			btrfs_release_path(root, path);
			key.offset += num_bytes;
		} else {
Y
Yan Zheng 已提交
5567 5568
			BUG_ON(1);
#if 0
Z
Zheng Yan 已提交
5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605
			u64 alloc_hint;
			u64 extent_len;
			int i;
			/*
			 * drop old extent pointer at first, then insert the
			 * new pointers one bye one
			 */
			btrfs_release_path(root, path);
			ret = btrfs_drop_extents(trans, root, inode, key.offset,
						 key.offset + num_bytes,
						 key.offset, &alloc_hint);
			BUG_ON(ret);

			for (i = 0; i < nr_extents; i++) {
				if (ext_offset >= new_extents[i].num_bytes) {
					ext_offset -= new_extents[i].num_bytes;
					continue;
				}
				extent_len = min(new_extents[i].num_bytes -
						 ext_offset, num_bytes);

				ret = btrfs_insert_empty_item(trans, root,
							      path, &key,
							      sizeof(*fi));
				BUG_ON(ret);

				leaf = path->nodes[0];
				fi = btrfs_item_ptr(leaf, path->slots[0],
						struct btrfs_file_extent_item);
				btrfs_set_file_extent_generation(leaf, fi,
							trans->transid);
				btrfs_set_file_extent_type(leaf, fi,
							BTRFS_FILE_EXTENT_REG);
				btrfs_set_file_extent_disk_bytenr(leaf, fi,
						new_extents[i].disk_bytenr);
				btrfs_set_file_extent_disk_num_bytes(leaf, fi,
						new_extents[i].disk_num_bytes);
C
Chris Mason 已提交
5606 5607 5608 5609 5610 5611 5612 5613 5614 5615
				btrfs_set_file_extent_ram_bytes(leaf, fi,
						new_extents[i].ram_bytes);

				btrfs_set_file_extent_compression(leaf, fi,
						new_extents[i].compression);
				btrfs_set_file_extent_encryption(leaf, fi,
						new_extents[i].encryption);
				btrfs_set_file_extent_other_encoding(leaf, fi,
						new_extents[i].other_encoding);

Z
Zheng Yan 已提交
5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630
				btrfs_set_file_extent_num_bytes(leaf, fi,
							extent_len);
				ext_offset += new_extents[i].offset;
				btrfs_set_file_extent_offset(leaf, fi,
							ext_offset);
				btrfs_mark_buffer_dirty(leaf);

				btrfs_drop_extent_cache(inode, key.offset,
						key.offset + extent_len - 1, 0);

				ret = btrfs_inc_extent_ref(trans, root,
						new_extents[i].disk_bytenr,
						new_extents[i].disk_num_bytes,
						leaf->start,
						root->root_key.objectid,
5631
						trans->transid, key.objectid);
Z
Zheng Yan 已提交
5632 5633 5634
				BUG_ON(ret);
				btrfs_release_path(root, path);

5635
				inode_add_bytes(inode, extent_len);
Z
Zheng Yan 已提交
5636 5637 5638 5639 5640 5641 5642 5643 5644

				ext_offset = 0;
				num_bytes -= extent_len;
				key.offset += extent_len;

				if (num_bytes == 0)
					break;
			}
			BUG_ON(i >= nr_extents);
Y
Yan Zheng 已提交
5645
#endif
Z
Zheng Yan 已提交
5646 5647 5648 5649 5650 5651 5652 5653 5654
		}

		if (extent_locked) {
			unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
				      lock_end, GFP_NOFS);
			extent_locked = 0;
		}
skip:
		if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS &&
5655
		    key.offset >= search_end)
Z
Zheng Yan 已提交
5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708
			break;

		cond_resched();
	}
	ret = 0;
out:
	btrfs_release_path(root, path);
	if (inode) {
		mutex_unlock(&inode->i_mutex);
		if (extent_locked) {
			unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
				      lock_end, GFP_NOFS);
		}
		iput(inode);
	}
	return ret;
}

int btrfs_reloc_tree_cache_ref(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root,
			       struct extent_buffer *buf, u64 orig_start)
{
	int level;
	int ret;

	BUG_ON(btrfs_header_generation(buf) != trans->transid);
	BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);

	level = btrfs_header_level(buf);
	if (level == 0) {
		struct btrfs_leaf_ref *ref;
		struct btrfs_leaf_ref *orig_ref;

		orig_ref = btrfs_lookup_leaf_ref(root, orig_start);
		if (!orig_ref)
			return -ENOENT;

		ref = btrfs_alloc_leaf_ref(root, orig_ref->nritems);
		if (!ref) {
			btrfs_free_leaf_ref(root, orig_ref);
			return -ENOMEM;
		}

		ref->nritems = orig_ref->nritems;
		memcpy(ref->extents, orig_ref->extents,
			sizeof(ref->extents[0]) * ref->nritems);

		btrfs_free_leaf_ref(root, orig_ref);

		ref->root_gen = trans->transid;
		ref->bytenr = buf->start;
		ref->owner = btrfs_header_owner(buf);
		ref->generation = btrfs_header_generation(buf);
5709

Z
Zheng Yan 已提交
5710 5711 5712 5713 5714 5715 5716
		ret = btrfs_add_leaf_ref(root, ref, 0);
		WARN_ON(ret);
		btrfs_free_leaf_ref(root, ref);
	}
	return 0;
}

C
Chris Mason 已提交
5717
static noinline int invalidate_extent_cache(struct btrfs_root *root,
Z
Zheng Yan 已提交
5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764
					struct extent_buffer *leaf,
					struct btrfs_block_group_cache *group,
					struct btrfs_root *target_root)
{
	struct btrfs_key key;
	struct inode *inode = NULL;
	struct btrfs_file_extent_item *fi;
	u64 num_bytes;
	u64 skip_objectid = 0;
	u32 nritems;
	u32 i;

	nritems = btrfs_header_nritems(leaf);
	for (i = 0; i < nritems; i++) {
		btrfs_item_key_to_cpu(leaf, &key, i);
		if (key.objectid == skip_objectid ||
		    key.type != BTRFS_EXTENT_DATA_KEY)
			continue;
		fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
		if (btrfs_file_extent_type(leaf, fi) ==
		    BTRFS_FILE_EXTENT_INLINE)
			continue;
		if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
			continue;
		if (!inode || inode->i_ino != key.objectid) {
			iput(inode);
			inode = btrfs_ilookup(target_root->fs_info->sb,
					      key.objectid, target_root, 1);
		}
		if (!inode) {
			skip_objectid = key.objectid;
			continue;
		}
		num_bytes = btrfs_file_extent_num_bytes(leaf, fi);

		lock_extent(&BTRFS_I(inode)->io_tree, key.offset,
			    key.offset + num_bytes - 1, GFP_NOFS);
		btrfs_drop_extent_cache(inode, key.offset,
					key.offset + num_bytes - 1, 1);
		unlock_extent(&BTRFS_I(inode)->io_tree, key.offset,
			      key.offset + num_bytes - 1, GFP_NOFS);
		cond_resched();
	}
	iput(inode);
	return 0;
}

C
Chris Mason 已提交
5765
static noinline int replace_extents_in_leaf(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836
					struct btrfs_root *root,
					struct extent_buffer *leaf,
					struct btrfs_block_group_cache *group,
					struct inode *reloc_inode)
{
	struct btrfs_key key;
	struct btrfs_key extent_key;
	struct btrfs_file_extent_item *fi;
	struct btrfs_leaf_ref *ref;
	struct disk_extent *new_extent;
	u64 bytenr;
	u64 num_bytes;
	u32 nritems;
	u32 i;
	int ext_index;
	int nr_extent;
	int ret;

	new_extent = kmalloc(sizeof(*new_extent), GFP_NOFS);
	BUG_ON(!new_extent);

	ref = btrfs_lookup_leaf_ref(root, leaf->start);
	BUG_ON(!ref);

	ext_index = -1;
	nritems = btrfs_header_nritems(leaf);
	for (i = 0; i < nritems; i++) {
		btrfs_item_key_to_cpu(leaf, &key, i);
		if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
			continue;
		fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
		if (btrfs_file_extent_type(leaf, fi) ==
		    BTRFS_FILE_EXTENT_INLINE)
			continue;
		bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
		num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
		if (bytenr == 0)
			continue;

		ext_index++;
		if (bytenr >= group->key.objectid + group->key.offset ||
		    bytenr + num_bytes <= group->key.objectid)
			continue;

		extent_key.objectid = bytenr;
		extent_key.offset = num_bytes;
		extent_key.type = BTRFS_EXTENT_ITEM_KEY;
		nr_extent = 1;
		ret = get_new_locations(reloc_inode, &extent_key,
					group->key.objectid, 1,
					&new_extent, &nr_extent);
		if (ret > 0)
			continue;
		BUG_ON(ret < 0);

		BUG_ON(ref->extents[ext_index].bytenr != bytenr);
		BUG_ON(ref->extents[ext_index].num_bytes != num_bytes);
		ref->extents[ext_index].bytenr = new_extent->disk_bytenr;
		ref->extents[ext_index].num_bytes = new_extent->disk_num_bytes;

		btrfs_set_file_extent_disk_bytenr(leaf, fi,
						new_extent->disk_bytenr);
		btrfs_set_file_extent_disk_num_bytes(leaf, fi,
						new_extent->disk_num_bytes);
		btrfs_mark_buffer_dirty(leaf);

		ret = btrfs_inc_extent_ref(trans, root,
					new_extent->disk_bytenr,
					new_extent->disk_num_bytes,
					leaf->start,
					root->root_key.objectid,
5837
					trans->transid, key.objectid);
Z
Zheng Yan 已提交
5838
		BUG_ON(ret);
5839

Z
Zheng Yan 已提交
5840 5841 5842 5843
		ret = btrfs_free_extent(trans, root,
					bytenr, num_bytes, leaf->start,
					btrfs_header_owner(leaf),
					btrfs_header_generation(leaf),
5844
					key.objectid, 0);
Z
Zheng Yan 已提交
5845 5846 5847 5848 5849 5850 5851 5852 5853
		BUG_ON(ret);
		cond_resched();
	}
	kfree(new_extent);
	BUG_ON(ext_index + 1 != ref->nritems);
	btrfs_free_leaf_ref(root, ref);
	return 0;
}

Y
Yan Zheng 已提交
5854 5855
int btrfs_free_reloc_root(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
Z
Zheng Yan 已提交
5856 5857
{
	struct btrfs_root *reloc_root;
Y
Yan Zheng 已提交
5858
	int ret;
Z
Zheng Yan 已提交
5859 5860 5861 5862 5863 5864

	if (root->reloc_root) {
		reloc_root = root->reloc_root;
		root->reloc_root = NULL;
		list_add(&reloc_root->dead_list,
			 &root->fs_info->dead_reloc_roots);
Y
Yan Zheng 已提交
5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877

		btrfs_set_root_bytenr(&reloc_root->root_item,
				      reloc_root->node->start);
		btrfs_set_root_level(&root->root_item,
				     btrfs_header_level(reloc_root->node));
		memset(&reloc_root->root_item.drop_progress, 0,
			sizeof(struct btrfs_disk_key));
		reloc_root->root_item.drop_level = 0;

		ret = btrfs_update_root(trans, root->fs_info->tree_root,
					&reloc_root->root_key,
					&reloc_root->root_item);
		BUG_ON(ret);
Z
Zheng Yan 已提交
5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974
	}
	return 0;
}

int btrfs_drop_dead_reloc_roots(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *reloc_root;
	struct btrfs_root *prev_root = NULL;
	struct list_head dead_roots;
	int ret;
	unsigned long nr;

	INIT_LIST_HEAD(&dead_roots);
	list_splice_init(&root->fs_info->dead_reloc_roots, &dead_roots);

	while (!list_empty(&dead_roots)) {
		reloc_root = list_entry(dead_roots.prev,
					struct btrfs_root, dead_list);
		list_del_init(&reloc_root->dead_list);

		BUG_ON(reloc_root->commit_root != NULL);
		while (1) {
			trans = btrfs_join_transaction(root, 1);
			BUG_ON(!trans);

			mutex_lock(&root->fs_info->drop_mutex);
			ret = btrfs_drop_snapshot(trans, reloc_root);
			if (ret != -EAGAIN)
				break;
			mutex_unlock(&root->fs_info->drop_mutex);

			nr = trans->blocks_used;
			ret = btrfs_end_transaction(trans, root);
			BUG_ON(ret);
			btrfs_btree_balance_dirty(root, nr);
		}

		free_extent_buffer(reloc_root->node);

		ret = btrfs_del_root(trans, root->fs_info->tree_root,
				     &reloc_root->root_key);
		BUG_ON(ret);
		mutex_unlock(&root->fs_info->drop_mutex);

		nr = trans->blocks_used;
		ret = btrfs_end_transaction(trans, root);
		BUG_ON(ret);
		btrfs_btree_balance_dirty(root, nr);

		kfree(prev_root);
		prev_root = reloc_root;
	}
	if (prev_root) {
		btrfs_remove_leaf_refs(prev_root, (u64)-1, 0);
		kfree(prev_root);
	}
	return 0;
}

int btrfs_add_dead_reloc_root(struct btrfs_root *root)
{
	list_add(&root->dead_list, &root->fs_info->dead_reloc_roots);
	return 0;
}

int btrfs_cleanup_reloc_trees(struct btrfs_root *root)
{
	struct btrfs_root *reloc_root;
	struct btrfs_trans_handle *trans;
	struct btrfs_key location;
	int found;
	int ret;

	mutex_lock(&root->fs_info->tree_reloc_mutex);
	ret = btrfs_find_dead_roots(root, BTRFS_TREE_RELOC_OBJECTID, NULL);
	BUG_ON(ret);
	found = !list_empty(&root->fs_info->dead_reloc_roots);
	mutex_unlock(&root->fs_info->tree_reloc_mutex);

	if (found) {
		trans = btrfs_start_transaction(root, 1);
		BUG_ON(!trans);
		ret = btrfs_commit_transaction(trans, root);
		BUG_ON(ret);
	}

	location.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
	location.offset = (u64)-1;
	location.type = BTRFS_ROOT_ITEM_KEY;

	reloc_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
	BUG_ON(!reloc_root);
	btrfs_orphan_cleanup(reloc_root);
	return 0;
}

C
Chris Mason 已提交
5975
static noinline int init_reloc_tree(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002
				    struct btrfs_root *root)
{
	struct btrfs_root *reloc_root;
	struct extent_buffer *eb;
	struct btrfs_root_item *root_item;
	struct btrfs_key root_key;
	int ret;

	BUG_ON(!root->ref_cows);
	if (root->reloc_root)
		return 0;

	root_item = kmalloc(sizeof(*root_item), GFP_NOFS);
	BUG_ON(!root_item);

	ret = btrfs_copy_root(trans, root, root->commit_root,
			      &eb, BTRFS_TREE_RELOC_OBJECTID);
	BUG_ON(ret);

	root_key.objectid = BTRFS_TREE_RELOC_OBJECTID;
	root_key.offset = root->root_key.objectid;
	root_key.type = BTRFS_ROOT_ITEM_KEY;

	memcpy(root_item, &root->root_item, sizeof(root_item));
	btrfs_set_root_refs(root_item, 0);
	btrfs_set_root_bytenr(root_item, eb->start);
	btrfs_set_root_level(root_item, btrfs_header_level(eb));
6003
	btrfs_set_root_generation(root_item, trans->transid);
Z
Zheng Yan 已提交
6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027

	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);

	ret = btrfs_insert_root(trans, root->fs_info->tree_root,
				&root_key, root_item);
	BUG_ON(ret);
	kfree(root_item);

	reloc_root = btrfs_read_fs_root_no_radix(root->fs_info->tree_root,
						 &root_key);
	BUG_ON(!reloc_root);
	reloc_root->last_trans = trans->transid;
	reloc_root->commit_root = NULL;
	reloc_root->ref_tree = &root->fs_info->reloc_ref_tree;

	root->reloc_root = reloc_root;
	return 0;
}

/*
 * Core function of space balance.
 *
 * The idea is using reloc trees to relocate tree blocks in reference
Y
Yan Zheng 已提交
6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040
 * counted roots. There is one reloc tree for each subvol, and all
 * reloc trees share same root key objectid. Reloc trees are snapshots
 * of the latest committed roots of subvols (root->commit_root).
 *
 * To relocate a tree block referenced by a subvol, there are two steps.
 * COW the block through subvol's reloc tree, then update block pointer
 * in the subvol to point to the new block. Since all reloc trees share
 * same root key objectid, doing special handing for tree blocks owned
 * by them is easy. Once a tree block has been COWed in one reloc tree,
 * we can use the resulting new block directly when the same block is
 * required to COW again through other reloc trees. By this way, relocated
 * tree blocks are shared between reloc trees, so they are also shared
 * between subvols.
Z
Zheng Yan 已提交
6041
 */
C
Chris Mason 已提交
6042
static noinline int relocate_one_path(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054
				      struct btrfs_root *root,
				      struct btrfs_path *path,
				      struct btrfs_key *first_key,
				      struct btrfs_ref_path *ref_path,
				      struct btrfs_block_group_cache *group,
				      struct inode *reloc_inode)
{
	struct btrfs_root *reloc_root;
	struct extent_buffer *eb = NULL;
	struct btrfs_key *keys;
	u64 *nodes;
	int level;
Y
Yan Zheng 已提交
6055
	int shared_level;
Z
Zheng Yan 已提交
6056 6057 6058 6059 6060 6061
	int lowest_level = 0;
	int ret;

	if (ref_path->owner_objectid < BTRFS_FIRST_FREE_OBJECTID)
		lowest_level = ref_path->owner_objectid;

Y
Yan Zheng 已提交
6062
	if (!root->ref_cows) {
Z
Zheng Yan 已提交
6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075
		path->lowest_level = lowest_level;
		ret = btrfs_search_slot(trans, root, first_key, path, 0, 1);
		BUG_ON(ret < 0);
		path->lowest_level = 0;
		btrfs_release_path(root, path);
		return 0;
	}

	mutex_lock(&root->fs_info->tree_reloc_mutex);
	ret = init_reloc_tree(trans, root);
	BUG_ON(ret);
	reloc_root = root->reloc_root;

Y
Yan Zheng 已提交
6076 6077
	shared_level = ref_path->shared_level;
	ref_path->shared_level = BTRFS_MAX_LEVEL - 1;
Z
Zheng Yan 已提交
6078

Y
Yan Zheng 已提交
6079 6080 6081 6082 6083 6084
	keys = ref_path->node_keys;
	nodes = ref_path->new_nodes;
	memset(&keys[shared_level + 1], 0,
	       sizeof(*keys) * (BTRFS_MAX_LEVEL - shared_level - 1));
	memset(&nodes[shared_level + 1], 0,
	       sizeof(*nodes) * (BTRFS_MAX_LEVEL - shared_level - 1));
Z
Zheng Yan 已提交
6085

Y
Yan Zheng 已提交
6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100
	if (nodes[lowest_level] == 0) {
		path->lowest_level = lowest_level;
		ret = btrfs_search_slot(trans, reloc_root, first_key, path,
					0, 1);
		BUG_ON(ret);
		for (level = lowest_level; level < BTRFS_MAX_LEVEL; level++) {
			eb = path->nodes[level];
			if (!eb || eb == reloc_root->node)
				break;
			nodes[level] = eb->start;
			if (level == 0)
				btrfs_item_key_to_cpu(eb, &keys[level], 0);
			else
				btrfs_node_key_to_cpu(eb, &keys[level], 0);
		}
Y
Yan Zheng 已提交
6101 6102
		if (nodes[0] &&
		    ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
Y
Yan Zheng 已提交
6103 6104 6105 6106 6107 6108 6109
			eb = path->nodes[0];
			ret = replace_extents_in_leaf(trans, reloc_root, eb,
						      group, reloc_inode);
			BUG_ON(ret);
		}
		btrfs_release_path(reloc_root, path);
	} else {
Z
Zheng Yan 已提交
6110
		ret = btrfs_merge_path(trans, reloc_root, keys, nodes,
Y
Yan Zheng 已提交
6111
				       lowest_level);
Z
Zheng Yan 已提交
6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122
		BUG_ON(ret);
	}

	/*
	 * replace tree blocks in the fs tree with tree blocks in
	 * the reloc tree.
	 */
	ret = btrfs_merge_path(trans, root, keys, nodes, lowest_level);
	BUG_ON(ret < 0);

	if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
Y
Yan Zheng 已提交
6123 6124 6125 6126 6127 6128
		ret = btrfs_search_slot(trans, reloc_root, first_key, path,
					0, 0);
		BUG_ON(ret);
		extent_buffer_get(path->nodes[0]);
		eb = path->nodes[0];
		btrfs_release_path(reloc_root, path);
Z
Zheng Yan 已提交
6129 6130 6131 6132 6133
		ret = invalidate_extent_cache(reloc_root, eb, group, root);
		BUG_ON(ret);
		free_extent_buffer(eb);
	}

Y
Yan Zheng 已提交
6134
	mutex_unlock(&root->fs_info->tree_reloc_mutex);
Z
Zheng Yan 已提交
6135 6136 6137 6138
	path->lowest_level = 0;
	return 0;
}

C
Chris Mason 已提交
6139
static noinline int relocate_tree_block(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153
					struct btrfs_root *root,
					struct btrfs_path *path,
					struct btrfs_key *first_key,
					struct btrfs_ref_path *ref_path)
{
	int ret;

	ret = relocate_one_path(trans, root, path, first_key,
				ref_path, NULL, NULL);
	BUG_ON(ret);

	return 0;
}

C
Chris Mason 已提交
6154
static noinline int del_extent_zero(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169
				    struct btrfs_root *extent_root,
				    struct btrfs_path *path,
				    struct btrfs_key *extent_key)
{
	int ret;

	ret = btrfs_search_slot(trans, extent_root, extent_key, path, -1, 1);
	if (ret)
		goto out;
	ret = btrfs_del_item(trans, extent_root, path);
out:
	btrfs_release_path(extent_root, path);
	return ret;
}

C
Chris Mason 已提交
6170
static noinline struct btrfs_root *read_ref_root(struct btrfs_fs_info *fs_info,
Z
Zheng Yan 已提交
6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184
						struct btrfs_ref_path *ref_path)
{
	struct btrfs_key root_key;

	root_key.objectid = ref_path->root_objectid;
	root_key.type = BTRFS_ROOT_ITEM_KEY;
	if (is_cowonly_root(ref_path->root_objectid))
		root_key.offset = 0;
	else
		root_key.offset = (u64)-1;

	return btrfs_read_fs_root_no_name(fs_info, &root_key);
}

C
Chris Mason 已提交
6185
static noinline int relocate_one_extent(struct btrfs_root *extent_root,
Z
Zheng Yan 已提交
6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212
					struct btrfs_path *path,
					struct btrfs_key *extent_key,
					struct btrfs_block_group_cache *group,
					struct inode *reloc_inode, int pass)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *found_root;
	struct btrfs_ref_path *ref_path = NULL;
	struct disk_extent *new_extents = NULL;
	int nr_extents = 0;
	int loops;
	int ret;
	int level;
	struct btrfs_key first_key;
	u64 prev_block = 0;


	trans = btrfs_start_transaction(extent_root, 1);
	BUG_ON(!trans);

	if (extent_key->objectid == 0) {
		ret = del_extent_zero(trans, extent_root, path, extent_key);
		goto out;
	}

	ref_path = kmalloc(sizeof(*ref_path), GFP_NOFS);
	if (!ref_path) {
C
Chris Mason 已提交
6213 6214
		ret = -ENOMEM;
		goto out;
Z
Zheng Yan 已提交
6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280
	}

	for (loops = 0; ; loops++) {
		if (loops == 0) {
			ret = btrfs_first_ref_path(trans, extent_root, ref_path,
						   extent_key->objectid);
		} else {
			ret = btrfs_next_ref_path(trans, extent_root, ref_path);
		}
		if (ret < 0)
			goto out;
		if (ret > 0)
			break;

		if (ref_path->root_objectid == BTRFS_TREE_LOG_OBJECTID ||
		    ref_path->root_objectid == BTRFS_TREE_RELOC_OBJECTID)
			continue;

		found_root = read_ref_root(extent_root->fs_info, ref_path);
		BUG_ON(!found_root);
		/*
		 * for reference counted tree, only process reference paths
		 * rooted at the latest committed root.
		 */
		if (found_root->ref_cows &&
		    ref_path->root_generation != found_root->root_key.offset)
			continue;

		if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
			if (pass == 0) {
				/*
				 * copy data extents to new locations
				 */
				u64 group_start = group->key.objectid;
				ret = relocate_data_extent(reloc_inode,
							   extent_key,
							   group_start);
				if (ret < 0)
					goto out;
				break;
			}
			level = 0;
		} else {
			level = ref_path->owner_objectid;
		}

		if (prev_block != ref_path->nodes[level]) {
			struct extent_buffer *eb;
			u64 block_start = ref_path->nodes[level];
			u64 block_size = btrfs_level_size(found_root, level);

			eb = read_tree_block(found_root, block_start,
					     block_size, 0);
			btrfs_tree_lock(eb);
			BUG_ON(level != btrfs_header_level(eb));

			if (level == 0)
				btrfs_item_key_to_cpu(eb, &first_key, 0);
			else
				btrfs_node_key_to_cpu(eb, &first_key, 0);

			btrfs_tree_unlock(eb);
			free_extent_buffer(eb);
			prev_block = block_start;
		}

6281
		mutex_lock(&extent_root->fs_info->trans_mutex);
Y
Yan Zheng 已提交
6282
		btrfs_record_root_in_trans(found_root);
6283
		mutex_unlock(&extent_root->fs_info->trans_mutex);
Y
Yan Zheng 已提交
6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296
		if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
			/*
			 * try to update data extent references while
			 * keeping metadata shared between snapshots.
			 */
			if (pass == 1) {
				ret = relocate_one_path(trans, found_root,
						path, &first_key, ref_path,
						group, reloc_inode);
				if (ret < 0)
					goto out;
				continue;
			}
Z
Zheng Yan 已提交
6297 6298 6299 6300 6301 6302
			/*
			 * use fallback method to process the remaining
			 * references.
			 */
			if (!new_extents) {
				u64 group_start = group->key.objectid;
Y
Yan Zheng 已提交
6303 6304 6305
				new_extents = kmalloc(sizeof(*new_extents),
						      GFP_NOFS);
				nr_extents = 1;
Z
Zheng Yan 已提交
6306 6307
				ret = get_new_locations(reloc_inode,
							extent_key,
Y
Yan Zheng 已提交
6308
							group_start, 1,
Z
Zheng Yan 已提交
6309 6310
							&new_extents,
							&nr_extents);
Y
Yan Zheng 已提交
6311
				if (ret)
Z
Zheng Yan 已提交
6312 6313 6314 6315 6316 6317
					goto out;
			}
			ret = replace_one_extent(trans, found_root,
						path, extent_key,
						&first_key, ref_path,
						new_extents, nr_extents);
Y
Yan Zheng 已提交
6318
		} else {
Z
Zheng Yan 已提交
6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331
			ret = relocate_tree_block(trans, found_root, path,
						  &first_key, ref_path);
		}
		if (ret < 0)
			goto out;
	}
	ret = 0;
out:
	btrfs_end_transaction(trans, extent_root);
	kfree(new_extents);
	kfree(ref_path);
	return ret;
}
6332
#endif
Z
Zheng Yan 已提交
6333

6334 6335 6336 6337 6338 6339
static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
{
	u64 num_devices;
	u64 stripped = BTRFS_BLOCK_GROUP_RAID0 |
		BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;

Y
Yan Zheng 已提交
6340
	num_devices = root->fs_info->fs_devices->rw_devices;
6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371
	if (num_devices == 1) {
		stripped |= BTRFS_BLOCK_GROUP_DUP;
		stripped = flags & ~stripped;

		/* turn raid0 into single device chunks */
		if (flags & BTRFS_BLOCK_GROUP_RAID0)
			return stripped;

		/* turn mirroring into duplication */
		if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
			     BTRFS_BLOCK_GROUP_RAID10))
			return stripped | BTRFS_BLOCK_GROUP_DUP;
		return flags;
	} else {
		/* they already had raid on here, just return */
		if (flags & stripped)
			return flags;

		stripped |= BTRFS_BLOCK_GROUP_DUP;
		stripped = flags & ~stripped;

		/* switch duplicated blocks with raid1 */
		if (flags & BTRFS_BLOCK_GROUP_DUP)
			return stripped | BTRFS_BLOCK_GROUP_RAID1;

		/* turn single device chunks into raid0 */
		return stripped | BTRFS_BLOCK_GROUP_RAID0;
	}
	return flags;
}

6372
static int __alloc_chunk_for_shrink(struct btrfs_root *root,
C
Chris Mason 已提交
6373 6374 6375 6376 6377 6378 6379
		     struct btrfs_block_group_cache *shrink_block_group,
		     int force)
{
	struct btrfs_trans_handle *trans;
	u64 new_alloc_flags;
	u64 calc;

6380
	spin_lock(&shrink_block_group->lock);
6381 6382
	if (btrfs_block_group_used(&shrink_block_group->item) +
	    shrink_block_group->reserved > 0) {
6383 6384
		spin_unlock(&shrink_block_group->lock);

C
Chris Mason 已提交
6385
		trans = btrfs_start_transaction(root, 1);
6386
		spin_lock(&shrink_block_group->lock);
6387

C
Chris Mason 已提交
6388 6389 6390 6391 6392 6393 6394 6395
		new_alloc_flags = update_block_group_flags(root,
						   shrink_block_group->flags);
		if (new_alloc_flags != shrink_block_group->flags) {
			calc =
			     btrfs_block_group_used(&shrink_block_group->item);
		} else {
			calc = shrink_block_group->key.offset;
		}
6396 6397
		spin_unlock(&shrink_block_group->lock);

C
Chris Mason 已提交
6398 6399
		do_chunk_alloc(trans, root->fs_info->extent_root,
			       calc + 2 * 1024 * 1024, new_alloc_flags, force);
6400

C
Chris Mason 已提交
6401
		btrfs_end_transaction(trans, root);
6402 6403
	} else
		spin_unlock(&shrink_block_group->lock);
C
Chris Mason 已提交
6404 6405 6406
	return 0;
}

6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417

int btrfs_prepare_block_group_relocation(struct btrfs_root *root,
					 struct btrfs_block_group_cache *group)

{
	__alloc_chunk_for_shrink(root, group, 1);
	set_block_group_readonly(group);
	return 0;
}

#if 0
Z
Zheng Yan 已提交
6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430
static int __insert_orphan_inode(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 u64 objectid, u64 size)
{
	struct btrfs_path *path;
	struct btrfs_inode_item *item;
	struct extent_buffer *leaf;
	int ret;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

6431
	path->leave_spinning = 1;
Z
Zheng Yan 已提交
6432 6433 6434 6435 6436 6437 6438 6439 6440 6441
	ret = btrfs_insert_empty_inode(trans, root, path, objectid);
	if (ret)
		goto out;

	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_inode_item);
	memset_extent_buffer(leaf, 0, (unsigned long)item, sizeof(*item));
	btrfs_set_inode_generation(leaf, item, 1);
	btrfs_set_inode_size(leaf, item, size);
	btrfs_set_inode_mode(leaf, item, S_IFREG | 0600);
6442
	btrfs_set_inode_flags(leaf, item, BTRFS_INODE_NOCOMPRESS);
Z
Zheng Yan 已提交
6443 6444 6445 6446 6447 6448 6449
	btrfs_mark_buffer_dirty(leaf);
	btrfs_release_path(root, path);
out:
	btrfs_free_path(path);
	return ret;
}

C
Chris Mason 已提交
6450
static noinline struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
Z
Zheng Yan 已提交
6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477
					struct btrfs_block_group_cache *group)
{
	struct inode *inode = NULL;
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root;
	struct btrfs_key root_key;
	u64 objectid = BTRFS_FIRST_FREE_OBJECTID;
	int err = 0;

	root_key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
	root_key.type = BTRFS_ROOT_ITEM_KEY;
	root_key.offset = (u64)-1;
	root = btrfs_read_fs_root_no_name(fs_info, &root_key);
	if (IS_ERR(root))
		return ERR_CAST(root);

	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);

	err = btrfs_find_free_objectid(trans, root, objectid, &objectid);
	if (err)
		goto out;

	err = __insert_orphan_inode(trans, root, objectid, group->key.offset);
	BUG_ON(err);

	err = btrfs_insert_file_extent(trans, root, objectid, 0, 0, 0,
C
Chris Mason 已提交
6478 6479
				       group->key.offset, 0, group->key.offset,
				       0, 0, 0);
Z
Zheng Yan 已提交
6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493
	BUG_ON(err);

	inode = btrfs_iget_locked(root->fs_info->sb, objectid, root);
	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		BTRFS_I(inode)->location.objectid = objectid;
		BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
		BTRFS_I(inode)->location.offset = 0;
		btrfs_read_locked_inode(inode);
		unlock_new_inode(inode);
		BUG_ON(is_bad_inode(inode));
	} else {
		BUG_ON(1);
	}
6494
	BTRFS_I(inode)->index_cnt = group->key.objectid;
Z
Zheng Yan 已提交
6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506

	err = btrfs_orphan_add(trans, inode);
out:
	btrfs_end_transaction(trans, root);
	if (err) {
		if (inode)
			iput(inode);
		inode = ERR_PTR(err);
	}
	return inode;
}

6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524
int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len)
{

	struct btrfs_ordered_sum *sums;
	struct btrfs_sector_sum *sector_sum;
	struct btrfs_ordered_extent *ordered;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct list_head list;
	size_t offset;
	int ret;
	u64 disk_bytenr;

	INIT_LIST_HEAD(&list);

	ordered = btrfs_lookup_ordered_extent(inode, file_pos);
	BUG_ON(ordered->file_offset != file_pos || ordered->len != len);

	disk_bytenr = file_pos + BTRFS_I(inode)->index_cnt;
Y
Yan Zheng 已提交
6525
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, disk_bytenr,
6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547
				       disk_bytenr + len - 1, &list);

	while (!list_empty(&list)) {
		sums = list_entry(list.next, struct btrfs_ordered_sum, list);
		list_del_init(&sums->list);

		sector_sum = sums->sums;
		sums->bytenr = ordered->start;

		offset = 0;
		while (offset < sums->len) {
			sector_sum->bytenr += ordered->start - disk_bytenr;
			sector_sum++;
			offset += root->sectorsize;
		}

		btrfs_add_ordered_sum(inode, ordered, sums);
	}
	btrfs_put_ordered_extent(ordered);
	return 0;
}

Z
Zheng Yan 已提交
6548
int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start)
6549 6550 6551
{
	struct btrfs_trans_handle *trans;
	struct btrfs_path *path;
Z
Zheng Yan 已提交
6552 6553 6554 6555 6556
	struct btrfs_fs_info *info = root->fs_info;
	struct extent_buffer *leaf;
	struct inode *reloc_inode;
	struct btrfs_block_group_cache *block_group;
	struct btrfs_key key;
Y
Yan Zheng 已提交
6557
	u64 skipped;
6558 6559 6560 6561
	u64 cur_byte;
	u64 total_found;
	u32 nritems;
	int ret;
6562
	int progress;
Z
Zheng Yan 已提交
6563
	int pass = 0;
6564

Z
Zheng Yan 已提交
6565 6566 6567 6568
	root = root->fs_info->extent_root;

	block_group = btrfs_lookup_block_group(info, group_start);
	BUG_ON(!block_group);
6569

C
Chris Mason 已提交
6570
	printk(KERN_INFO "btrfs relocating block group %llu flags %llu\n",
Z
Zheng Yan 已提交
6571 6572
	       (unsigned long long)block_group->key.objectid,
	       (unsigned long long)block_group->flags);
6573

6574
	path = btrfs_alloc_path();
Z
Zheng Yan 已提交
6575
	BUG_ON(!path);
6576

Z
Zheng Yan 已提交
6577 6578
	reloc_inode = create_reloc_inode(info, block_group);
	BUG_ON(IS_ERR(reloc_inode));
6579

Z
Zheng Yan 已提交
6580
	__alloc_chunk_for_shrink(root, block_group, 1);
Y
Yan Zheng 已提交
6581
	set_block_group_readonly(block_group);
6582

Z
Zheng Yan 已提交
6583 6584 6585
	btrfs_start_delalloc_inodes(info->tree_root);
	btrfs_wait_ordered_extents(info->tree_root, 0);
again:
Y
Yan Zheng 已提交
6586
	skipped = 0;
6587
	total_found = 0;
6588
	progress = 0;
Z
Zheng Yan 已提交
6589
	key.objectid = block_group->key.objectid;
6590 6591
	key.offset = 0;
	key.type = 0;
6592
	cur_byte = key.objectid;
6593

Z
Zheng Yan 已提交
6594 6595
	trans = btrfs_start_transaction(info->tree_root, 1);
	btrfs_commit_transaction(trans, info->tree_root);
6596

Z
Zheng Yan 已提交
6597 6598 6599 6600
	mutex_lock(&root->fs_info->cleaner_mutex);
	btrfs_clean_old_snapshots(info->tree_root);
	btrfs_remove_leaf_refs(info->tree_root, (u64)-1, 1);
	mutex_unlock(&root->fs_info->cleaner_mutex);
6601

6602 6603 6604
	trans = btrfs_start_transaction(info->tree_root, 1);
	btrfs_commit_transaction(trans, info->tree_root);

C
Chris Mason 已提交
6605
	while (1) {
6606 6607 6608
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		if (ret < 0)
			goto out;
6609
next:
6610
		leaf = path->nodes[0];
6611 6612 6613 6614 6615 6616 6617 6618
		nritems = btrfs_header_nritems(leaf);
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				goto out;
			if (ret == 1) {
				ret = 0;
				break;
6619
			}
6620 6621
			leaf = path->nodes[0];
			nritems = btrfs_header_nritems(leaf);
6622
		}
6623

Z
Zheng Yan 已提交
6624
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
6625

Z
Zheng Yan 已提交
6626 6627
		if (key.objectid >= block_group->key.objectid +
		    block_group->key.offset)
6628 6629
			break;

6630 6631
		if (progress && need_resched()) {
			btrfs_release_path(root, path);
Z
Zheng Yan 已提交
6632
			cond_resched();
6633
			progress = 0;
Z
Zheng Yan 已提交
6634
			continue;
6635 6636 6637
		}
		progress = 1;

Z
Zheng Yan 已提交
6638 6639
		if (btrfs_key_type(&key) != BTRFS_EXTENT_ITEM_KEY ||
		    key.objectid + key.offset <= cur_byte) {
6640 6641 6642
			path->slots[0]++;
			goto next;
		}
6643

6644
		total_found++;
Z
Zheng Yan 已提交
6645
		cur_byte = key.objectid + key.offset;
6646 6647
		btrfs_release_path(root, path);

Z
Zheng Yan 已提交
6648 6649 6650 6651
		__alloc_chunk_for_shrink(root, block_group, 0);
		ret = relocate_one_extent(root, path, &key, block_group,
					  reloc_inode, pass);
		BUG_ON(ret < 0);
Y
Yan Zheng 已提交
6652 6653
		if (ret > 0)
			skipped++;
6654

Z
Zheng Yan 已提交
6655 6656 6657
		key.objectid = cur_byte;
		key.type = 0;
		key.offset = 0;
6658 6659
	}

Z
Zheng Yan 已提交
6660
	btrfs_release_path(root, path);
6661

Z
Zheng Yan 已提交
6662 6663 6664
	if (pass == 0) {
		btrfs_wait_ordered_range(reloc_inode, 0, (u64)-1);
		invalidate_mapping_pages(reloc_inode->i_mapping, 0, -1);
6665
	}
6666

Z
Zheng Yan 已提交
6667
	if (total_found > 0) {
C
Chris Mason 已提交
6668
		printk(KERN_INFO "btrfs found %llu extents in pass %d\n",
Z
Zheng Yan 已提交
6669 6670
		       (unsigned long long)total_found, pass);
		pass++;
Y
Yan Zheng 已提交
6671 6672 6673 6674 6675
		if (total_found == skipped && pass > 2) {
			iput(reloc_inode);
			reloc_inode = create_reloc_inode(info, block_group);
			pass = 0;
		}
Z
Zheng Yan 已提交
6676
		goto again;
J
Josef Bacik 已提交
6677
	}
C
Chris Mason 已提交
6678

Z
Zheng Yan 已提交
6679 6680 6681 6682 6683 6684
	/* delete reloc_inode */
	iput(reloc_inode);

	/* unpin extents in this range */
	trans = btrfs_start_transaction(info->tree_root, 1);
	btrfs_commit_transaction(trans, info->tree_root);
C
Chris Mason 已提交
6685

Z
Zheng Yan 已提交
6686 6687 6688 6689 6690
	spin_lock(&block_group->lock);
	WARN_ON(block_group->pinned > 0);
	WARN_ON(block_group->reserved > 0);
	WARN_ON(btrfs_block_group_used(&block_group->item) > 0);
	spin_unlock(&block_group->lock);
6691
	btrfs_put_block_group(block_group);
Z
Zheng Yan 已提交
6692
	ret = 0;
6693
out:
Z
Zheng Yan 已提交
6694
	btrfs_free_path(path);
6695 6696
	return ret;
}
6697
#endif
6698

6699 6700
static int find_first_block_group(struct btrfs_root *root,
		struct btrfs_path *path, struct btrfs_key *key)
6701
{
6702
	int ret = 0;
6703 6704 6705
	struct btrfs_key found_key;
	struct extent_buffer *leaf;
	int slot;
6706

6707 6708
	ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
	if (ret < 0)
6709 6710
		goto out;

C
Chris Mason 已提交
6711
	while (1) {
6712
		slot = path->slots[0];
6713
		leaf = path->nodes[0];
6714 6715 6716 6717 6718
		if (slot >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
			if (ret == 0)
				continue;
			if (ret < 0)
6719
				goto out;
6720
			break;
6721
		}
6722
		btrfs_item_key_to_cpu(leaf, &found_key, slot);
6723

6724
		if (found_key.objectid >= key->objectid &&
6725 6726 6727 6728
		    found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
			ret = 0;
			goto out;
		}
6729
		path->slots[0]++;
6730
	}
6731
	ret = -ENOENT;
6732
out:
6733
	return ret;
6734 6735
}

Z
Zheng Yan 已提交
6736 6737 6738
int btrfs_free_block_groups(struct btrfs_fs_info *info)
{
	struct btrfs_block_group_cache *block_group;
6739
	struct btrfs_space_info *space_info;
Z
Zheng Yan 已提交
6740 6741 6742 6743 6744 6745 6746 6747
	struct rb_node *n;

	spin_lock(&info->block_group_cache_lock);
	while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
		block_group = rb_entry(n, struct btrfs_block_group_cache,
				       cache_node);
		rb_erase(&block_group->cache_node,
			 &info->block_group_cache_tree);
Y
Yan Zheng 已提交
6748 6749 6750
		spin_unlock(&info->block_group_cache_lock);

		btrfs_remove_free_space_cache(block_group);
6751
		down_write(&block_group->space_info->groups_sem);
Z
Zheng Yan 已提交
6752
		list_del(&block_group->list);
6753
		up_write(&block_group->space_info->groups_sem);
6754 6755

		WARN_ON(atomic_read(&block_group->count) != 1);
Z
Zheng Yan 已提交
6756
		kfree(block_group);
Y
Yan Zheng 已提交
6757 6758

		spin_lock(&info->block_group_cache_lock);
Z
Zheng Yan 已提交
6759 6760
	}
	spin_unlock(&info->block_group_cache_lock);
6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777

	/* now that all the block groups are freed, go through and
	 * free all the space_info structs.  This is only called during
	 * the final stages of unmount, and so we know nobody is
	 * using them.  We call synchronize_rcu() once before we start,
	 * just to be on the safe side.
	 */
	synchronize_rcu();

	while(!list_empty(&info->space_info)) {
		space_info = list_entry(info->space_info.next,
					struct btrfs_space_info,
					list);

		list_del(&space_info->list);
		kfree(space_info);
	}
Z
Zheng Yan 已提交
6778 6779 6780
	return 0;
}

C
Chris Mason 已提交
6781 6782 6783 6784 6785
int btrfs_read_block_groups(struct btrfs_root *root)
{
	struct btrfs_path *path;
	int ret;
	struct btrfs_block_group_cache *cache;
C
Chris Mason 已提交
6786
	struct btrfs_fs_info *info = root->fs_info;
6787
	struct btrfs_space_info *space_info;
C
Chris Mason 已提交
6788 6789
	struct btrfs_key key;
	struct btrfs_key found_key;
6790
	struct extent_buffer *leaf;
6791

C
Chris Mason 已提交
6792
	root = info->extent_root;
C
Chris Mason 已提交
6793
	key.objectid = 0;
6794
	key.offset = 0;
C
Chris Mason 已提交
6795 6796 6797 6798 6799
	btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

C
Chris Mason 已提交
6800
	while (1) {
6801 6802 6803 6804
		ret = find_first_block_group(root, path, &key);
		if (ret > 0) {
			ret = 0;
			goto error;
C
Chris Mason 已提交
6805
		}
6806 6807 6808
		if (ret != 0)
			goto error;

6809 6810
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6811
		cache = kzalloc(sizeof(*cache), GFP_NOFS);
C
Chris Mason 已提交
6812
		if (!cache) {
6813
			ret = -ENOMEM;
C
Chris Mason 已提交
6814 6815
			break;
		}
C
Chris Mason 已提交
6816

6817
		atomic_set(&cache->count, 1);
6818
		spin_lock_init(&cache->lock);
6819
		spin_lock_init(&cache->tree_lock);
6820
		mutex_init(&cache->cache_mutex);
J
Josef Bacik 已提交
6821
		INIT_LIST_HEAD(&cache->list);
6822
		INIT_LIST_HEAD(&cache->cluster_list);
6823 6824 6825
		read_extent_buffer(leaf, &cache->item,
				   btrfs_item_ptr_offset(leaf, path->slots[0]),
				   sizeof(cache->item));
C
Chris Mason 已提交
6826
		memcpy(&cache->key, &found_key, sizeof(found_key));
6827

C
Chris Mason 已提交
6828 6829
		key.objectid = found_key.objectid + found_key.offset;
		btrfs_release_path(root, path);
6830
		cache->flags = btrfs_block_group_flags(&cache->item);
6831

6832 6833 6834 6835 6836
		ret = update_space_info(info, cache->flags, found_key.offset,
					btrfs_block_group_used(&cache->item),
					&space_info);
		BUG_ON(ret);
		cache->space_info = space_info;
6837 6838 6839
		down_write(&space_info->groups_sem);
		list_add_tail(&cache->list, &space_info->block_groups);
		up_write(&space_info->groups_sem);
J
Josef Bacik 已提交
6840 6841 6842

		ret = btrfs_add_block_group_cache(root->fs_info, cache);
		BUG_ON(ret);
6843 6844

		set_avail_alloc_bits(root->fs_info, cache->flags);
Y
Yan Zheng 已提交
6845 6846
		if (btrfs_chunk_readonly(root, cache->key.objectid))
			set_block_group_readonly(cache);
C
Chris Mason 已提交
6847
	}
6848 6849
	ret = 0;
error:
C
Chris Mason 已提交
6850
	btrfs_free_path(path);
6851
	return ret;
C
Chris Mason 已提交
6852
}
6853 6854 6855

int btrfs_make_block_group(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root, u64 bytes_used,
6856
			   u64 type, u64 chunk_objectid, u64 chunk_offset,
6857 6858 6859 6860 6861 6862 6863 6864
			   u64 size)
{
	int ret;
	struct btrfs_root *extent_root;
	struct btrfs_block_group_cache *cache;

	extent_root = root->fs_info->extent_root;

6865
	root->fs_info->last_trans_log_full_commit = trans->transid;
6866

6867
	cache = kzalloc(sizeof(*cache), GFP_NOFS);
J
Josef Bacik 已提交
6868 6869 6870
	if (!cache)
		return -ENOMEM;

6871
	cache->key.objectid = chunk_offset;
6872
	cache->key.offset = size;
6873 6874
	cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
	atomic_set(&cache->count, 1);
6875
	spin_lock_init(&cache->lock);
6876
	spin_lock_init(&cache->tree_lock);
6877
	mutex_init(&cache->cache_mutex);
J
Josef Bacik 已提交
6878
	INIT_LIST_HEAD(&cache->list);
6879
	INIT_LIST_HEAD(&cache->cluster_list);
C
Chris Mason 已提交
6880

6881 6882 6883 6884 6885 6886 6887 6888
	btrfs_set_block_group_used(&cache->item, bytes_used);
	btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
	cache->flags = type;
	btrfs_set_block_group_flags(&cache->item, type);

	ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
				&cache->space_info);
	BUG_ON(ret);
6889 6890 6891
	down_write(&cache->space_info->groups_sem);
	list_add_tail(&cache->list, &cache->space_info->block_groups);
	up_write(&cache->space_info->groups_sem);
6892

J
Josef Bacik 已提交
6893 6894
	ret = btrfs_add_block_group_cache(root->fs_info, cache);
	BUG_ON(ret);
6895

6896 6897 6898 6899
	ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
				sizeof(cache->item));
	BUG_ON(ret);

C
Chris Mason 已提交
6900
	set_avail_alloc_bits(extent_root->fs_info, type);
6901

6902 6903
	return 0;
}
Z
Zheng Yan 已提交
6904 6905 6906 6907 6908 6909

int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root, u64 group_start)
{
	struct btrfs_path *path;
	struct btrfs_block_group_cache *block_group;
6910
	struct btrfs_free_cluster *cluster;
Z
Zheng Yan 已提交
6911 6912 6913 6914 6915 6916 6917
	struct btrfs_key key;
	int ret;

	root = root->fs_info->extent_root;

	block_group = btrfs_lookup_block_group(root->fs_info, group_start);
	BUG_ON(!block_group);
Y
Yan Zheng 已提交
6918
	BUG_ON(!block_group->ro);
Z
Zheng Yan 已提交
6919 6920 6921

	memcpy(&key, &block_group->key, sizeof(key));

6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936
	/* make sure this block group isn't part of an allocation cluster */
	cluster = &root->fs_info->data_alloc_cluster;
	spin_lock(&cluster->refill_lock);
	btrfs_return_cluster_to_free_space(block_group, cluster);
	spin_unlock(&cluster->refill_lock);

	/*
	 * make sure this block group isn't part of a metadata
	 * allocation cluster
	 */
	cluster = &root->fs_info->meta_alloc_cluster;
	spin_lock(&cluster->refill_lock);
	btrfs_return_cluster_to_free_space(block_group, cluster);
	spin_unlock(&cluster->refill_lock);

Z
Zheng Yan 已提交
6937 6938 6939
	path = btrfs_alloc_path();
	BUG_ON(!path);

6940
	spin_lock(&root->fs_info->block_group_cache_lock);
Z
Zheng Yan 已提交
6941 6942
	rb_erase(&block_group->cache_node,
		 &root->fs_info->block_group_cache_tree);
6943 6944
	spin_unlock(&root->fs_info->block_group_cache_lock);
	btrfs_remove_free_space_cache(block_group);
6945
	down_write(&block_group->space_info->groups_sem);
6946 6947 6948 6949 6950
	/*
	 * we must use list_del_init so people can check to see if they
	 * are still on the list after taking the semaphore
	 */
	list_del_init(&block_group->list);
6951
	up_write(&block_group->space_info->groups_sem);
Z
Zheng Yan 已提交
6952

Y
Yan Zheng 已提交
6953 6954 6955 6956
	spin_lock(&block_group->space_info->lock);
	block_group->space_info->total_bytes -= block_group->key.offset;
	block_group->space_info->bytes_readonly -= block_group->key.offset;
	spin_unlock(&block_group->space_info->lock);
Y
Yan Zheng 已提交
6957
	block_group->space_info->full = 0;
Y
Yan Zheng 已提交
6958

6959 6960
	btrfs_put_block_group(block_group);
	btrfs_put_block_group(block_group);
Z
Zheng Yan 已提交
6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972

	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
	if (ret > 0)
		ret = -EIO;
	if (ret < 0)
		goto out;

	ret = btrfs_del_item(trans, root, path);
out:
	btrfs_free_path(path);
	return ret;
}