1 // SPDX-License-Identifier: GPL-2.0
20 #include "tree-log.h"
21 #include "disk-io.h"
22 #include "print-tree.h"
26 #include "free-space-cache.h"
27 #include "free-space-tree.h"
30 #include "ref-verify.h"
31 #include "space-info.h"
32 #include "block-rsv.h"
33 #include "delalloc-space.h"
34 #include "block-group.h"
36 #include "rcu-string.h"
61 	return (cache->flags & bits) == bits;  in block_group_bits()
67 	u64 end = start + num_bytes - 1;  in btrfs_add_excluded_extent()
68 	set_extent_bits(&fs_info->excluded_extents, start, end,  in btrfs_add_excluded_extent()
75 	struct btrfs_fs_info *fs_info = cache->fs_info;  in btrfs_free_excluded_extents()
78 	start = cache->start;  in btrfs_free_excluded_extents()
79 	end = start + cache->length - 1;  in btrfs_free_excluded_extents()
81 	clear_extent_bits(&fs_info->excluded_extents, start, end,  in btrfs_free_excluded_extents()
94 		return -ENOMEM;  in btrfs_lookup_data_extent()
99 	ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0);  in btrfs_lookup_data_extent()
133 		offset = fs_info->nodesize;  in btrfs_lookup_extent_info()
139 		return -ENOMEM;  in btrfs_lookup_extent_info()
142 		path->skip_locking = 1;  in btrfs_lookup_extent_info()
143 		path->search_commit_root = 1;  in btrfs_lookup_extent_info()
154 	ret = btrfs_search_slot(trans, fs_info->extent_root, &key, path, 0, 0);  in btrfs_lookup_extent_info()
159 		if (path->slots[0]) {  in btrfs_lookup_extent_info()
160 			path->slots[0]--;  in btrfs_lookup_extent_info()
161 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in btrfs_lookup_extent_info()
162 					      path->slots[0]);  in btrfs_lookup_extent_info()
165 			    key.offset == fs_info->nodesize)  in btrfs_lookup_extent_info()
171 		leaf = path->nodes[0];  in btrfs_lookup_extent_info()
172 		item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in btrfs_lookup_extent_info()
174 			ei = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_lookup_extent_info()
179 			ret = -EINVAL;  in btrfs_lookup_extent_info()
199 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_lookup_extent_info()
200 	spin_lock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
203 		if (!mutex_trylock(&head->mutex)) {  in btrfs_lookup_extent_info()
204 			refcount_inc(&head->refs);  in btrfs_lookup_extent_info()
205 			spin_unlock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
213 			mutex_lock(&head->mutex);  in btrfs_lookup_extent_info()
214 			mutex_unlock(&head->mutex);  in btrfs_lookup_extent_info()
218 		spin_lock(&head->lock);  in btrfs_lookup_extent_info()
219 		if (head->extent_op && head->extent_op->update_flags)  in btrfs_lookup_extent_info()
220 			extent_flags |= head->extent_op->flags_to_set;  in btrfs_lookup_extent_info()
224 		num_refs += head->ref_mod;  in btrfs_lookup_extent_info()
225 		spin_unlock(&head->lock);  in btrfs_lookup_extent_info()
226 		mutex_unlock(&head->mutex);  in btrfs_lookup_extent_info()
228 	spin_unlock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
255  * for pointers in non-shared tree blocks. For a given pointer in a block,
258  * b-tree searching. The full back refs is for pointers in tree blocks not
301  * - multiple snapshots, subvolumes, or different generations in one subvol
302  * - different files inside a single subvolume
303  * - different offsets inside a file (bookend extents in file.c)
307  * - Objectid of the subvolume root
308  * - objectid of the file holding the reference
309  * - original offset in the file
310  * - how many bookend extents
317  * - number of pointers in the tree leaf
334  * - Different subvolumes
366 				ASSERT(eb->fs_info);  in btrfs_get_extent_inline_ref_type()
372 				    IS_ALIGNED(offset, eb->fs_info->sectorsize))  in btrfs_get_extent_inline_ref_type()
379 				ASSERT(eb->fs_info);  in btrfs_get_extent_inline_ref_type()
385 				    IS_ALIGNED(offset, eb->fs_info->sectorsize))  in btrfs_get_extent_inline_ref_type()
395 	btrfs_err(eb->fs_info,  in btrfs_get_extent_inline_ref_type()
397 		  eb->start, (unsigned long)iref, type);  in btrfs_get_extent_inline_ref_type()
444 	struct btrfs_root *root = trans->fs_info->extent_root;  in lookup_extent_data_ref()
451 	int err = -ENOENT;  in lookup_extent_data_ref()
464 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in lookup_extent_data_ref()
476 	leaf = path->nodes[0];  in lookup_extent_data_ref()
479 		if (path->slots[0] >= nritems) {  in lookup_extent_data_ref()
486 			leaf = path->nodes[0];  in lookup_extent_data_ref()
491 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in lookup_extent_data_ref()
496 		ref = btrfs_item_ptr(leaf, path->slots[0],  in lookup_extent_data_ref()
508 		path->slots[0]++;  in lookup_extent_data_ref()
520 	struct btrfs_root *root = trans->fs_info->extent_root;  in insert_extent_data_ref()
540 	if (ret && ret != -EEXIST)  in insert_extent_data_ref()
543 	leaf = path->nodes[0];  in insert_extent_data_ref()
546 		ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
557 		while (ret == -EEXIST) {  in insert_extent_data_ref()
558 			ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
567 			if (ret && ret != -EEXIST)  in insert_extent_data_ref()
570 			leaf = path->nodes[0];  in insert_extent_data_ref()
572 		ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
604 	leaf = path->nodes[0];  in remove_extent_data_ref()
605 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in remove_extent_data_ref()
608 		ref1 = btrfs_item_ptr(leaf, path->slots[0],  in remove_extent_data_ref()
612 		ref2 = btrfs_item_ptr(leaf, path->slots[0],  in remove_extent_data_ref()
616 		btrfs_print_v0_err(trans->fs_info);  in remove_extent_data_ref()
617 		btrfs_abort_transaction(trans, -EINVAL);  in remove_extent_data_ref()
618 		return -EINVAL;  in remove_extent_data_ref()
624 	num_refs -= refs_to_drop;  in remove_extent_data_ref()
627 		ret = btrfs_del_item(trans, trans->fs_info->extent_root, path);  in remove_extent_data_ref()
649 	leaf = path->nodes[0];  in extent_data_ref_count()
650 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in extent_data_ref_count()
661 			ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);  in extent_data_ref_count()
668 		ref1 = btrfs_item_ptr(leaf, path->slots[0],  in extent_data_ref_count()
672 		ref2 = btrfs_item_ptr(leaf, path->slots[0],  in extent_data_ref_count()
686 	struct btrfs_root *root = trans->fs_info->extent_root;  in lookup_tree_block_ref()
699 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in lookup_tree_block_ref()
701 		ret = -ENOENT;  in lookup_tree_block_ref()
722 	ret = btrfs_insert_empty_item(trans, trans->fs_info->extent_root,  in insert_tree_block_ref()
750 		if (!path->nodes[level])  in find_next_key()
752 		if (path->slots[level] + 1 >=  in find_next_key()
753 		    btrfs_header_nritems(path->nodes[level]))  in find_next_key()
756 			btrfs_item_key_to_cpu(path->nodes[level], key,  in find_next_key()
757 					      path->slots[level] + 1);  in find_next_key()
759 			btrfs_node_key_to_cpu(path->nodes[level], key,  in find_next_key()
760 					      path->slots[level] + 1);  in find_next_key()
771  * should be inserted, and -ENOENT is returned.
774  * points to the extent item, and -EAGAIN is returned.
787 	struct btrfs_fs_info *fs_info = trans->fs_info;  in lookup_inline_extent_backref()
788 	struct btrfs_root *root = fs_info->extent_root;  in lookup_inline_extent_backref()
812 		path->keep_locks = 1;  in lookup_inline_extent_backref()
814 		extra_size = -1;  in lookup_inline_extent_backref()
838 		if (path->slots[0]) {  in lookup_inline_extent_backref()
839 			path->slots[0]--;  in lookup_inline_extent_backref()
840 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in lookup_inline_extent_backref()
841 					      path->slots[0]);  in lookup_inline_extent_backref()
857 		err = -ENOENT;  in lookup_inline_extent_backref()
860 		err = -EIO;  in lookup_inline_extent_backref()
864 	leaf = path->nodes[0];  in lookup_inline_extent_backref()
865 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in lookup_inline_extent_backref()
867 		err = -EINVAL;  in lookup_inline_extent_backref()
873 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in lookup_inline_extent_backref()
889 	err = -ENOENT;  in lookup_inline_extent_backref()
898 			err = -EUCLEAN;  in lookup_inline_extent_backref()
911 			dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in lookup_inline_extent_backref()
941 	if (err == -ENOENT && insert) {  in lookup_inline_extent_backref()
944 			err = -EAGAIN;  in lookup_inline_extent_backref()
949 		 * there is no corresponding back ref item.  in lookup_inline_extent_backref()
956 			err = -EAGAIN;  in lookup_inline_extent_backref()
963 		path->keep_locks = 0;  in lookup_inline_extent_backref()
989 	leaf = path->nodes[0];  in setup_inline_extent_backref()
990 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in setup_inline_extent_backref()
991 	item_offset = (unsigned long)iref - (unsigned long)ei;  in setup_inline_extent_backref()
998 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in setup_inline_extent_backref()
1006 	end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);  in setup_inline_extent_backref()
1007 	if (ptr < end - size)  in setup_inline_extent_backref()
1009 				      end - size - ptr);  in setup_inline_extent_backref()
1015 		dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in setup_inline_extent_backref()
1044 	if (ret != -ENOENT)  in lookup_extent_backref()
1070 	struct extent_buffer *leaf = path->nodes[0];  in update_inline_extent_backref()
1081 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in update_inline_extent_backref()
1097 		dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in update_inline_extent_backref()
1104 		BUG_ON(refs_to_mod != -1);  in update_inline_extent_backref()
1107 	BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);  in update_inline_extent_backref()
1118 		item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in update_inline_extent_backref()
1123 					      end - ptr - size);  in update_inline_extent_backref()
1124 		item_size -= size;  in update_inline_extent_backref()
1150 			btrfs_crit(trans->fs_info,  in insert_inline_extent_backref()
1155 				btrfs_crit(trans->fs_info,  in insert_inline_extent_backref()
1156 			"path->slots[0]=%d path->nodes[0]:", path->slots[0]);  in insert_inline_extent_backref()
1157 				btrfs_print_leaf(path->nodes[0]);  in insert_inline_extent_backref()
1159 			return -EUCLEAN;  in insert_inline_extent_backref()
1163 	} else if (ret == -ENOENT) {  in insert_inline_extent_backref()
1164 		setup_inline_extent_backref(trans->fs_info, path, iref, parent,  in insert_inline_extent_backref()
1181 		update_inline_extent_backref(path, iref, -refs_to_drop, NULL,  in remove_extent_backref()
1188 		ret = btrfs_del_item(trans, trans->fs_info->extent_root, path);  in remove_extent_backref()
1201 		len -= aligned_start - start;  in btrfs_issue_discard()
1218 		u64 size = sb_start - start;  in btrfs_issue_discard()
1230 			start += sb_end - start;  in btrfs_issue_discard()
1235 			bytes_left = end - start;  in btrfs_issue_discard()
1244 			else if (ret != -EOPNOTSUPP)  in btrfs_issue_discard()
1253 		bytes_left = end - start;  in btrfs_issue_discard()
1284 		num_bytes = end - cur;  in btrfs_discard_extent()
1289 		 * Error can be -ENOMEM, -ENOENT (no such chunk mapping) or  in btrfs_discard_extent()
1290 		 * -EOPNOTSUPP. For any such error, @num_bytes is not updated,  in btrfs_discard_extent()
1296 		stripe = bbio->stripes;  in btrfs_discard_extent()
1297 		for (i = 0; i < bbio->num_stripes; i++, stripe++) {  in btrfs_discard_extent()
1300 			struct btrfs_device *device = stripe->dev;  in btrfs_discard_extent()
1302 			if (!device->bdev) {  in btrfs_discard_extent()
1306 			req_q = bdev_get_queue(device->bdev);  in btrfs_discard_extent()
1310 			if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state))  in btrfs_discard_extent()
1313 			ret = btrfs_issue_discard(device->bdev,  in btrfs_discard_extent()
1314 						  stripe->physical,  in btrfs_discard_extent()
1315 						  stripe->length,  in btrfs_discard_extent()
1319 			} else if (ret != -EOPNOTSUPP) {  in btrfs_discard_extent()
1321 				 * Logic errors or -ENOMEM, or -EIO, but  in btrfs_discard_extent()
1348 	if (ret == -EOPNOTSUPP)  in btrfs_discard_extent()
1353 /* Can return -ENOMEM */
1357 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_inc_extent_ref()
1360 	ASSERT(generic_ref->type != BTRFS_REF_NOT_SET &&  in btrfs_inc_extent_ref()
1361 	       generic_ref->action);  in btrfs_inc_extent_ref()
1362 	BUG_ON(generic_ref->type == BTRFS_REF_METADATA &&  in btrfs_inc_extent_ref()
1363 	       generic_ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID);  in btrfs_inc_extent_ref()
1365 	if (generic_ref->type == BTRFS_REF_METADATA)  in btrfs_inc_extent_ref()
1376  * __btrfs_inc_extent_ref - insert backreference for a given extent
1395  *		    this can be either one of the well-known metadata trees or
1422 	u64 bytenr = node->bytenr;  in __btrfs_inc_extent_ref()
1423 	u64 num_bytes = node->num_bytes;  in __btrfs_inc_extent_ref()
1429 		return -ENOMEM;  in __btrfs_inc_extent_ref()
1431 	path->leave_spinning = 1;  in __btrfs_inc_extent_ref()
1436 	if ((ret < 0 && ret != -EAGAIN) || !ret)  in __btrfs_inc_extent_ref()
1440 	 * Ok we had -EAGAIN which means we didn't have space to insert and  in __btrfs_inc_extent_ref()
1444 	leaf = path->nodes[0];  in __btrfs_inc_extent_ref()
1445 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in __btrfs_inc_extent_ref()
1446 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in __btrfs_inc_extent_ref()
1455 	path->leave_spinning = 1;  in __btrfs_inc_extent_ref()
1485 	ins.objectid = node->bytenr;  in run_delayed_data_ref()
1486 	ins.offset = node->num_bytes;  in run_delayed_data_ref()
1490 	trace_run_delayed_data_ref(trans->fs_info, node, ref, node->action);  in run_delayed_data_ref()
1492 	if (node->type == BTRFS_SHARED_DATA_REF_KEY)  in run_delayed_data_ref()
1493 		parent = ref->parent;  in run_delayed_data_ref()
1494 	ref_root = ref->root;  in run_delayed_data_ref()
1496 	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {  in run_delayed_data_ref()
1498 			flags |= extent_op->flags_to_set;  in run_delayed_data_ref()
1500 						 flags, ref->objectid,  in run_delayed_data_ref()
1501 						 ref->offset, &ins,  in run_delayed_data_ref()
1502 						 node->ref_mod);  in run_delayed_data_ref()
1503 	} else if (node->action == BTRFS_ADD_DELAYED_REF) {  in run_delayed_data_ref()
1505 					     ref->objectid, ref->offset,  in run_delayed_data_ref()
1506 					     node->ref_mod, extent_op);  in run_delayed_data_ref()
1507 	} else if (node->action == BTRFS_DROP_DELAYED_REF) {  in run_delayed_data_ref()
1509 					  ref_root, ref->objectid,  in run_delayed_data_ref()
1510 					  ref->offset, node->ref_mod,  in run_delayed_data_ref()
1523 	if (extent_op->update_flags) {  in __run_delayed_extent_op()
1524 		flags |= extent_op->flags_to_set;  in __run_delayed_extent_op()
1528 	if (extent_op->update_key) {  in __run_delayed_extent_op()
1532 		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);  in __run_delayed_extent_op()
1540 	struct btrfs_fs_info *fs_info = trans->fs_info;  in run_delayed_extent_op()
1548 	int metadata = !extent_op->is_data;  in run_delayed_extent_op()
1558 		return -ENOMEM;  in run_delayed_extent_op()
1560 	key.objectid = head->bytenr;  in run_delayed_extent_op()
1564 		key.offset = extent_op->level;  in run_delayed_extent_op()
1567 		key.offset = head->num_bytes;  in run_delayed_extent_op()
1571 	path->leave_spinning = 1;  in run_delayed_extent_op()
1572 	ret = btrfs_search_slot(trans, fs_info->extent_root, &key, path, 0, 1);  in run_delayed_extent_op()
1579 			if (path->slots[0] > 0) {  in run_delayed_extent_op()
1580 				path->slots[0]--;  in run_delayed_extent_op()
1581 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in run_delayed_extent_op()
1582 						      path->slots[0]);  in run_delayed_extent_op()
1583 				if (key.objectid == head->bytenr &&  in run_delayed_extent_op()
1585 				    key.offset == head->num_bytes)  in run_delayed_extent_op()
1592 				key.objectid = head->bytenr;  in run_delayed_extent_op()
1593 				key.offset = head->num_bytes;  in run_delayed_extent_op()
1598 			err = -EIO;  in run_delayed_extent_op()
1603 	leaf = path->nodes[0];  in run_delayed_extent_op()
1604 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in run_delayed_extent_op()
1607 		err = -EINVAL;  in run_delayed_extent_op()
1613 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in run_delayed_extent_op()
1633 	trace_run_delayed_tree_ref(trans->fs_info, node, ref, node->action);  in run_delayed_tree_ref()
1635 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)  in run_delayed_tree_ref()
1636 		parent = ref->parent;  in run_delayed_tree_ref()
1637 	ref_root = ref->root;  in run_delayed_tree_ref()
1639 	if (node->ref_mod != 1) {  in run_delayed_tree_ref()
1640 		btrfs_err(trans->fs_info,  in run_delayed_tree_ref()
1642 			  node->bytenr, node->ref_mod, node->action, ref_root,  in run_delayed_tree_ref()
1644 		return -EIO;  in run_delayed_tree_ref()
1646 	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {  in run_delayed_tree_ref()
1647 		BUG_ON(!extent_op || !extent_op->update_flags);  in run_delayed_tree_ref()
1649 	} else if (node->action == BTRFS_ADD_DELAYED_REF) {  in run_delayed_tree_ref()
1651 					     ref->level, 0, 1, extent_op);  in run_delayed_tree_ref()
1652 	} else if (node->action == BTRFS_DROP_DELAYED_REF) {  in run_delayed_tree_ref()
1654 					  ref->level, 0, 1, extent_op);  in run_delayed_tree_ref()
1671 			btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);  in run_one_delayed_ref()
1675 	if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||  in run_one_delayed_ref()
1676 	    node->type == BTRFS_SHARED_BLOCK_REF_KEY)  in run_one_delayed_ref()
1679 	else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||  in run_one_delayed_ref()
1680 		 node->type == BTRFS_SHARED_DATA_REF_KEY)  in run_one_delayed_ref()
1686 		btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);  in run_one_delayed_ref()
1695 	if (RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in select_delayed_ref()
1704 	if (!list_empty(&head->ref_add_list))  in select_delayed_ref()
1705 		return list_first_entry(&head->ref_add_list,  in select_delayed_ref()
1708 	ref = rb_entry(rb_first_cached(&head->ref_tree),  in select_delayed_ref()
1710 	ASSERT(list_empty(&ref->add_list));  in select_delayed_ref()
1717 	spin_lock(&delayed_refs->lock);  in unselect_delayed_ref_head()
1718 	head->processing = 0;  in unselect_delayed_ref_head()
1719 	delayed_refs->num_heads_ready++;  in unselect_delayed_ref_head()
1720 	spin_unlock(&delayed_refs->lock);  in unselect_delayed_ref_head()
1727 	struct btrfs_delayed_extent_op *extent_op = head->extent_op;  in cleanup_extent_op()
1732 	if (head->must_insert_reserved) {  in cleanup_extent_op()
1733 		head->extent_op = NULL;  in cleanup_extent_op()
1749 	head->extent_op = NULL;  in run_and_cleanup_extent_op()
1750 	spin_unlock(&head->lock);  in run_and_cleanup_extent_op()
1766 	if (head->total_ref_mod < 0 && head->is_data) {  in btrfs_cleanup_ref_head_accounting()
1767 		spin_lock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1768 		delayed_refs->pending_csums -= head->num_bytes;  in btrfs_cleanup_ref_head_accounting()
1769 		spin_unlock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1770 		nr_items += btrfs_csum_bytes_to_leaves(fs_info, head->num_bytes);  in btrfs_cleanup_ref_head_accounting()
1779 	if (head->total_ref_mod < 0 ||  in btrfs_cleanup_ref_head_accounting()
1780 	    (head->total_ref_mod == 0 && head->must_insert_reserved)) {  in btrfs_cleanup_ref_head_accounting()
1783 		btrfs_mod_total_bytes_pinned(fs_info, flags, -head->num_bytes);  in btrfs_cleanup_ref_head_accounting()
1793 	struct btrfs_fs_info *fs_info = trans->fs_info;  in cleanup_ref_head()
1797 	delayed_refs = &trans->transaction->delayed_refs;  in cleanup_ref_head()
1809 	 * Need to drop our head ref lock and re-acquire the delayed ref lock  in cleanup_ref_head()
1810 	 * and then re-check to make sure nobody got added.  in cleanup_ref_head()
1812 	spin_unlock(&head->lock);  in cleanup_ref_head()
1813 	spin_lock(&delayed_refs->lock);  in cleanup_ref_head()
1814 	spin_lock(&head->lock);  in cleanup_ref_head()
1815 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root) || head->extent_op) {  in cleanup_ref_head()
1816 		spin_unlock(&head->lock);  in cleanup_ref_head()
1817 		spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1821 	spin_unlock(&head->lock);  in cleanup_ref_head()
1822 	spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1824 	if (head->must_insert_reserved) {  in cleanup_ref_head()
1825 		btrfs_pin_extent(trans, head->bytenr, head->num_bytes, 1);  in cleanup_ref_head()
1826 		if (head->is_data) {  in cleanup_ref_head()
1827 			ret = btrfs_del_csums(trans, fs_info->csum_root,  in cleanup_ref_head()
1828 					      head->bytenr, head->num_bytes);  in cleanup_ref_head()
1844 		&trans->transaction->delayed_refs;  in btrfs_obtain_ref_head()
1848 	spin_lock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1851 		spin_unlock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1860 	spin_unlock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1867 	if (ret == -EAGAIN)  in btrfs_obtain_ref_head()
1868 		head = ERR_PTR(-EAGAIN);  in btrfs_obtain_ref_head()
1877 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs_for_head()
1884 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs_for_head()
1886 	lockdep_assert_held(&locked_ref->mutex);  in btrfs_run_delayed_refs_for_head()
1887 	lockdep_assert_held(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1890 		if (ref->seq &&  in btrfs_run_delayed_refs_for_head()
1891 		    btrfs_check_delayed_seq(fs_info, ref->seq)) {  in btrfs_run_delayed_refs_for_head()
1892 			spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1894 			return -EAGAIN;  in btrfs_run_delayed_refs_for_head()
1898 		ref->in_tree = 0;  in btrfs_run_delayed_refs_for_head()
1899 		rb_erase_cached(&ref->ref_node, &locked_ref->ref_tree);  in btrfs_run_delayed_refs_for_head()
1900 		RB_CLEAR_NODE(&ref->ref_node);  in btrfs_run_delayed_refs_for_head()
1901 		if (!list_empty(&ref->add_list))  in btrfs_run_delayed_refs_for_head()
1902 			list_del(&ref->add_list);  in btrfs_run_delayed_refs_for_head()
1907 		switch (ref->action) {  in btrfs_run_delayed_refs_for_head()
1910 			locked_ref->ref_mod -= ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1913 			locked_ref->ref_mod += ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1918 		atomic_dec(&delayed_refs->num_entries);  in btrfs_run_delayed_refs_for_head()
1924 		must_insert_reserved = locked_ref->must_insert_reserved;  in btrfs_run_delayed_refs_for_head()
1925 		locked_ref->must_insert_reserved = 0;  in btrfs_run_delayed_refs_for_head()
1927 		extent_op = locked_ref->extent_op;  in btrfs_run_delayed_refs_for_head()
1928 		locked_ref->extent_op = NULL;  in btrfs_run_delayed_refs_for_head()
1929 		spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1946 		spin_lock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1955  * Returns -ENOMEM or -EIO on failure and will abort the transaction.
1960 	struct btrfs_fs_info *fs_info = trans->fs_info;  in __btrfs_run_delayed_refs()
1968 	delayed_refs = &trans->transaction->delayed_refs;  in __btrfs_run_delayed_refs()
1973 				if (PTR_ERR(locked_ref) == -EAGAIN) {  in __btrfs_run_delayed_refs()
1985 		 * finish.  If we merged anything we need to re-loop so we can  in __btrfs_run_delayed_refs()
1993 		spin_lock(&locked_ref->lock);  in __btrfs_run_delayed_refs()
1998 		if (ret < 0 && ret != -EAGAIN) {  in __btrfs_run_delayed_refs()
2021 		 * returned -EAGAIN, meaning we need to select another head  in __btrfs_run_delayed_refs()
2026 	} while ((nr != -1 && count < nr) || locked_ref);  in __btrfs_run_delayed_refs()
2031 	 * accounting, no actual extent tree updates.  in __btrfs_run_delayed_refs()
2041 		spin_lock(&delayed_refs->lock);  in __btrfs_run_delayed_refs()
2042 		avg = fs_info->avg_delayed_ref_runtime * 3 + runtime;  in __btrfs_run_delayed_refs()
2043 		fs_info->avg_delayed_ref_runtime = avg >> 2;	/* div by 4 */  in __btrfs_run_delayed_refs()
2044 		spin_unlock(&delayed_refs->lock);  in __btrfs_run_delayed_refs()
2057 	struct rb_node *n = root->rb_node;  in find_middle()
2066 		first = entry->bytenr;  in find_middle()
2071 		last = entry->bytenr;  in find_middle()
2073 	n = root->rb_node;  in find_middle()
2077 		WARN_ON(!entry->in_tree);  in find_middle()
2079 		middle = entry->bytenr;  in find_middle()
2082 			n = n->rb_left;  in find_middle()
2084 			n = n->rb_right;  in find_middle()
2086 		alt = 1 - alt;  in find_middle()
2104 			(u64)btrfs_super_csum_size(fs_info->super_copy));  in btrfs_csum_bytes_to_leaves()
2105 	num_csums = div64_u64(csum_bytes, fs_info->sectorsize);  in btrfs_csum_bytes_to_leaves()
2106 	num_csums += num_csums_per_leaf - 1;  in btrfs_csum_bytes_to_leaves()
2124 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs()
2129 	int run_all = count == (unsigned long)-1;  in btrfs_run_delayed_refs()
2135 	if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags))  in btrfs_run_delayed_refs()
2138 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs()
2140 		count = atomic_read(&delayed_refs->num_entries) * 2;  in btrfs_run_delayed_refs()
2144 	delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);  in btrfs_run_delayed_refs()
2155 		spin_lock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2156 		node = rb_first_cached(&delayed_refs->href_root);  in btrfs_run_delayed_refs()
2158 			spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2163 		refcount_inc(&head->refs);  in btrfs_run_delayed_refs()
2164 		spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2167 		mutex_lock(&head->mutex);  in btrfs_run_delayed_refs()
2168 		mutex_unlock(&head->mutex);  in btrfs_run_delayed_refs()
2187 		return -ENOMEM;  in btrfs_set_disk_extent_flags()
2189 	extent_op->flags_to_set = flags;  in btrfs_set_disk_extent_flags()
2190 	extent_op->update_flags = true;  in btrfs_set_disk_extent_flags()
2191 	extent_op->update_key = false;  in btrfs_set_disk_extent_flags()
2192 	extent_op->is_data = is_data ? true : false;  in btrfs_set_disk_extent_flags()
2193 	extent_op->level = level;  in btrfs_set_disk_extent_flags()
2195 	ret = btrfs_add_delayed_extent_op(trans, eb->start, eb->len, extent_op);  in btrfs_set_disk_extent_flags()
2213 	spin_lock(&root->fs_info->trans_lock);  in check_delayed_ref()
2214 	cur_trans = root->fs_info->running_transaction;  in check_delayed_ref()
2216 		refcount_inc(&cur_trans->use_count);  in check_delayed_ref()
2217 	spin_unlock(&root->fs_info->trans_lock);  in check_delayed_ref()
2221 	delayed_refs = &cur_trans->delayed_refs;  in check_delayed_ref()
2222 	spin_lock(&delayed_refs->lock);  in check_delayed_ref()
2225 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2230 	if (!mutex_trylock(&head->mutex)) {  in check_delayed_ref()
2231 		refcount_inc(&head->refs);  in check_delayed_ref()
2232 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2240 		mutex_lock(&head->mutex);  in check_delayed_ref()
2241 		mutex_unlock(&head->mutex);  in check_delayed_ref()
2244 		return -EAGAIN;  in check_delayed_ref()
2246 	spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2248 	spin_lock(&head->lock);  in check_delayed_ref()
2253 	for (node = rb_first_cached(&head->ref_tree); node;  in check_delayed_ref()
2257 		if (ref->type != BTRFS_EXTENT_DATA_REF_KEY) {  in check_delayed_ref()
2268 		if (data_ref->root != root->root_key.objectid ||  in check_delayed_ref()
2269 		    data_ref->objectid != objectid ||  in check_delayed_ref()
2270 		    data_ref->offset != offset) {  in check_delayed_ref()
2275 	spin_unlock(&head->lock);  in check_delayed_ref()
2276 	mutex_unlock(&head->mutex);  in check_delayed_ref()
2286 	struct btrfs_fs_info *fs_info = root->fs_info;  in check_committed_ref()
2287 	struct btrfs_root *extent_root = fs_info->extent_root;  in check_committed_ref()
2298 	key.offset = (u64)-1;  in check_committed_ref()
2306 	ret = -ENOENT;  in check_committed_ref()
2307 	if (path->slots[0] == 0)  in check_committed_ref()
2310 	path->slots[0]--;  in check_committed_ref()
2311 	leaf = path->nodes[0];  in check_committed_ref()
2312 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in check_committed_ref()
2318 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in check_committed_ref()
2319 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in check_committed_ref()
2332 	     btrfs_root_last_snapshot(&root->root_item)))  in check_committed_ref()
2342 	ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in check_committed_ref()
2346 	    root->root_key.objectid ||  in check_committed_ref()
2364 		return -ENOMEM;  in btrfs_cross_ref_exist()
2369 		if (ret && ret != -ENOENT)  in btrfs_cross_ref_exist()
2373 	} while (ret == -EAGAIN);  in btrfs_cross_ref_exist()
2377 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in btrfs_cross_ref_exist()
2387 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_mod_ref()
2409 	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && level == 0)  in __btrfs_mod_ref()
2413 		parent = buf->start;  in __btrfs_mod_ref()
2436 			key.offset -= btrfs_file_extent_offset(buf, fi);  in __btrfs_mod_ref()
2439 			generic_ref.real_root = root->root_key.objectid;  in __btrfs_mod_ref()
2451 			num_bytes = fs_info->nodesize;  in __btrfs_mod_ref()
2454 			generic_ref.real_root = root->root_key.objectid;  in __btrfs_mod_ref()
2455 			btrfs_init_tree_ref(&generic_ref, level - 1, ref_root);  in __btrfs_mod_ref()
2488 	if (!block_group || block_group->ro)  in btrfs_extent_readonly()
2497 	struct btrfs_fs_info *fs_info = root->fs_info;  in get_alloc_profile_by_root()
2503 	else if (root == fs_info->chunk_root)  in get_alloc_profile_by_root()
2517 	spin_lock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2518 	bytenr = fs_info->first_logical_byte;  in first_logical_byte()
2519 	spin_unlock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2521 	if (bytenr < (u64)-1)  in first_logical_byte()
2528 	bytenr = cache->start;  in first_logical_byte()
2538 	struct btrfs_fs_info *fs_info = cache->fs_info;  in pin_down_extent()
2540 	spin_lock(&cache->space_info->lock);  in pin_down_extent()
2541 	spin_lock(&cache->lock);  in pin_down_extent()
2542 	cache->pinned += num_bytes;  in pin_down_extent()
2543 	btrfs_space_info_update_bytes_pinned(fs_info, cache->space_info,  in pin_down_extent()
2546 		cache->reserved -= num_bytes;  in pin_down_extent()
2547 		cache->space_info->bytes_reserved -= num_bytes;  in pin_down_extent()
2549 	spin_unlock(&cache->lock);  in pin_down_extent()
2550 	spin_unlock(&cache->space_info->lock);  in pin_down_extent()
2552 	__btrfs_mod_total_bytes_pinned(cache->space_info, num_bytes);  in pin_down_extent()
2553 	set_extent_dirty(&trans->transaction->pinned_extents, bytenr,  in pin_down_extent()
2554 			 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);  in pin_down_extent()
2563 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent()
2581 	btrfs_add_excluded_extent(trans->fs_info, bytenr, num_bytes);  in btrfs_pin_extent_for_log_replay()
2583 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent_for_log_replay()
2585 		return -EINVAL;  in btrfs_pin_extent_for_log_replay()
2612 		return -EINVAL;  in __exclude_logged_extent()
2622 		mutex_lock(&caching_ctl->mutex);  in __exclude_logged_extent()
2624 		if (start >= caching_ctl->progress) {  in __exclude_logged_extent()
2627 		} else if (start + num_bytes <= caching_ctl->progress) {  in __exclude_logged_extent()
2631 			num_bytes = caching_ctl->progress - start;  in __exclude_logged_extent()
2637 			num_bytes = (start + num_bytes) -  in __exclude_logged_extent()
2638 				caching_ctl->progress;  in __exclude_logged_extent()
2639 			start = caching_ctl->progress;  in __exclude_logged_extent()
2644 		mutex_unlock(&caching_ctl->mutex);  in __exclude_logged_extent()
2653 	struct btrfs_fs_info *fs_info = eb->fs_info;  in btrfs_exclude_logged_extents()
2686 	atomic_inc(&bg->reservations);  in btrfs_inc_block_group_reservations()
2703 	if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {  in fetch_cluster_info()
2704 		ret = &fs_info->meta_alloc_cluster;  in fetch_cluster_info()
2709 	} else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) &&  in fetch_cluster_info()
2712 		ret = &fs_info->data_alloc_cluster;  in fetch_cluster_info()
2724 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in unpin_extent_range()
2734 		    start >= cache->start + cache->length) {  in unpin_extent_range()
2742 						     cache->space_info,  in unpin_extent_range()
2747 		len = cache->start + cache->length - start;  in unpin_extent_range()
2748 		len = min(len, end + 1 - start);  in unpin_extent_range()
2750 		if (start < cache->last_byte_to_unpin && return_free_space) {  in unpin_extent_range()
2751 			u64 add_len = min(len, cache->last_byte_to_unpin - start);  in unpin_extent_range()
2758 		space_info = cache->space_info;  in unpin_extent_range()
2766 		if (cluster && cluster->fragmented &&  in unpin_extent_range()
2768 			spin_lock(&cluster->lock);  in unpin_extent_range()
2769 			cluster->fragmented = 0;  in unpin_extent_range()
2770 			spin_unlock(&cluster->lock);  in unpin_extent_range()
2773 		spin_lock(&space_info->lock);  in unpin_extent_range()
2774 		spin_lock(&cache->lock);  in unpin_extent_range()
2775 		cache->pinned -= len;  in unpin_extent_range()
2776 		btrfs_space_info_update_bytes_pinned(fs_info, space_info, -len);  in unpin_extent_range()
2777 		space_info->max_extent_size = 0;  in unpin_extent_range()
2778 		__btrfs_mod_total_bytes_pinned(space_info, -len);  in unpin_extent_range()
2779 		if (cache->ro) {  in unpin_extent_range()
2780 			space_info->bytes_readonly += len;  in unpin_extent_range()
2783 		spin_unlock(&cache->lock);  in unpin_extent_range()
2785 		    global_rsv->space_info == space_info) {  in unpin_extent_range()
2788 			spin_lock(&global_rsv->lock);  in unpin_extent_range()
2789 			if (!global_rsv->full) {  in unpin_extent_range()
2790 				to_add = min(len, global_rsv->size -  in unpin_extent_range()
2791 					     global_rsv->reserved);  in unpin_extent_range()
2792 				global_rsv->reserved += to_add;  in unpin_extent_range()
2795 				if (global_rsv->reserved >= global_rsv->size)  in unpin_extent_range()
2796 					global_rsv->full = 1;  in unpin_extent_range()
2797 				len -= to_add;  in unpin_extent_range()
2799 			spin_unlock(&global_rsv->lock);  in unpin_extent_range()
2804 		spin_unlock(&space_info->lock);  in unpin_extent_range()
2814 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_finish_extent_commit()
2822 	unpin = &trans->transaction->pinned_extents;  in btrfs_finish_extent_commit()
2827 		mutex_lock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2831 			mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2834 		if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))  in btrfs_finish_extent_commit()
2835 			clear_extent_bits(&fs_info->excluded_extents, start,  in btrfs_finish_extent_commit()
2840 						   end + 1 - start, NULL);  in btrfs_finish_extent_commit()
2844 		mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2850 		btrfs_discard_calc_delay(&fs_info->discard_ctl);  in btrfs_finish_extent_commit()
2851 		btrfs_discard_schedule_work(&fs_info->discard_ctl, true);  in btrfs_finish_extent_commit()
2859 	deleted_bgs = &trans->transaction->deleted_bgs;  in btrfs_finish_extent_commit()
2863 		ret = -EROFS;  in btrfs_finish_extent_commit()
2866 						   block_group->start,  in btrfs_finish_extent_commit()
2867 						   block_group->length,  in btrfs_finish_extent_commit()
2870 		list_del_init(&block_group->bg_list);  in btrfs_finish_extent_commit()
2905  *    node->bytenr = 13631488
2906  *    node->num_bytes = 1048576
2930  *    node->bytenr = 13631488
2931  *    node->num_bytes = 1048576
2950 	struct btrfs_fs_info *info = trans->fs_info;  in __btrfs_free_extent()
2953 	struct btrfs_root *extent_root = info->extent_root;  in __btrfs_free_extent()
2964 	u64 bytenr = node->bytenr;  in __btrfs_free_extent()
2965 	u64 num_bytes = node->num_bytes;  in __btrfs_free_extent()
2971 		return -ENOMEM;  in __btrfs_free_extent()
2973 	path->leave_spinning = 1;  in __btrfs_free_extent()
2980 			   node->bytenr, refs_to_drop);  in __btrfs_free_extent()
2981 		ret = -EINVAL;  in __btrfs_free_extent()
3000 		extent_slot = path->slots[0];  in __btrfs_free_extent()
3002 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3018 			if (path->slots[0] - extent_slot > 5)  in __btrfs_free_extent()
3020 			extent_slot--;  in __btrfs_free_extent()
3026 "invalid iref, no EXTENT/METADATA_ITEM found but has inline extent ref");  in __btrfs_free_extent()
3027 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3039 			path->leave_spinning = 1;  in __btrfs_free_extent()
3052 						&key, path, -1, 1);  in __btrfs_free_extent()
3053 			if (ret > 0 && skinny_metadata && path->slots[0]) {  in __btrfs_free_extent()
3058 				path->slots[0]--;  in __btrfs_free_extent()
3059 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3060 						      path->slots[0]);  in __btrfs_free_extent()
3074 							&key, path, -1, 1);  in __btrfs_free_extent()
3082 					btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3088 			extent_slot = path->slots[0];  in __btrfs_free_extent()
3090 	} else if (WARN_ON(ret == -ENOENT)) {  in __btrfs_free_extent()
3091 		btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3103 	leaf = path->nodes[0];  in __btrfs_free_extent()
3106 		ret = -EINVAL;  in __btrfs_free_extent()
3122 			btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3134 		btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3137 	refs -= refs_to_drop;  in __btrfs_free_extent()
3149 "invalid iref, got inlined extent ref but no EXTENT/METADATA_ITEM found");  in __btrfs_free_extent()
3150 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3175 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3179 				if (path->slots[0] != extent_slot) {  in __btrfs_free_extent()
3184 					btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3189 				 * No inline ref, we must be at SHARED_* item,  in __btrfs_free_extent()
3194 				if (path->slots[0] != extent_slot + 1) {  in __btrfs_free_extent()
3197 					btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3200 				path->slots[0] = extent_slot;  in __btrfs_free_extent()
3206 		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],  in __btrfs_free_extent()
3215 			ret = btrfs_del_csums(trans, info->csum_root, bytenr,  in __btrfs_free_extent()
3246 		btrfs_crit(info, "path->slots[0]=%d extent_slot=%d",  in __btrfs_free_extent()
3247 			   path->slots[0], extent_slot);  in __btrfs_free_extent()
3248 		btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3252 	return -EUCLEAN;  in __btrfs_free_extent()
3258  * a given extent, and if there are no other delayed refs to be processed, it
3268 	delayed_refs = &trans->transaction->delayed_refs;  in check_ref_cleanup()
3269 	spin_lock(&delayed_refs->lock);  in check_ref_cleanup()
3274 	spin_lock(&head->lock);  in check_ref_cleanup()
3275 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in check_ref_cleanup()
3285 	if (!mutex_trylock(&head->mutex))  in check_ref_cleanup()
3289 	head->processing = 0;  in check_ref_cleanup()
3291 	spin_unlock(&head->lock);  in check_ref_cleanup()
3292 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3294 	BUG_ON(head->extent_op);  in check_ref_cleanup()
3295 	if (head->must_insert_reserved)  in check_ref_cleanup()
3298 	btrfs_cleanup_ref_head_accounting(trans->fs_info, delayed_refs, head);  in check_ref_cleanup()
3299 	mutex_unlock(&head->mutex);  in check_ref_cleanup()
3303 	spin_unlock(&head->lock);  in check_ref_cleanup()
3306 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3315 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_free_tree_block()
3320 			       buf->start, buf->len, parent);  in btrfs_free_tree_block()
3322 			    root->root_key.objectid);  in btrfs_free_tree_block()
3324 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_tree_block()
3327 		BUG_ON(ret); /* -ENOMEM */  in btrfs_free_tree_block()
3330 	if (last_ref && btrfs_header_generation(buf) == trans->transid) {  in btrfs_free_tree_block()
3333 		if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_tree_block()
3334 			ret = check_ref_cleanup(trans, buf->start);  in btrfs_free_tree_block()
3339 		cache = btrfs_lookup_block_group(fs_info, buf->start);  in btrfs_free_tree_block()
3342 			pin_down_extent(trans, cache, buf->start, buf->len, 1);  in btrfs_free_tree_block()
3347 		WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));  in btrfs_free_tree_block()
3349 		btrfs_add_free_space(cache, buf->start, buf->len);  in btrfs_free_tree_block()
3350 		btrfs_free_reserved_bytes(cache, buf->len, 0);  in btrfs_free_tree_block()
3352 		trace_btrfs_reserved_extent_free(fs_info, buf->start, buf->len);  in btrfs_free_tree_block()
3360 		clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);  in btrfs_free_tree_block()
3364 /* Can return -ENOMEM */
3367 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_free_extent()
3377 	if ((ref->type == BTRFS_REF_METADATA &&  in btrfs_free_extent()
3378 	     ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID) ||  in btrfs_free_extent()
3379 	    (ref->type == BTRFS_REF_DATA &&  in btrfs_free_extent()
3380 	     ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)) {  in btrfs_free_extent()
3382 		btrfs_pin_extent(trans, ref->bytenr, ref->len, 1);  in btrfs_free_extent()
3384 	} else if (ref->type == BTRFS_REF_METADATA) {  in btrfs_free_extent()
3390 	if (!((ref->type == BTRFS_REF_METADATA &&  in btrfs_free_extent()
3391 	       ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID) ||  in btrfs_free_extent()
3392 	      (ref->type == BTRFS_REF_DATA &&  in btrfs_free_extent()
3393 	       ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)))  in btrfs_free_extent()
3411 		down_read(&cache->data_rwsem);  in btrfs_lock_block_group()
3419 		down_read(&cache->data_rwsem);  in btrfs_grab_block_group()
3426 	__acquires(&cluster->refill_lock)  in btrfs_lock_cluster()
3430 	spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3432 		used_bg = cluster->block_group;  in btrfs_lock_cluster()
3444 		if (down_read_trylock(&used_bg->data_rwsem))  in btrfs_lock_cluster()
3447 		spin_unlock(&cluster->refill_lock);  in btrfs_lock_cluster()
3449 		/* We should only have one-level nested. */  in btrfs_lock_cluster()
3450 		down_read_nested(&used_bg->data_rwsem, SINGLE_DEPTH_NESTING);  in btrfs_lock_cluster()
3452 		spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3453 		if (used_bg == cluster->block_group)  in btrfs_lock_cluster()
3456 		up_read(&used_bg->data_rwsem);  in btrfs_lock_cluster()
3466 		up_read(&cache->data_rwsem);  in btrfs_release_block_group()
3505 	 * Whether we're refilling a cluster, if true we need to re-search
3511 	 * Whether we're updating free space cache, if true we need to re-search
3539  * Return -ENOENT to inform caller that we need fallback to unclustered mode.
3540  * Return -EAGAIN to inform caller that we need to re-search this block group
3542  * Return 0 means we have found a location and set ffe_ctl->found_offset.
3549 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_clustered()
3554 	cluster_bg = btrfs_lock_cluster(bg, last_ptr, ffe_ctl->delalloc);  in find_free_extent_clustered()
3557 	if (cluster_bg != bg && (cluster_bg->ro ||  in find_free_extent_clustered()
3558 	    !block_group_bits(cluster_bg, ffe_ctl->flags)))  in find_free_extent_clustered()
3562 			ffe_ctl->num_bytes, cluster_bg->start,  in find_free_extent_clustered()
3563 			&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3566 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3568 				ffe_ctl->search_start, ffe_ctl->num_bytes);  in find_free_extent_clustered()
3570 		ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3573 	WARN_ON(last_ptr->block_group != cluster_bg);  in find_free_extent_clustered()
3587 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE && cluster_bg != bg) {  in find_free_extent_clustered()
3588 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3589 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3590 		return -ENOENT;  in find_free_extent_clustered()
3597 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3600 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE) {  in find_free_extent_clustered()
3601 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3602 		return -ENOENT;  in find_free_extent_clustered()
3606 			ffe_ctl->empty_cluster + ffe_ctl->empty_size,  in find_free_extent_clustered()
3607 			bg->full_stripe_len);  in find_free_extent_clustered()
3608 	ret = btrfs_find_space_cluster(bg, last_ptr, ffe_ctl->search_start,  in find_free_extent_clustered()
3609 			ffe_ctl->num_bytes, aligned_cluster);  in find_free_extent_clustered()
3613 				ffe_ctl->num_bytes, ffe_ctl->search_start,  in find_free_extent_clustered()
3614 				&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3617 			spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3619 					ffe_ctl->search_start,  in find_free_extent_clustered()
3620 					ffe_ctl->num_bytes);  in find_free_extent_clustered()
3621 			ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3624 	} else if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&  in find_free_extent_clustered()
3625 		   !ffe_ctl->retry_clustered) {  in find_free_extent_clustered()
3626 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3628 		ffe_ctl->retry_clustered = true;  in find_free_extent_clustered()
3629 		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +  in find_free_extent_clustered()
3630 				ffe_ctl->empty_cluster + ffe_ctl->empty_size);  in find_free_extent_clustered()
3631 		return -EAGAIN;  in find_free_extent_clustered()
3639 	spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3645  * Return 0 when we found an free extent and set ffe_ctrl->found_offset
3646  * Return -EAGAIN to inform caller that we need to re-search this block group
3651 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_unclustered()
3660 		spin_lock(&last_ptr->lock);  in find_free_extent_unclustered()
3661 		last_ptr->fragmented = 1;  in find_free_extent_unclustered()
3662 		spin_unlock(&last_ptr->lock);  in find_free_extent_unclustered()
3664 	if (ffe_ctl->cached) {  in find_free_extent_unclustered()
3667 		free_space_ctl = bg->free_space_ctl;  in find_free_extent_unclustered()
3668 		spin_lock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3669 		if (free_space_ctl->free_space <  in find_free_extent_unclustered()
3670 		    ffe_ctl->num_bytes + ffe_ctl->empty_cluster +  in find_free_extent_unclustered()
3671 		    ffe_ctl->empty_size) {  in find_free_extent_unclustered()
3672 			ffe_ctl->total_free_space = max_t(u64,  in find_free_extent_unclustered()
3673 					ffe_ctl->total_free_space,  in find_free_extent_unclustered()
3674 					free_space_ctl->free_space);  in find_free_extent_unclustered()
3675 			spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3678 		spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3681 	offset = btrfs_find_space_for_alloc(bg, ffe_ctl->search_start,  in find_free_extent_unclustered()
3682 			ffe_ctl->num_bytes, ffe_ctl->empty_size,  in find_free_extent_unclustered()
3683 			&ffe_ctl->max_extent_size);  in find_free_extent_unclustered()
3694 	if (!offset && !ffe_ctl->retry_unclustered && !ffe_ctl->cached &&  in find_free_extent_unclustered()
3695 	    ffe_ctl->loop > LOOP_CACHING_NOWAIT) {  in find_free_extent_unclustered()
3696 		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +  in find_free_extent_unclustered()
3697 						      ffe_ctl->empty_size);  in find_free_extent_unclustered()
3698 		ffe_ctl->retry_unclustered = true;  in find_free_extent_unclustered()
3699 		return -EAGAIN;  in find_free_extent_unclustered()
3703 	ffe_ctl->found_offset = offset;  in find_free_extent_unclustered()
3714 	if (ffe_ctl->last_ptr && ffe_ctl->use_cluster) {  in do_allocation_clustered()
3716 		if (ret >= 0 || ret == -EAGAIN)  in do_allocation_clustered()
3718 		/* ret == -ENOENT case falls through */  in do_allocation_clustered()
3728 	switch (ffe_ctl->policy) {  in do_allocation()
3740 	switch (ffe_ctl->policy) {  in release_block_group()
3742 		ffe_ctl->retry_clustered = false;  in release_block_group()
3743 		ffe_ctl->retry_unclustered = false;  in release_block_group()
3749 	BUG_ON(btrfs_bg_flags_to_raid_index(block_group->flags) !=  in release_block_group()
3750 	       ffe_ctl->index);  in release_block_group()
3757 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in found_extent_clustered()
3759 	if (!ffe_ctl->use_cluster && last_ptr) {  in found_extent_clustered()
3760 		spin_lock(&last_ptr->lock);  in found_extent_clustered()
3761 		last_ptr->window_start = ins->objectid;  in found_extent_clustered()
3762 		spin_unlock(&last_ptr->lock);  in found_extent_clustered()
3769 	switch (ffe_ctl->policy) {  in found_extent()
3780 	switch (ffe_ctl->policy) {  in chunk_allocation_failed()
3786 		ffe_ctl->loop = LOOP_NO_EMPTY_SIZE;  in chunk_allocation_failed()
3794  * Return >0 means caller needs to re-search for free extent
3803 	struct btrfs_root *root = fs_info->extent_root;  in find_free_extent_update_loop()
3806 	if ((ffe_ctl->loop == LOOP_CACHING_NOWAIT) &&  in find_free_extent_update_loop()
3807 	    ffe_ctl->have_caching_bg && !ffe_ctl->orig_have_caching_bg)  in find_free_extent_update_loop()
3808 		ffe_ctl->orig_have_caching_bg = true;  in find_free_extent_update_loop()
3810 	if (!ins->objectid && ffe_ctl->loop >= LOOP_CACHING_WAIT &&  in find_free_extent_update_loop()
3811 	    ffe_ctl->have_caching_bg)  in find_free_extent_update_loop()
3814 	if (!ins->objectid && ++(ffe_ctl->index) < BTRFS_NR_RAID_TYPES)  in find_free_extent_update_loop()
3817 	if (ins->objectid) {  in find_free_extent_update_loop()
3830 	if (ffe_ctl->loop < LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
3831 		ffe_ctl->index = 0;  in find_free_extent_update_loop()
3832 		if (ffe_ctl->loop == LOOP_CACHING_NOWAIT) {  in find_free_extent_update_loop()
3838 			if (ffe_ctl->orig_have_caching_bg || !full_search)  in find_free_extent_update_loop()
3839 				ffe_ctl->loop = LOOP_CACHING_WAIT;  in find_free_extent_update_loop()
3841 				ffe_ctl->loop = LOOP_ALLOC_CHUNK;  in find_free_extent_update_loop()
3843 			ffe_ctl->loop++;  in find_free_extent_update_loop()
3846 		if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {  in find_free_extent_update_loop()
3850 			trans = current->journal_info;  in find_free_extent_update_loop()
3861 			ret = btrfs_chunk_alloc(trans, ffe_ctl->flags,  in find_free_extent_update_loop()
3865 			if (ret == -ENOSPC)  in find_free_extent_update_loop()
3877 		if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
3878 			if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)  in find_free_extent_update_loop()
3879 				return -ENOSPC;  in find_free_extent_update_loop()
3882 			 * Don't loop again if we already have no empty_size and  in find_free_extent_update_loop()
3883 			 * no empty_cluster.  in find_free_extent_update_loop()
3885 			if (ffe_ctl->empty_size == 0 &&  in find_free_extent_update_loop()
3886 			    ffe_ctl->empty_cluster == 0)  in find_free_extent_update_loop()
3887 				return -ENOSPC;  in find_free_extent_update_loop()
3888 			ffe_ctl->empty_size = 0;  in find_free_extent_update_loop()
3889 			ffe_ctl->empty_cluster = 0;  in find_free_extent_update_loop()
3893 	return -ENOSPC;  in find_free_extent_update_loop()
3911 	if (space_info->max_extent_size) {  in prepare_allocation_clustered()
3912 		spin_lock(&space_info->lock);  in prepare_allocation_clustered()
3913 		if (space_info->max_extent_size &&  in prepare_allocation_clustered()
3914 		    ffe_ctl->num_bytes > space_info->max_extent_size) {  in prepare_allocation_clustered()
3915 			ins->offset = space_info->max_extent_size;  in prepare_allocation_clustered()
3916 			spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
3917 			return -ENOSPC;  in prepare_allocation_clustered()
3918 		} else if (space_info->max_extent_size) {  in prepare_allocation_clustered()
3919 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
3921 		spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
3924 	ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,  in prepare_allocation_clustered()
3925 					       &ffe_ctl->empty_cluster);  in prepare_allocation_clustered()
3926 	if (ffe_ctl->last_ptr) {  in prepare_allocation_clustered()
3927 		struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in prepare_allocation_clustered()
3929 		spin_lock(&last_ptr->lock);  in prepare_allocation_clustered()
3930 		if (last_ptr->block_group)  in prepare_allocation_clustered()
3931 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
3932 		if (last_ptr->fragmented) {  in prepare_allocation_clustered()
3938 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
3939 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
3941 		spin_unlock(&last_ptr->lock);  in prepare_allocation_clustered()
3952 	switch (ffe_ctl->policy) {  in prepare_allocation()
3964  * ins->objectid == start position
3965  * ins->flags = BTRFS_EXTENT_ITEM_KEY
3966  * ins->offset == the size of the hole.
3969  * If there is no suitable free space, we will record the max size of
3975  * |- Iterate through all block groups
3976  * |  |- Get a valid block group
3977  * |  |- Try to do clustered allocation in that block group
3978  * |  |- Try to do unclustered allocation in that block group
3979  * |  |- Check if the result is valid
3980  * |  |  |- If valid, then exit
3981  * |  |- Jump to next block group
3983  * |- Push harder to find free extents
3984  *    |- If not found, re-iterate all block groups
3991 	struct btrfs_fs_info *fs_info = root->fs_info;  in find_free_extent()
3999 	WARN_ON(num_bytes < fs_info->sectorsize);  in find_free_extent()
4019 	ins->type = BTRFS_EXTENT_ITEM_KEY;  in find_free_extent()
4020 	ins->objectid = 0;  in find_free_extent()
4021 	ins->offset = 0;  in find_free_extent()
4027 		btrfs_err(fs_info, "No space info for %llu", flags);  in find_free_extent()
4028 		return -ENOSPC;  in find_free_extent()
4045 		 * However if we are re-searching with an ideal block group  in find_free_extent()
4049 		    block_group->cached != BTRFS_CACHE_NO) {  in find_free_extent()
4050 			down_read(&space_info->groups_sem);  in find_free_extent()
4051 			if (list_empty(&block_group->list) ||  in find_free_extent()
4052 			    block_group->ro) {  in find_free_extent()
4060 				up_read(&space_info->groups_sem);  in find_free_extent()
4063 						block_group->flags);  in find_free_extent()
4076 	down_read(&space_info->groups_sem);  in find_free_extent()
4078 			    &space_info->block_groups[ffe_ctl.index], list) {  in find_free_extent()
4081 		/* If the block group is read-only, we can skip it entirely. */  in find_free_extent()
4082 		if (unlikely(block_group->ro))  in find_free_extent()
4086 		ffe_ctl.search_start = block_group->start;  in find_free_extent()
4104 			if ((flags & extra) && !(block_group->flags & extra))  in find_free_extent()
4109 			 * It's possible that we have MIXED_GROUP flag but no  in find_free_extent()
4138 		if (unlikely(block_group->cached == BTRFS_CACHE_ERROR))  in find_free_extent()
4148 		} else if (ret == -EAGAIN) {  in find_free_extent()
4156 					     fs_info->stripesize);  in find_free_extent()
4160 		    block_group->start + block_group->length) {  in find_free_extent()
4168 				ffe_ctl.search_start - ffe_ctl.found_offset);  in find_free_extent()
4172 		if (ret == -EAGAIN) {  in find_free_extent()
4180 		ins->objectid = ffe_ctl.search_start;  in find_free_extent()
4181 		ins->offset = num_bytes;  in find_free_extent()
4191 	up_read(&space_info->groups_sem);  in find_free_extent()
4197 	if (ret == -ENOSPC && !cache_block_group_error) {  in find_free_extent()
4199 		 * Use ffe_ctl->total_free_space as fallback if we can't find  in find_free_extent()
4204 		spin_lock(&space_info->lock);  in find_free_extent()
4205 		space_info->max_extent_size = ffe_ctl.max_extent_size;  in find_free_extent()
4206 		spin_unlock(&space_info->lock);  in find_free_extent()
4207 		ins->offset = ffe_ctl.max_extent_size;  in find_free_extent()
4208 	} else if (ret == -ENOSPC) {  in find_free_extent()
4215  * btrfs_reserve_extent - entry point to the extent allocator. Tries to find a
4218  * @root           -	The root that will contain this extent
4220  * @ram_bytes      -	The amount of space in ram that @num_bytes take. This
4224  * @num_bytes      -	Number of bytes to allocate on-disk.
4226  * @min_alloc_size -	Indicates the minimum amount of space that the
4233  * @empty_size     -	A hint that you plan on doing more COW. This is the
4238  * @hint_byte      -	Hint to the allocator to start searching above the byte
4241  * @ins            -	This key is modified to record the found hole. It will
4243  *			ins->objectid == start position
4244  *			ins->flags = BTRFS_EXTENT_ITEM_KEY
4245  *			ins->offset == the size of the hole.
4247  * @is_data        -	Boolean flag indicating whether an extent is
4250  * @delalloc       -	Boolean flag indicating whether this allocation is for
4256  * case -ENOSPC is returned then @ins->offset will contain the size of the
4264 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_reserve_extent()
4271 	WARN_ON(num_bytes < fs_info->sectorsize);  in btrfs_reserve_extent()
4275 		btrfs_dec_block_group_reservations(fs_info, ins->objectid);  in btrfs_reserve_extent()
4276 	} else if (ret == -ENOSPC) {  in btrfs_reserve_extent()
4277 		if (!final_tried && ins->offset) {  in btrfs_reserve_extent()
4278 			num_bytes = min(num_bytes >> 1, ins->offset);  in btrfs_reserve_extent()
4280 					       fs_info->sectorsize);  in btrfs_reserve_extent()
4311 		return -ENOSPC;  in btrfs_free_reserved_extent()
4328 	cache = btrfs_lookup_block_group(trans->fs_info, start);  in btrfs_pin_reserved_extent()
4330 		btrfs_err(trans->fs_info, "unable to find block group for %llu",  in btrfs_pin_reserved_extent()
4332 		return -ENOSPC;  in btrfs_pin_reserved_extent()
4345 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_file_extent()
4363 		return -ENOMEM;  in alloc_reserved_file_extent()
4365 	path->leave_spinning = 1;  in alloc_reserved_file_extent()
4366 	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,  in alloc_reserved_file_extent()
4373 	leaf = path->nodes[0];  in alloc_reserved_file_extent()
4374 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_file_extent()
4377 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_file_extent()
4390 		ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in alloc_reserved_file_extent()
4397 	btrfs_mark_buffer_dirty(path->nodes[0]);  in alloc_reserved_file_extent()
4400 	ret = remove_from_free_space_tree(trans, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4404 	ret = btrfs_update_block_group(trans, ins->objectid, ins->offset, 1);  in alloc_reserved_file_extent()
4405 	if (ret) { /* -ENOENT, logic error */  in alloc_reserved_file_extent()
4407 			ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4410 	trace_btrfs_reserved_extent_alloc(fs_info, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4418 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_tree_block()
4429 	u64 flags = extent_op->flags_to_set;  in alloc_reserved_tree_block()
4434 	extent_key.objectid = node->bytenr;  in alloc_reserved_tree_block()
4436 		extent_key.offset = ref->level;  in alloc_reserved_tree_block()
4438 		num_bytes = fs_info->nodesize;  in alloc_reserved_tree_block()
4440 		extent_key.offset = node->num_bytes;  in alloc_reserved_tree_block()
4443 		num_bytes = node->num_bytes;  in alloc_reserved_tree_block()
4448 		return -ENOMEM;  in alloc_reserved_tree_block()
4450 	path->leave_spinning = 1;  in alloc_reserved_tree_block()
4451 	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,  in alloc_reserved_tree_block()
4458 	leaf = path->nodes[0];  in alloc_reserved_tree_block()
4459 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_tree_block()
4462 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_tree_block()
4470 		btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);  in alloc_reserved_tree_block()
4471 		btrfs_set_tree_block_level(leaf, block_info, ref->level);  in alloc_reserved_tree_block()
4475 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY) {  in alloc_reserved_tree_block()
4479 		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->parent);  in alloc_reserved_tree_block()
4483 		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->root);  in alloc_reserved_tree_block()
4495 				       fs_info->nodesize, 1);  in alloc_reserved_tree_block()
4496 	if (ret) { /* -ENOENT, logic error */  in alloc_reserved_tree_block()
4503 					  fs_info->nodesize);  in alloc_reserved_tree_block()
4514 	BUG_ON(root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);  in btrfs_alloc_reserved_file_extent()
4517 			       ins->objectid, ins->offset, 0);  in btrfs_alloc_reserved_file_extent()
4518 	btrfs_init_data_ref(&generic_ref, root->root_key.objectid, owner, offset);  in btrfs_alloc_reserved_file_extent()
4519 	btrfs_ref_tree_mod(root->fs_info, &generic_ref);  in btrfs_alloc_reserved_file_extent()
4533 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_alloc_logged_file_extent()
4543 		ret = __exclude_logged_extent(fs_info, ins->objectid,  in btrfs_alloc_logged_file_extent()
4544 					      ins->offset);  in btrfs_alloc_logged_file_extent()
4549 	block_group = btrfs_lookup_block_group(fs_info, ins->objectid);  in btrfs_alloc_logged_file_extent()
4551 		return -EINVAL;  in btrfs_alloc_logged_file_extent()
4553 	space_info = block_group->space_info;  in btrfs_alloc_logged_file_extent()
4554 	spin_lock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
4555 	spin_lock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
4556 	space_info->bytes_reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
4557 	block_group->reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
4558 	spin_unlock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
4559 	spin_unlock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
4564 		btrfs_pin_extent(trans, ins->objectid, ins->offset, 1);  in btrfs_alloc_logged_file_extent()
4574 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_init_new_buffer()
4586 	if (buf->lock_owner == current->pid) {  in btrfs_init_new_buffer()
4589 			buf->start, btrfs_header_owner(buf), current->pid);  in btrfs_init_new_buffer()
4591 		return ERR_PTR(-EUCLEAN);  in btrfs_init_new_buffer()
4597 	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);  in btrfs_init_new_buffer()
4604 	btrfs_set_header_bytenr(buf, buf->start);  in btrfs_init_new_buffer()
4605 	btrfs_set_header_generation(buf, trans->transid);  in btrfs_init_new_buffer()
4608 	write_extent_buffer_fsid(buf, fs_info->fs_devices->metadata_uuid);  in btrfs_init_new_buffer()
4609 	write_extent_buffer_chunk_tree_uuid(buf, fs_info->chunk_tree_uuid);  in btrfs_init_new_buffer()
4610 	if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {  in btrfs_init_new_buffer()
4611 		buf->log_index = root->log_transid % 2;  in btrfs_init_new_buffer()
4616 		if (buf->log_index == 0)  in btrfs_init_new_buffer()
4617 			set_extent_dirty(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
4618 					buf->start + buf->len - 1, GFP_NOFS);  in btrfs_init_new_buffer()
4620 			set_extent_new(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
4621 					buf->start + buf->len - 1);  in btrfs_init_new_buffer()
4623 		buf->log_index = -1;  in btrfs_init_new_buffer()
4624 		set_extent_dirty(&trans->transaction->dirty_pages, buf->start,  in btrfs_init_new_buffer()
4625 			 buf->start + buf->len - 1, GFP_NOFS);  in btrfs_init_new_buffer()
4627 	trans->dirty = true;  in btrfs_init_new_buffer()
4644 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_alloc_tree_block()
4652 	u32 blocksize = fs_info->nodesize;  in btrfs_alloc_tree_block()
4657 		buf = btrfs_init_new_buffer(trans, root, root->alloc_bytenr,  in btrfs_alloc_tree_block()
4660 			root->alloc_bytenr += blocksize;  in btrfs_alloc_tree_block()
4691 			ret = -ENOMEM;  in btrfs_alloc_tree_block()
4695 			memcpy(&extent_op->key, key, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
4697 			memset(&extent_op->key, 0, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
4698 		extent_op->flags_to_set = flags;  in btrfs_alloc_tree_block()
4699 		extent_op->update_key = skinny_metadata ? false : true;  in btrfs_alloc_tree_block()
4700 		extent_op->update_flags = true;  in btrfs_alloc_tree_block()
4701 		extent_op->is_data = false;  in btrfs_alloc_tree_block()
4702 		extent_op->level = level;  in btrfs_alloc_tree_block()
4706 		generic_ref.real_root = root->root_key.objectid;  in btrfs_alloc_tree_block()
4748 				     struct walk_control *wc,  in reada_walk_down()  argument
4751 	struct btrfs_fs_info *fs_info = root->fs_info;  in reada_walk_down()
4763 	if (path->slots[wc->level] < wc->reada_slot) {  in reada_walk_down()
4764 		wc->reada_count = wc->reada_count * 2 / 3;  in reada_walk_down()
4765 		wc->reada_count = max(wc->reada_count, 2);  in reada_walk_down()
4767 		wc->reada_count = wc->reada_count * 3 / 2;  in reada_walk_down()
4768 		wc->reada_count = min_t(int, wc->reada_count,  in reada_walk_down()
4772 	eb = path->nodes[wc->level];  in reada_walk_down()
4775 	for (slot = path->slots[wc->level]; slot < nritems; slot++) {  in reada_walk_down()
4776 		if (nread >= wc->reada_count)  in reada_walk_down()
4783 		if (slot == path->slots[wc->level])  in reada_walk_down()
4786 		if (wc->stage == UPDATE_BACKREF &&  in reada_walk_down()
4787 		    generation <= root->root_key.offset)  in reada_walk_down()
4792 					       wc->level - 1, 1, &refs,  in reada_walk_down()
4799 		if (wc->stage == DROP_REFERENCE) {  in reada_walk_down()
4803 			if (wc->level == 1 &&  in reada_walk_down()
4806 			if (!wc->update_ref ||  in reada_walk_down()
4807 			    generation <= root->root_key.offset)  in reada_walk_down()
4811 						  &wc->update_progress);  in reada_walk_down()
4815 			if (wc->level == 1 &&  in reada_walk_down()
4823 	wc->reada_slot = slot;  in reada_walk_down()
4829  * when wc->stage == UPDATE_BACKREF, this function updates
4837 				   struct walk_control *wc, int lookup_info)  in walk_down_proc()  argument
4839 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_down_proc()
4840 	int level = wc->level;  in walk_down_proc()
4841 	struct extent_buffer *eb = path->nodes[level];  in walk_down_proc()
4845 	if (wc->stage == UPDATE_BACKREF &&  in walk_down_proc()
4846 	    btrfs_header_owner(eb) != root->root_key.objectid)  in walk_down_proc()
4854 	    ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||  in walk_down_proc()
4855 	     (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {  in walk_down_proc()
4856 		BUG_ON(!path->locks[level]);  in walk_down_proc()
4858 					       eb->start, level, 1,  in walk_down_proc()
4859 					       &wc->refs[level],  in walk_down_proc()
4860 					       &wc->flags[level]);  in walk_down_proc()
4861 		BUG_ON(ret == -ENOMEM);  in walk_down_proc()
4864 		BUG_ON(wc->refs[level] == 0);  in walk_down_proc()
4867 	if (wc->stage == DROP_REFERENCE) {  in walk_down_proc()
4868 		if (wc->refs[level] > 1)  in walk_down_proc()
4871 		if (path->locks[level] && !wc->keep_locks) {  in walk_down_proc()
4872 			btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
4873 			path->locks[level] = 0;  in walk_down_proc()
4878 	/* wc->stage == UPDATE_BACKREF */  in walk_down_proc()
4879 	if (!(wc->flags[level] & flag)) {  in walk_down_proc()
4880 		BUG_ON(!path->locks[level]);  in walk_down_proc()
4882 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4884 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4887 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4888 		wc->flags[level] |= flag;  in walk_down_proc()
4895 	if (path->locks[level] && level > 0) {  in walk_down_proc()
4896 		btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
4897 		path->locks[level] = 0;  in walk_down_proc()
4916 		return -ENOMEM;  in check_ref_exists()
4919 				    root->fs_info->nodesize, parent,  in check_ref_exists()
4920 				    root->root_key.objectid, level, 0);  in check_ref_exists()
4922 	if (ret == -ENOENT)  in check_ref_exists()
4932  * when wc->stage == DROP_REFERENCE, this function checks
4935  * rooted at the block, this function changes wc->stage to
4936  * UPDATE_BACKREF. if the block is shared and there is no
4945 				 struct walk_control *wc, int *lookup_info)  in do_walk_down()  argument
4947 	struct btrfs_fs_info *fs_info = root->fs_info;  in do_walk_down()
4955 	int level = wc->level;  in do_walk_down()
4960 	generation = btrfs_node_ptr_generation(path->nodes[level],  in do_walk_down()
4961 					       path->slots[level]);  in do_walk_down()
4964 	 * was created, we know there is no need to update back refs  in do_walk_down()
4967 	if (wc->stage == UPDATE_BACKREF &&  in do_walk_down()
4968 	    generation <= root->root_key.offset) {  in do_walk_down()
4973 	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);  in do_walk_down()
4974 	btrfs_node_key_to_cpu(path->nodes[level], &first_key,  in do_walk_down()
4975 			      path->slots[level]);  in do_walk_down()
4983 		btrfs_set_buffer_lockdep_class(root->root_key.objectid, next,  in do_walk_down()
4984 					       level - 1);  in do_walk_down()
4990 	ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,  in do_walk_down()
4991 				       &wc->refs[level - 1],  in do_walk_down()
4992 				       &wc->flags[level - 1]);  in do_walk_down()
4996 	if (unlikely(wc->refs[level - 1] == 0)) {  in do_walk_down()
4998 		ret = -EIO;  in do_walk_down()
5003 	if (wc->stage == DROP_REFERENCE) {  in do_walk_down()
5004 		if (wc->refs[level - 1] > 1) {  in do_walk_down()
5007 			    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))  in do_walk_down()
5010 			if (!wc->update_ref ||  in do_walk_down()
5011 			    generation <= root->root_key.offset)  in do_walk_down()
5014 			btrfs_node_key_to_cpu(path->nodes[level], &key,  in do_walk_down()
5015 					      path->slots[level]);  in do_walk_down()
5016 			ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);  in do_walk_down()
5020 			wc->stage = UPDATE_BACKREF;  in do_walk_down()
5021 			wc->shared_level = level - 1;  in do_walk_down()
5025 		    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))  in do_walk_down()
5038 			reada_walk_down(trans, root, wc, path);  in do_walk_down()
5039 		next = read_tree_block(fs_info, bytenr, generation, level - 1,  in do_walk_down()
5045 			return -EIO;  in do_walk_down()
5051 	level--;  in do_walk_down()
5054 		btrfs_err(root->fs_info, "mismatched level");  in do_walk_down()
5055 		ret = -EIO;  in do_walk_down()
5058 	path->nodes[level] = next;  in do_walk_down()
5059 	path->slots[level] = 0;  in do_walk_down()
5060 	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in do_walk_down()
5061 	wc->level = level;  in do_walk_down()
5062 	if (wc->level == 1)  in do_walk_down()
5063 		wc->reada_slot = 0;  in do_walk_down()
5066 	wc->refs[level - 1] = 0;  in do_walk_down()
5067 	wc->flags[level - 1] = 0;  in do_walk_down()
5068 	if (wc->stage == DROP_REFERENCE) {  in do_walk_down()
5069 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {  in do_walk_down()
5070 			parent = path->nodes[level]->start;  in do_walk_down()
5072 			ASSERT(root->root_key.objectid ==  in do_walk_down()
5073 			       btrfs_header_owner(path->nodes[level]));  in do_walk_down()
5074 			if (root->root_key.objectid !=  in do_walk_down()
5075 			    btrfs_header_owner(path->nodes[level])) {  in do_walk_down()
5076 				btrfs_err(root->fs_info,  in do_walk_down()
5078 				ret = -EIO;  in do_walk_down()
5088 		 * ->restarted flag.  in do_walk_down()
5090 		if (wc->restarted) {  in do_walk_down()
5092 					       level - 1);  in do_walk_down()
5098 			wc->restarted = 0;  in do_walk_down()
5106 		if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&  in do_walk_down()
5109 							 generation, level - 1);  in do_walk_down()
5123 		wc->drop_level = level;  in do_walk_down()
5124 		find_next_key(path, level, &wc->drop_progress);  in do_walk_down()
5127 				       fs_info->nodesize, parent);  in do_walk_down()
5128 		btrfs_init_tree_ref(&ref, level - 1, root->root_key.objectid);  in do_walk_down()
5147  * when wc->stage == DROP_REFERENCE, this function drops
5150  * when wc->stage == UPDATE_BACKREF, this function changes
5151  * wc->stage back to DROP_REFERENCE if we changed wc->stage
5159 				 struct walk_control *wc)  in walk_up_proc()  argument
5161 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_up_proc()
5163 	int level = wc->level;  in walk_up_proc()
5164 	struct extent_buffer *eb = path->nodes[level];  in walk_up_proc()
5167 	if (wc->stage == UPDATE_BACKREF) {  in walk_up_proc()
5168 		BUG_ON(wc->shared_level < level);  in walk_up_proc()
5169 		if (level < wc->shared_level)  in walk_up_proc()
5172 		ret = find_next_key(path, level + 1, &wc->update_progress);  in walk_up_proc()
5174 			wc->update_ref = 0;  in walk_up_proc()
5176 		wc->stage = DROP_REFERENCE;  in walk_up_proc()
5177 		wc->shared_level = -1;  in walk_up_proc()
5178 		path->slots[level] = 0;  in walk_up_proc()
5185 		if (!path->locks[level]) {  in walk_up_proc()
5189 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in walk_up_proc()
5192 						       eb->start, level, 1,  in walk_up_proc()
5193 						       &wc->refs[level],  in walk_up_proc()
5194 						       &wc->flags[level]);  in walk_up_proc()
5196 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5197 				path->locks[level] = 0;  in walk_up_proc()
5200 			BUG_ON(wc->refs[level] == 0);  in walk_up_proc()
5201 			if (wc->refs[level] == 1) {  in walk_up_proc()
5202 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5203 				path->locks[level] = 0;  in walk_up_proc()
5209 	/* wc->stage == DROP_REFERENCE */  in walk_up_proc()
5210 	BUG_ON(wc->refs[level] > 1 && !path->locks[level]);  in walk_up_proc()
5212 	if (wc->refs[level] == 1) {  in walk_up_proc()
5214 			if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5218 			BUG_ON(ret); /* -ENOMEM */  in walk_up_proc()
5219 			if (is_fstree(root->root_key.objectid)) {  in walk_up_proc()
5229 		if (!path->locks[level] &&  in walk_up_proc()
5230 		    btrfs_header_generation(eb) == trans->transid) {  in walk_up_proc()
5233 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in walk_up_proc()
5238 	if (eb == root->node) {  in walk_up_proc()
5239 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5240 			parent = eb->start;  in walk_up_proc()
5241 		else if (root->root_key.objectid != btrfs_header_owner(eb))  in walk_up_proc()
5244 		if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5245 			parent = path->nodes[level + 1]->start;  in walk_up_proc()
5246 		else if (root->root_key.objectid !=  in walk_up_proc()
5247 			 btrfs_header_owner(path->nodes[level + 1]))  in walk_up_proc()
5251 	btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);  in walk_up_proc()
5253 	wc->refs[level] = 0;  in walk_up_proc()
5254 	wc->flags[level] = 0;  in walk_up_proc()
5259 		     btrfs_header_owner(eb), root->root_key.objectid);  in walk_up_proc()
5260 	return -EUCLEAN;  in walk_up_proc()
5266 				   struct walk_control *wc)  in walk_down_tree()  argument
5268 	int level = wc->level;  in walk_down_tree()
5273 		ret = walk_down_proc(trans, root, path, wc, lookup_info);  in walk_down_tree()
5280 		if (path->slots[level] >=  in walk_down_tree()
5281 		    btrfs_header_nritems(path->nodes[level]))  in walk_down_tree()
5284 		ret = do_walk_down(trans, root, path, wc, &lookup_info);  in walk_down_tree()
5286 			path->slots[level]++;  in walk_down_tree()
5290 		level = wc->level;  in walk_down_tree()
5298 				 struct walk_control *wc, int max_level)  in walk_up_tree()  argument
5300 	int level = wc->level;  in walk_up_tree()
5303 	path->slots[level] = btrfs_header_nritems(path->nodes[level]);  in walk_up_tree()
5304 	while (level < max_level && path->nodes[level]) {  in walk_up_tree()
5305 		wc->level = level;  in walk_up_tree()
5306 		if (path->slots[level] + 1 <  in walk_up_tree()
5307 		    btrfs_header_nritems(path->nodes[level])) {  in walk_up_tree()
5308 			path->slots[level]++;  in walk_up_tree()
5311 			ret = walk_up_proc(trans, root, path, wc);  in walk_up_tree()
5317 			if (path->locks[level]) {  in walk_up_tree()
5318 				btrfs_tree_unlock_rw(path->nodes[level],  in walk_up_tree()
5319 						     path->locks[level]);  in walk_up_tree()
5320 				path->locks[level] = 0;  in walk_up_tree()
5322 			free_extent_buffer(path->nodes[level]);  in walk_up_tree()
5323 			path->nodes[level] = NULL;  in walk_up_tree()
5341  * If called with for_reloc == 0, may exit early with -EAGAIN
5345 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_snapshot()
5348 	struct btrfs_root *tree_root = fs_info->tree_root;  in btrfs_drop_snapshot()
5349 	struct btrfs_root_item *root_item = &root->root_item;  in btrfs_drop_snapshot()
5350 	struct walk_control *wc;  in btrfs_drop_snapshot()  local
5357 	btrfs_debug(fs_info, "Drop subvolume %llu", root->root_key.objectid);  in btrfs_drop_snapshot()
5361 		err = -ENOMEM;  in btrfs_drop_snapshot()
5365 	wc = kzalloc(sizeof(*wc), GFP_NOFS);  in btrfs_drop_snapshot()
5366 	if (!wc) {  in btrfs_drop_snapshot()
5368 		err = -ENOMEM;  in btrfs_drop_snapshot()
5397 	set_bit(BTRFS_ROOT_DELETING, &root->state);  in btrfs_drop_snapshot()
5398 	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {  in btrfs_drop_snapshot()
5399 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
5400 		path->nodes[level] = btrfs_lock_root_node(root);  in btrfs_drop_snapshot()
5401 		btrfs_set_lock_blocking_write(path->nodes[level]);  in btrfs_drop_snapshot()
5402 		path->slots[level] = 0;  in btrfs_drop_snapshot()
5403 		path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_snapshot()
5404 		memset(&wc->update_progress, 0,  in btrfs_drop_snapshot()
5405 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
5407 		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);  in btrfs_drop_snapshot()
5408 		memcpy(&wc->update_progress, &key,  in btrfs_drop_snapshot()
5409 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
5411 		level = root_item->drop_level;  in btrfs_drop_snapshot()
5413 		path->lowest_level = level;  in btrfs_drop_snapshot()
5415 		path->lowest_level = 0;  in btrfs_drop_snapshot()
5428 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
5430 			btrfs_tree_lock(path->nodes[level]);  in btrfs_drop_snapshot()
5431 			btrfs_set_lock_blocking_write(path->nodes[level]);  in btrfs_drop_snapshot()
5432 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_snapshot()
5435 						path->nodes[level]->start,  in btrfs_drop_snapshot()
5436 						level, 1, &wc->refs[level],  in btrfs_drop_snapshot()
5437 						&wc->flags[level]);  in btrfs_drop_snapshot()
5442 			BUG_ON(wc->refs[level] == 0);  in btrfs_drop_snapshot()
5444 			if (level == root_item->drop_level)  in btrfs_drop_snapshot()
5447 			btrfs_tree_unlock(path->nodes[level]);  in btrfs_drop_snapshot()
5448 			path->locks[level] = 0;  in btrfs_drop_snapshot()
5449 			WARN_ON(wc->refs[level] != 1);  in btrfs_drop_snapshot()
5450 			level--;  in btrfs_drop_snapshot()
5454 	wc->restarted = test_bit(BTRFS_ROOT_DEAD_TREE, &root->state);  in btrfs_drop_snapshot()
5455 	wc->level = level;  in btrfs_drop_snapshot()
5456 	wc->shared_level = -1;  in btrfs_drop_snapshot()
5457 	wc->stage = DROP_REFERENCE;  in btrfs_drop_snapshot()
5458 	wc->update_ref = update_ref;  in btrfs_drop_snapshot()
5459 	wc->keep_locks = 0;  in btrfs_drop_snapshot()
5460 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_snapshot()
5464 		ret = walk_down_tree(trans, root, path, wc);  in btrfs_drop_snapshot()
5470 		ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);  in btrfs_drop_snapshot()
5477 			BUG_ON(wc->stage != DROP_REFERENCE);  in btrfs_drop_snapshot()
5481 		if (wc->stage == DROP_REFERENCE) {  in btrfs_drop_snapshot()
5482 			wc->drop_level = wc->level;  in btrfs_drop_snapshot()
5483 			btrfs_node_key_to_cpu(path->nodes[wc->drop_level],  in btrfs_drop_snapshot()
5484 					      &wc->drop_progress,  in btrfs_drop_snapshot()
5485 					      path->slots[wc->drop_level]);  in btrfs_drop_snapshot()
5487 		btrfs_cpu_key_to_disk(&root_item->drop_progress,  in btrfs_drop_snapshot()
5488 				      &wc->drop_progress);  in btrfs_drop_snapshot()
5489 		root_item->drop_level = wc->drop_level;  in btrfs_drop_snapshot()
5491 		BUG_ON(wc->level == 0);  in btrfs_drop_snapshot()
5495 						&root->root_key,  in btrfs_drop_snapshot()
5507 				err = -EAGAIN;  in btrfs_drop_snapshot()
5530 	ret = btrfs_del_root(trans, &root->root_key);  in btrfs_drop_snapshot()
5537 	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {  in btrfs_drop_snapshot()
5538 		ret = btrfs_find_root(tree_root, &root->root_key, path,  in btrfs_drop_snapshot()
5548 			 * The most common failure here is just -ENOENT.  in btrfs_drop_snapshot()
5551 					      root->root_key.objectid);  in btrfs_drop_snapshot()
5563 	if (test_bit(BTRFS_ROOT_IN_RADIX, &root->state))  in btrfs_drop_snapshot()
5571 	kfree(wc);  in btrfs_drop_snapshot()
5579 	 * or unmount) so we don't leak memory.  in btrfs_drop_snapshot()
5597 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_subtree()
5599 	struct walk_control *wc;  in btrfs_drop_subtree()  local
5605 	BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);  in btrfs_drop_subtree()
5609 		return -ENOMEM;  in btrfs_drop_subtree()
5611 	wc = kzalloc(sizeof(*wc), GFP_NOFS);  in btrfs_drop_subtree()
5612 	if (!wc) {  in btrfs_drop_subtree()
5614 		return -ENOMEM;  in btrfs_drop_subtree()
5619 	atomic_inc(&parent->refs);  in btrfs_drop_subtree()
5620 	path->nodes[parent_level] = parent;  in btrfs_drop_subtree()
5621 	path->slots[parent_level] = btrfs_header_nritems(parent);  in btrfs_drop_subtree()
5625 	path->nodes[level] = node;  in btrfs_drop_subtree()
5626 	path->slots[level] = 0;  in btrfs_drop_subtree()
5627 	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_subtree()
5629 	wc->refs[parent_level] = 1;  in btrfs_drop_subtree()
5630 	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;  in btrfs_drop_subtree()
5631 	wc->level = level;  in btrfs_drop_subtree()
5632 	wc->shared_level = -1;  in btrfs_drop_subtree()
5633 	wc->stage = DROP_REFERENCE;  in btrfs_drop_subtree()
5634 	wc->update_ref = 0;  in btrfs_drop_subtree()
5635 	wc->keep_locks = 1;  in btrfs_drop_subtree()
5636 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_subtree()
5639 		wret = walk_down_tree(trans, root, path, wc);  in btrfs_drop_subtree()
5645 		wret = walk_up_tree(trans, root, path, wc, parent_level);  in btrfs_drop_subtree()
5652 	kfree(wc);  in btrfs_drop_subtree()
5668 	if (list_empty(&sinfo->ro_bgs))  in btrfs_account_ro_block_groups_free_space()
5671 	spin_lock(&sinfo->lock);  in btrfs_account_ro_block_groups_free_space()
5672 	list_for_each_entry(block_group, &sinfo->ro_bgs, ro_list) {  in btrfs_account_ro_block_groups_free_space()
5673 		spin_lock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5675 		if (!block_group->ro) {  in btrfs_account_ro_block_groups_free_space()
5676 			spin_unlock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5680 		factor = btrfs_bg_type_to_factor(block_group->flags);  in btrfs_account_ro_block_groups_free_space()
5681 		free_bytes += (block_group->length -  in btrfs_account_ro_block_groups_free_space()
5682 			       block_group->used) * factor;  in btrfs_account_ro_block_groups_free_space()
5684 		spin_unlock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5686 	spin_unlock(&sinfo->lock);  in btrfs_account_ro_block_groups_free_space()
5711  * from committing and releasing the memory that the pending chunks
5725 	if (!blk_queue_discard(bdev_get_queue(device->bdev)))  in btrfs_trim_free_extents()
5729 	if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state))  in btrfs_trim_free_extents()
5732 	/* No free space = nothing to do. */  in btrfs_trim_free_extents()
5733 	if (device->total_bytes <= device->bytes_used)  in btrfs_trim_free_extents()
5739 		struct btrfs_fs_info *fs_info = device->fs_info;  in btrfs_trim_free_extents()
5742 		ret = mutex_lock_interruptible(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5746 		find_first_clear_extent_bit(&device->alloc_state, start,  in btrfs_trim_free_extents()
5751 		if (start > device->total_bytes) {  in btrfs_trim_free_extents()
5755 					  start, end - start + 1,  in btrfs_trim_free_extents()
5756 					  rcu_str_deref(device->name),  in btrfs_trim_free_extents()
5757 					  device->total_bytes);  in btrfs_trim_free_extents()
5758 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5768 		 * end of the device it will set end to -1, in this case it's up  in btrfs_trim_free_extents()
5771 		end = min(end, device->total_bytes - 1);  in btrfs_trim_free_extents()
5773 		len = end - start + 1;  in btrfs_trim_free_extents()
5777 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5782 		ret = btrfs_issue_discard(device->bdev, start, len,  in btrfs_trim_free_extents()
5785 			set_extent_bits(&device->alloc_state, start,  in btrfs_trim_free_extents()
5786 					start + bytes - 1,  in btrfs_trim_free_extents()
5788 		mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5797 			ret = -ERESTARTSYS;  in btrfs_trim_free_extents()
5833 	 * Check range overflow if range->len is set.  in btrfs_trim_fs()
5834 	 * The default range->len is U64_MAX.  in btrfs_trim_fs()
5836 	if (range->len != U64_MAX &&  in btrfs_trim_fs()
5837 	    check_add_overflow(range->start, range->len, &range_end))  in btrfs_trim_fs()
5838 		return -EINVAL;  in btrfs_trim_fs()
5840 	cache = btrfs_lookup_first_block_group(fs_info, range->start);  in btrfs_trim_fs()
5842 		if (cache->start >= range_end) {  in btrfs_trim_fs()
5847 		start = max(range->start, cache->start);  in btrfs_trim_fs()
5848 		end = min(range_end, cache->start + cache->length);  in btrfs_trim_fs()
5850 		if (end - start >= range->minlen) {  in btrfs_trim_fs()
5869 						     range->minlen);  in btrfs_trim_fs()
5884 	mutex_lock(&fs_info->fs_devices->device_list_mutex);  in btrfs_trim_fs()
5885 	devices = &fs_info->fs_devices->devices;  in btrfs_trim_fs()
5887 		if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))  in btrfs_trim_fs()
5899 	mutex_unlock(&fs_info->fs_devices->device_list_mutex);  in btrfs_trim_fs()
5905 	range->len = trimmed;  in btrfs_trim_fs()