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()
1688 		btrfs_err(trans->fs_info,  in run_one_delayed_ref()
1690 			  node->bytenr, node->num_bytes, node->type,  in run_one_delayed_ref()
1691 			  node->action, node->ref_mod, ret);  in run_one_delayed_ref()
1700 	if (RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in select_delayed_ref()
1709 	if (!list_empty(&head->ref_add_list))  in select_delayed_ref()
1710 		return list_first_entry(&head->ref_add_list,  in select_delayed_ref()
1713 	ref = rb_entry(rb_first_cached(&head->ref_tree),  in select_delayed_ref()
1715 	ASSERT(list_empty(&ref->add_list));  in select_delayed_ref()
1722 	spin_lock(&delayed_refs->lock);  in unselect_delayed_ref_head()
1723 	head->processing = 0;  in unselect_delayed_ref_head()
1724 	delayed_refs->num_heads_ready++;  in unselect_delayed_ref_head()
1725 	spin_unlock(&delayed_refs->lock);  in unselect_delayed_ref_head()
1732 	struct btrfs_delayed_extent_op *extent_op = head->extent_op;  in cleanup_extent_op()
1737 	if (head->must_insert_reserved) {  in cleanup_extent_op()
1738 		head->extent_op = NULL;  in cleanup_extent_op()
1754 	head->extent_op = NULL;  in run_and_cleanup_extent_op()
1755 	spin_unlock(&head->lock);  in run_and_cleanup_extent_op()
1771 	if (head->total_ref_mod < 0 && head->is_data) {  in btrfs_cleanup_ref_head_accounting()
1772 		spin_lock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1773 		delayed_refs->pending_csums -= head->num_bytes;  in btrfs_cleanup_ref_head_accounting()
1774 		spin_unlock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1775 		nr_items += btrfs_csum_bytes_to_leaves(fs_info, head->num_bytes);  in btrfs_cleanup_ref_head_accounting()
1784 	if (head->total_ref_mod < 0 ||  in btrfs_cleanup_ref_head_accounting()
1785 	    (head->total_ref_mod == 0 && head->must_insert_reserved)) {  in btrfs_cleanup_ref_head_accounting()
1788 		btrfs_mod_total_bytes_pinned(fs_info, flags, -head->num_bytes);  in btrfs_cleanup_ref_head_accounting()
1798 	struct btrfs_fs_info *fs_info = trans->fs_info;  in cleanup_ref_head()
1802 	delayed_refs = &trans->transaction->delayed_refs;  in cleanup_ref_head()
1814 	 * Need to drop our head ref lock and re-acquire the delayed ref lock  in cleanup_ref_head()
1815 	 * and then re-check to make sure nobody got added.  in cleanup_ref_head()
1817 	spin_unlock(&head->lock);  in cleanup_ref_head()
1818 	spin_lock(&delayed_refs->lock);  in cleanup_ref_head()
1819 	spin_lock(&head->lock);  in cleanup_ref_head()
1820 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root) || head->extent_op) {  in cleanup_ref_head()
1821 		spin_unlock(&head->lock);  in cleanup_ref_head()
1822 		spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1826 	spin_unlock(&head->lock);  in cleanup_ref_head()
1827 	spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1829 	if (head->must_insert_reserved) {  in cleanup_ref_head()
1830 		btrfs_pin_extent(trans, head->bytenr, head->num_bytes, 1);  in cleanup_ref_head()
1831 		if (head->is_data) {  in cleanup_ref_head()
1832 			ret = btrfs_del_csums(trans, fs_info->csum_root,  in cleanup_ref_head()
1833 					      head->bytenr, head->num_bytes);  in cleanup_ref_head()
1849 		&trans->transaction->delayed_refs;  in btrfs_obtain_ref_head()
1853 	spin_lock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1856 		spin_unlock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1865 	spin_unlock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1872 	if (ret == -EAGAIN)  in btrfs_obtain_ref_head()
1873 		head = ERR_PTR(-EAGAIN);  in btrfs_obtain_ref_head()
1882 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs_for_head()
1889 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs_for_head()
1891 	lockdep_assert_held(&locked_ref->mutex);  in btrfs_run_delayed_refs_for_head()
1892 	lockdep_assert_held(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1895 		if (ref->seq &&  in btrfs_run_delayed_refs_for_head()
1896 		    btrfs_check_delayed_seq(fs_info, ref->seq)) {  in btrfs_run_delayed_refs_for_head()
1897 			spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1899 			return -EAGAIN;  in btrfs_run_delayed_refs_for_head()
1903 		ref->in_tree = 0;  in btrfs_run_delayed_refs_for_head()
1904 		rb_erase_cached(&ref->ref_node, &locked_ref->ref_tree);  in btrfs_run_delayed_refs_for_head()
1905 		RB_CLEAR_NODE(&ref->ref_node);  in btrfs_run_delayed_refs_for_head()
1906 		if (!list_empty(&ref->add_list))  in btrfs_run_delayed_refs_for_head()
1907 			list_del(&ref->add_list);  in btrfs_run_delayed_refs_for_head()
1912 		switch (ref->action) {  in btrfs_run_delayed_refs_for_head()
1915 			locked_ref->ref_mod -= ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1918 			locked_ref->ref_mod += ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1923 		atomic_dec(&delayed_refs->num_entries);  in btrfs_run_delayed_refs_for_head()
1929 		must_insert_reserved = locked_ref->must_insert_reserved;  in btrfs_run_delayed_refs_for_head()
1930 		locked_ref->must_insert_reserved = 0;  in btrfs_run_delayed_refs_for_head()
1932 		extent_op = locked_ref->extent_op;  in btrfs_run_delayed_refs_for_head()
1933 		locked_ref->extent_op = NULL;  in btrfs_run_delayed_refs_for_head()
1934 		spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1949 		spin_lock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1958  * Returns -ENOMEM or -EIO on failure and will abort the transaction.
1963 	struct btrfs_fs_info *fs_info = trans->fs_info;  in __btrfs_run_delayed_refs()
1971 	delayed_refs = &trans->transaction->delayed_refs;  in __btrfs_run_delayed_refs()
1976 				if (PTR_ERR(locked_ref) == -EAGAIN) {  in __btrfs_run_delayed_refs()
1988 		 * finish.  If we merged anything we need to re-loop so we can  in __btrfs_run_delayed_refs()
1996 		spin_lock(&locked_ref->lock);  in __btrfs_run_delayed_refs()
2001 		if (ret < 0 && ret != -EAGAIN) {  in __btrfs_run_delayed_refs()
2024 		 * returned -EAGAIN, meaning we need to select another head  in __btrfs_run_delayed_refs()
2029 	} while ((nr != -1 && count < nr) || locked_ref);  in __btrfs_run_delayed_refs()
2034 	 * accounting, no actual extent tree updates.  in __btrfs_run_delayed_refs()
2044 		spin_lock(&delayed_refs->lock);  in __btrfs_run_delayed_refs()
2045 		avg = fs_info->avg_delayed_ref_runtime * 3 + runtime;  in __btrfs_run_delayed_refs()
2046 		fs_info->avg_delayed_ref_runtime = avg >> 2;	/* div by 4 */  in __btrfs_run_delayed_refs()
2047 		spin_unlock(&delayed_refs->lock);  in __btrfs_run_delayed_refs()
2060 	struct rb_node *n = root->rb_node;  in find_middle()
2069 		first = entry->bytenr;  in find_middle()
2074 		last = entry->bytenr;  in find_middle()
2076 	n = root->rb_node;  in find_middle()
2080 		WARN_ON(!entry->in_tree);  in find_middle()
2082 		middle = entry->bytenr;  in find_middle()
2085 			n = n->rb_left;  in find_middle()
2087 			n = n->rb_right;  in find_middle()
2089 		alt = 1 - alt;  in find_middle()
2107 			(u64)btrfs_super_csum_size(fs_info->super_copy));  in btrfs_csum_bytes_to_leaves()
2108 	num_csums = div64_u64(csum_bytes, fs_info->sectorsize);  in btrfs_csum_bytes_to_leaves()
2109 	num_csums += num_csums_per_leaf - 1;  in btrfs_csum_bytes_to_leaves()
2127 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs()
2132 	int run_all = count == (unsigned long)-1;  in btrfs_run_delayed_refs()
2138 	if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags))  in btrfs_run_delayed_refs()
2141 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs()
2143 		count = atomic_read(&delayed_refs->num_entries) * 2;  in btrfs_run_delayed_refs()
2147 	delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);  in btrfs_run_delayed_refs()
2158 		spin_lock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2159 		node = rb_first_cached(&delayed_refs->href_root);  in btrfs_run_delayed_refs()
2161 			spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2166 		refcount_inc(&head->refs);  in btrfs_run_delayed_refs()
2167 		spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2170 		mutex_lock(&head->mutex);  in btrfs_run_delayed_refs()
2171 		mutex_unlock(&head->mutex);  in btrfs_run_delayed_refs()
2190 		return -ENOMEM;  in btrfs_set_disk_extent_flags()
2192 	extent_op->flags_to_set = flags;  in btrfs_set_disk_extent_flags()
2193 	extent_op->update_flags = true;  in btrfs_set_disk_extent_flags()
2194 	extent_op->update_key = false;  in btrfs_set_disk_extent_flags()
2195 	extent_op->is_data = is_data ? true : false;  in btrfs_set_disk_extent_flags()
2196 	extent_op->level = level;  in btrfs_set_disk_extent_flags()
2198 	ret = btrfs_add_delayed_extent_op(trans, eb->start, eb->len, extent_op);  in btrfs_set_disk_extent_flags()
2216 	spin_lock(&root->fs_info->trans_lock);  in check_delayed_ref()
2217 	cur_trans = root->fs_info->running_transaction;  in check_delayed_ref()
2219 		refcount_inc(&cur_trans->use_count);  in check_delayed_ref()
2220 	spin_unlock(&root->fs_info->trans_lock);  in check_delayed_ref()
2224 	delayed_refs = &cur_trans->delayed_refs;  in check_delayed_ref()
2225 	spin_lock(&delayed_refs->lock);  in check_delayed_ref()
2228 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2233 	if (!mutex_trylock(&head->mutex)) {  in check_delayed_ref()
2234 		refcount_inc(&head->refs);  in check_delayed_ref()
2235 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2243 		mutex_lock(&head->mutex);  in check_delayed_ref()
2244 		mutex_unlock(&head->mutex);  in check_delayed_ref()
2247 		return -EAGAIN;  in check_delayed_ref()
2249 	spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2251 	spin_lock(&head->lock);  in check_delayed_ref()
2256 	for (node = rb_first_cached(&head->ref_tree); node;  in check_delayed_ref()
2260 		if (ref->type != BTRFS_EXTENT_DATA_REF_KEY) {  in check_delayed_ref()
2271 		if (data_ref->root != root->root_key.objectid ||  in check_delayed_ref()
2272 		    data_ref->objectid != objectid ||  in check_delayed_ref()
2273 		    data_ref->offset != offset) {  in check_delayed_ref()
2278 	spin_unlock(&head->lock);  in check_delayed_ref()
2279 	mutex_unlock(&head->mutex);  in check_delayed_ref()
2289 	struct btrfs_fs_info *fs_info = root->fs_info;  in check_committed_ref()
2290 	struct btrfs_root *extent_root = fs_info->extent_root;  in check_committed_ref()
2301 	key.offset = (u64)-1;  in check_committed_ref()
2309 	ret = -ENOENT;  in check_committed_ref()
2310 	if (path->slots[0] == 0)  in check_committed_ref()
2313 	path->slots[0]--;  in check_committed_ref()
2314 	leaf = path->nodes[0];  in check_committed_ref()
2315 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in check_committed_ref()
2321 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in check_committed_ref()
2322 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in check_committed_ref()
2335 	     btrfs_root_last_snapshot(&root->root_item)))  in check_committed_ref()
2345 	ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in check_committed_ref()
2349 	    root->root_key.objectid ||  in check_committed_ref()
2367 		return -ENOMEM;  in btrfs_cross_ref_exist()
2372 		if (ret && ret != -ENOENT)  in btrfs_cross_ref_exist()
2376 	} while (ret == -EAGAIN);  in btrfs_cross_ref_exist()
2380 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in btrfs_cross_ref_exist()
2390 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_mod_ref()
2412 	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && level == 0)  in __btrfs_mod_ref()
2416 		parent = buf->start;  in __btrfs_mod_ref()
2439 			key.offset -= btrfs_file_extent_offset(buf, fi);  in __btrfs_mod_ref()
2442 			generic_ref.real_root = root->root_key.objectid;  in __btrfs_mod_ref()
2454 			num_bytes = fs_info->nodesize;  in __btrfs_mod_ref()
2457 			generic_ref.real_root = root->root_key.objectid;  in __btrfs_mod_ref()
2458 			btrfs_init_tree_ref(&generic_ref, level - 1, ref_root);  in __btrfs_mod_ref()
2491 	if (!block_group || block_group->ro)  in btrfs_extent_readonly()
2500 	struct btrfs_fs_info *fs_info = root->fs_info;  in get_alloc_profile_by_root()
2506 	else if (root == fs_info->chunk_root)  in get_alloc_profile_by_root()
2520 	spin_lock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2521 	bytenr = fs_info->first_logical_byte;  in first_logical_byte()
2522 	spin_unlock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2524 	if (bytenr < (u64)-1)  in first_logical_byte()
2531 	bytenr = cache->start;  in first_logical_byte()
2541 	struct btrfs_fs_info *fs_info = cache->fs_info;  in pin_down_extent()
2543 	spin_lock(&cache->space_info->lock);  in pin_down_extent()
2544 	spin_lock(&cache->lock);  in pin_down_extent()
2545 	cache->pinned += num_bytes;  in pin_down_extent()
2546 	btrfs_space_info_update_bytes_pinned(fs_info, cache->space_info,  in pin_down_extent()
2549 		cache->reserved -= num_bytes;  in pin_down_extent()
2550 		cache->space_info->bytes_reserved -= num_bytes;  in pin_down_extent()
2552 	spin_unlock(&cache->lock);  in pin_down_extent()
2553 	spin_unlock(&cache->space_info->lock);  in pin_down_extent()
2555 	__btrfs_mod_total_bytes_pinned(cache->space_info, num_bytes);  in pin_down_extent()
2556 	set_extent_dirty(&trans->transaction->pinned_extents, bytenr,  in pin_down_extent()
2557 			 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);  in pin_down_extent()
2566 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent()
2584 	btrfs_add_excluded_extent(trans->fs_info, bytenr, num_bytes);  in btrfs_pin_extent_for_log_replay()
2586 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent_for_log_replay()
2588 		return -EINVAL;  in btrfs_pin_extent_for_log_replay()
2615 		return -EINVAL;  in __exclude_logged_extent()
2625 		mutex_lock(&caching_ctl->mutex);  in __exclude_logged_extent()
2627 		if (start >= caching_ctl->progress) {  in __exclude_logged_extent()
2630 		} else if (start + num_bytes <= caching_ctl->progress) {  in __exclude_logged_extent()
2634 			num_bytes = caching_ctl->progress - start;  in __exclude_logged_extent()
2640 			num_bytes = (start + num_bytes) -  in __exclude_logged_extent()
2641 				caching_ctl->progress;  in __exclude_logged_extent()
2642 			start = caching_ctl->progress;  in __exclude_logged_extent()
2647 		mutex_unlock(&caching_ctl->mutex);  in __exclude_logged_extent()
2656 	struct btrfs_fs_info *fs_info = eb->fs_info;  in btrfs_exclude_logged_extents()
2689 	atomic_inc(&bg->reservations);  in btrfs_inc_block_group_reservations()
2706 	if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {  in fetch_cluster_info()
2707 		ret = &fs_info->meta_alloc_cluster;  in fetch_cluster_info()
2712 	} else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) &&  in fetch_cluster_info()
2715 		ret = &fs_info->data_alloc_cluster;  in fetch_cluster_info()
2727 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in unpin_extent_range()
2737 		    start >= cache->start + cache->length) {  in unpin_extent_range()
2745 						     cache->space_info,  in unpin_extent_range()
2750 		len = cache->start + cache->length - start;  in unpin_extent_range()
2751 		len = min(len, end + 1 - start);  in unpin_extent_range()
2753 		if (start < cache->last_byte_to_unpin && return_free_space) {  in unpin_extent_range()
2754 			u64 add_len = min(len, cache->last_byte_to_unpin - start);  in unpin_extent_range()
2761 		space_info = cache->space_info;  in unpin_extent_range()
2769 		if (cluster && cluster->fragmented &&  in unpin_extent_range()
2771 			spin_lock(&cluster->lock);  in unpin_extent_range()
2772 			cluster->fragmented = 0;  in unpin_extent_range()
2773 			spin_unlock(&cluster->lock);  in unpin_extent_range()
2776 		spin_lock(&space_info->lock);  in unpin_extent_range()
2777 		spin_lock(&cache->lock);  in unpin_extent_range()
2778 		cache->pinned -= len;  in unpin_extent_range()
2779 		btrfs_space_info_update_bytes_pinned(fs_info, space_info, -len);  in unpin_extent_range()
2780 		space_info->max_extent_size = 0;  in unpin_extent_range()
2781 		__btrfs_mod_total_bytes_pinned(space_info, -len);  in unpin_extent_range()
2782 		if (cache->ro) {  in unpin_extent_range()
2783 			space_info->bytes_readonly += len;  in unpin_extent_range()
2786 		spin_unlock(&cache->lock);  in unpin_extent_range()
2788 		    global_rsv->space_info == space_info) {  in unpin_extent_range()
2791 			spin_lock(&global_rsv->lock);  in unpin_extent_range()
2792 			if (!global_rsv->full) {  in unpin_extent_range()
2793 				to_add = min(len, global_rsv->size -  in unpin_extent_range()
2794 					     global_rsv->reserved);  in unpin_extent_range()
2795 				global_rsv->reserved += to_add;  in unpin_extent_range()
2798 				if (global_rsv->reserved >= global_rsv->size)  in unpin_extent_range()
2799 					global_rsv->full = 1;  in unpin_extent_range()
2800 				len -= to_add;  in unpin_extent_range()
2802 			spin_unlock(&global_rsv->lock);  in unpin_extent_range()
2807 		spin_unlock(&space_info->lock);  in unpin_extent_range()
2817 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_finish_extent_commit()
2825 	unpin = &trans->transaction->pinned_extents;  in btrfs_finish_extent_commit()
2830 		mutex_lock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2834 			mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2837 		if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))  in btrfs_finish_extent_commit()
2838 			clear_extent_bits(&fs_info->excluded_extents, start,  in btrfs_finish_extent_commit()
2843 						   end + 1 - start, NULL);  in btrfs_finish_extent_commit()
2847 		mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2853 		btrfs_discard_calc_delay(&fs_info->discard_ctl);  in btrfs_finish_extent_commit()
2854 		btrfs_discard_schedule_work(&fs_info->discard_ctl, true);  in btrfs_finish_extent_commit()
2862 	deleted_bgs = &trans->transaction->deleted_bgs;  in btrfs_finish_extent_commit()
2866 		ret = -EROFS;  in btrfs_finish_extent_commit()
2869 						   block_group->start,  in btrfs_finish_extent_commit()
2870 						   block_group->length,  in btrfs_finish_extent_commit()
2873 		list_del_init(&block_group->bg_list);  in btrfs_finish_extent_commit()
2908  *    node->bytenr = 13631488
2909  *    node->num_bytes = 1048576
2933  *    node->bytenr = 13631488
2934  *    node->num_bytes = 1048576
2953 	struct btrfs_fs_info *info = trans->fs_info;  in __btrfs_free_extent()
2956 	struct btrfs_root *extent_root = info->extent_root;  in __btrfs_free_extent()
2967 	u64 bytenr = node->bytenr;  in __btrfs_free_extent()
2968 	u64 num_bytes = node->num_bytes;  in __btrfs_free_extent()
2974 		return -ENOMEM;  in __btrfs_free_extent()
2976 	path->leave_spinning = 1;  in __btrfs_free_extent()
2983 			   node->bytenr, refs_to_drop);  in __btrfs_free_extent()
2984 		ret = -EINVAL;  in __btrfs_free_extent()
3003 		extent_slot = path->slots[0];  in __btrfs_free_extent()
3005 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3021 			if (path->slots[0] - extent_slot > 5)  in __btrfs_free_extent()
3023 			extent_slot--;  in __btrfs_free_extent()
3029 "invalid iref, no EXTENT/METADATA_ITEM found but has inline extent ref");  in __btrfs_free_extent()
3030 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3042 			path->leave_spinning = 1;  in __btrfs_free_extent()
3055 						&key, path, -1, 1);  in __btrfs_free_extent()
3056 			if (ret > 0 && skinny_metadata && path->slots[0]) {  in __btrfs_free_extent()
3061 				path->slots[0]--;  in __btrfs_free_extent()
3062 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3063 						      path->slots[0]);  in __btrfs_free_extent()
3077 							&key, path, -1, 1);  in __btrfs_free_extent()
3085 					btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3091 			extent_slot = path->slots[0];  in __btrfs_free_extent()
3093 	} else if (WARN_ON(ret == -ENOENT)) {  in __btrfs_free_extent()
3094 		btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3106 	leaf = path->nodes[0];  in __btrfs_free_extent()
3109 		ret = -EINVAL;  in __btrfs_free_extent()
3125 			btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3137 		btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3140 	refs -= refs_to_drop;  in __btrfs_free_extent()
3152 "invalid iref, got inlined extent ref but no EXTENT/METADATA_ITEM found");  in __btrfs_free_extent()
3153 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3178 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3182 				if (path->slots[0] != extent_slot) {  in __btrfs_free_extent()
3187 					btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3192 				 * No inline ref, we must be at SHARED_* item,  in __btrfs_free_extent()
3197 				if (path->slots[0] != extent_slot + 1) {  in __btrfs_free_extent()
3200 					btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3203 				path->slots[0] = extent_slot;  in __btrfs_free_extent()
3209 		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],  in __btrfs_free_extent()
3218 			ret = btrfs_del_csums(trans, info->csum_root, bytenr,  in __btrfs_free_extent()
3249 		btrfs_crit(info, "path->slots[0]=%d extent_slot=%d",  in __btrfs_free_extent()
3250 			   path->slots[0], extent_slot);  in __btrfs_free_extent()
3251 		btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3255 	return -EUCLEAN;  in __btrfs_free_extent()
3261  * a given extent, and if there are no other delayed refs to be processed, it
3271 	delayed_refs = &trans->transaction->delayed_refs;  in check_ref_cleanup()
3272 	spin_lock(&delayed_refs->lock);  in check_ref_cleanup()
3277 	spin_lock(&head->lock);  in check_ref_cleanup()
3278 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in check_ref_cleanup()
3288 	if (!mutex_trylock(&head->mutex))  in check_ref_cleanup()
3292 	head->processing = 0;  in check_ref_cleanup()
3294 	spin_unlock(&head->lock);  in check_ref_cleanup()
3295 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3297 	BUG_ON(head->extent_op);  in check_ref_cleanup()
3298 	if (head->must_insert_reserved)  in check_ref_cleanup()
3301 	btrfs_cleanup_ref_head_accounting(trans->fs_info, delayed_refs, head);  in check_ref_cleanup()
3302 	mutex_unlock(&head->mutex);  in check_ref_cleanup()
3306 	spin_unlock(&head->lock);  in check_ref_cleanup()
3309 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3318 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_free_tree_block()
3323 			       buf->start, buf->len, parent);  in btrfs_free_tree_block()
3325 			    root->root_key.objectid);  in btrfs_free_tree_block()
3327 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_tree_block()
3330 		BUG_ON(ret); /* -ENOMEM */  in btrfs_free_tree_block()
3333 	if (last_ref && btrfs_header_generation(buf) == trans->transid) {  in btrfs_free_tree_block()
3336 		if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_tree_block()
3337 			ret = check_ref_cleanup(trans, buf->start);  in btrfs_free_tree_block()
3342 		cache = btrfs_lookup_block_group(fs_info, buf->start);  in btrfs_free_tree_block()
3345 			pin_down_extent(trans, cache, buf->start, buf->len, 1);  in btrfs_free_tree_block()
3350 		WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));  in btrfs_free_tree_block()
3352 		btrfs_add_free_space(cache, buf->start, buf->len);  in btrfs_free_tree_block()
3353 		btrfs_free_reserved_bytes(cache, buf->len, 0);  in btrfs_free_tree_block()
3355 		trace_btrfs_reserved_extent_free(fs_info, buf->start, buf->len);  in btrfs_free_tree_block()
3363 		clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);  in btrfs_free_tree_block()
3367 /* Can return -ENOMEM */
3370 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_free_extent()
3380 	if ((ref->type == BTRFS_REF_METADATA &&  in btrfs_free_extent()
3381 	     ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID) ||  in btrfs_free_extent()
3382 	    (ref->type == BTRFS_REF_DATA &&  in btrfs_free_extent()
3383 	     ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)) {  in btrfs_free_extent()
3385 		btrfs_pin_extent(trans, ref->bytenr, ref->len, 1);  in btrfs_free_extent()
3387 	} else if (ref->type == BTRFS_REF_METADATA) {  in btrfs_free_extent()
3393 	if (!((ref->type == BTRFS_REF_METADATA &&  in btrfs_free_extent()
3394 	       ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID) ||  in btrfs_free_extent()
3395 	      (ref->type == BTRFS_REF_DATA &&  in btrfs_free_extent()
3396 	       ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)))  in btrfs_free_extent()
3414 		down_read(&cache->data_rwsem);  in btrfs_lock_block_group()
3422 		down_read(&cache->data_rwsem);  in btrfs_grab_block_group()
3429 	__acquires(&cluster->refill_lock)  in btrfs_lock_cluster()
3433 	spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3435 		used_bg = cluster->block_group;  in btrfs_lock_cluster()
3447 		if (down_read_trylock(&used_bg->data_rwsem))  in btrfs_lock_cluster()
3450 		spin_unlock(&cluster->refill_lock);  in btrfs_lock_cluster()
3452 		/* We should only have one-level nested. */  in btrfs_lock_cluster()
3453 		down_read_nested(&used_bg->data_rwsem, SINGLE_DEPTH_NESTING);  in btrfs_lock_cluster()
3455 		spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3456 		if (used_bg == cluster->block_group)  in btrfs_lock_cluster()
3459 		up_read(&used_bg->data_rwsem);  in btrfs_lock_cluster()
3469 		up_read(&cache->data_rwsem);  in btrfs_release_block_group()
3508 	 * Whether we're refilling a cluster, if true we need to re-search
3514 	 * Whether we're updating free space cache, if true we need to re-search
3542  * Return -ENOENT to inform caller that we need fallback to unclustered mode.
3543  * Return -EAGAIN to inform caller that we need to re-search this block group
3545  * Return 0 means we have found a location and set ffe_ctl->found_offset.
3552 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_clustered()
3557 	cluster_bg = btrfs_lock_cluster(bg, last_ptr, ffe_ctl->delalloc);  in find_free_extent_clustered()
3560 	if (cluster_bg != bg && (cluster_bg->ro ||  in find_free_extent_clustered()
3561 	    !block_group_bits(cluster_bg, ffe_ctl->flags)))  in find_free_extent_clustered()
3565 			ffe_ctl->num_bytes, cluster_bg->start,  in find_free_extent_clustered()
3566 			&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3569 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3571 				ffe_ctl->search_start, ffe_ctl->num_bytes);  in find_free_extent_clustered()
3573 		ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3576 	WARN_ON(last_ptr->block_group != cluster_bg);  in find_free_extent_clustered()
3590 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE && cluster_bg != bg) {  in find_free_extent_clustered()
3591 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3592 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3593 		return -ENOENT;  in find_free_extent_clustered()
3600 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3603 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE) {  in find_free_extent_clustered()
3604 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3605 		return -ENOENT;  in find_free_extent_clustered()
3609 			ffe_ctl->empty_cluster + ffe_ctl->empty_size,  in find_free_extent_clustered()
3610 			bg->full_stripe_len);  in find_free_extent_clustered()
3611 	ret = btrfs_find_space_cluster(bg, last_ptr, ffe_ctl->search_start,  in find_free_extent_clustered()
3612 			ffe_ctl->num_bytes, aligned_cluster);  in find_free_extent_clustered()
3616 				ffe_ctl->num_bytes, ffe_ctl->search_start,  in find_free_extent_clustered()
3617 				&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3620 			spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3622 					ffe_ctl->search_start,  in find_free_extent_clustered()
3623 					ffe_ctl->num_bytes);  in find_free_extent_clustered()
3624 			ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3627 	} else if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&  in find_free_extent_clustered()
3628 		   !ffe_ctl->retry_clustered) {  in find_free_extent_clustered()
3629 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3631 		ffe_ctl->retry_clustered = true;  in find_free_extent_clustered()
3632 		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +  in find_free_extent_clustered()
3633 				ffe_ctl->empty_cluster + ffe_ctl->empty_size);  in find_free_extent_clustered()
3634 		return -EAGAIN;  in find_free_extent_clustered()
3642 	spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3648  * Return 0 when we found an free extent and set ffe_ctrl->found_offset
3649  * Return -EAGAIN to inform caller that we need to re-search this block group
3654 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_unclustered()
3663 		spin_lock(&last_ptr->lock);  in find_free_extent_unclustered()
3664 		last_ptr->fragmented = 1;  in find_free_extent_unclustered()
3665 		spin_unlock(&last_ptr->lock);  in find_free_extent_unclustered()
3667 	if (ffe_ctl->cached) {  in find_free_extent_unclustered()
3670 		free_space_ctl = bg->free_space_ctl;  in find_free_extent_unclustered()
3671 		spin_lock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3672 		if (free_space_ctl->free_space <  in find_free_extent_unclustered()
3673 		    ffe_ctl->num_bytes + ffe_ctl->empty_cluster +  in find_free_extent_unclustered()
3674 		    ffe_ctl->empty_size) {  in find_free_extent_unclustered()
3675 			ffe_ctl->total_free_space = max_t(u64,  in find_free_extent_unclustered()
3676 					ffe_ctl->total_free_space,  in find_free_extent_unclustered()
3677 					free_space_ctl->free_space);  in find_free_extent_unclustered()
3678 			spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3681 		spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3684 	offset = btrfs_find_space_for_alloc(bg, ffe_ctl->search_start,  in find_free_extent_unclustered()
3685 			ffe_ctl->num_bytes, ffe_ctl->empty_size,  in find_free_extent_unclustered()
3686 			&ffe_ctl->max_extent_size);  in find_free_extent_unclustered()
3697 	if (!offset && !ffe_ctl->retry_unclustered && !ffe_ctl->cached &&  in find_free_extent_unclustered()
3698 	    ffe_ctl->loop > LOOP_CACHING_NOWAIT) {  in find_free_extent_unclustered()
3699 		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +  in find_free_extent_unclustered()
3700 						      ffe_ctl->empty_size);  in find_free_extent_unclustered()
3701 		ffe_ctl->retry_unclustered = true;  in find_free_extent_unclustered()
3702 		return -EAGAIN;  in find_free_extent_unclustered()
3706 	ffe_ctl->found_offset = offset;  in find_free_extent_unclustered()
3717 	if (ffe_ctl->last_ptr && ffe_ctl->use_cluster) {  in do_allocation_clustered()
3719 		if (ret >= 0 || ret == -EAGAIN)  in do_allocation_clustered()
3721 		/* ret == -ENOENT case falls through */  in do_allocation_clustered()
3731 	switch (ffe_ctl->policy) {  in do_allocation()
3743 	switch (ffe_ctl->policy) {  in release_block_group()
3745 		ffe_ctl->retry_clustered = false;  in release_block_group()
3746 		ffe_ctl->retry_unclustered = false;  in release_block_group()
3752 	BUG_ON(btrfs_bg_flags_to_raid_index(block_group->flags) !=  in release_block_group()
3753 	       ffe_ctl->index);  in release_block_group()
3760 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in found_extent_clustered()
3762 	if (!ffe_ctl->use_cluster && last_ptr) {  in found_extent_clustered()
3763 		spin_lock(&last_ptr->lock);  in found_extent_clustered()
3764 		last_ptr->window_start = ins->objectid;  in found_extent_clustered()
3765 		spin_unlock(&last_ptr->lock);  in found_extent_clustered()
3772 	switch (ffe_ctl->policy) {  in found_extent()
3783 	switch (ffe_ctl->policy) {  in chunk_allocation_failed()
3789 		ffe_ctl->loop = LOOP_NO_EMPTY_SIZE;  in chunk_allocation_failed()
3797  * Return >0 means caller needs to re-search for free extent
3806 	struct btrfs_root *root = fs_info->extent_root;  in find_free_extent_update_loop()
3809 	if ((ffe_ctl->loop == LOOP_CACHING_NOWAIT) &&  in find_free_extent_update_loop()
3810 	    ffe_ctl->have_caching_bg && !ffe_ctl->orig_have_caching_bg)  in find_free_extent_update_loop()
3811 		ffe_ctl->orig_have_caching_bg = true;  in find_free_extent_update_loop()
3813 	if (!ins->objectid && ffe_ctl->loop >= LOOP_CACHING_WAIT &&  in find_free_extent_update_loop()
3814 	    ffe_ctl->have_caching_bg)  in find_free_extent_update_loop()
3817 	if (!ins->objectid && ++(ffe_ctl->index) < BTRFS_NR_RAID_TYPES)  in find_free_extent_update_loop()
3820 	if (ins->objectid) {  in find_free_extent_update_loop()
3833 	if (ffe_ctl->loop < LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
3834 		ffe_ctl->index = 0;  in find_free_extent_update_loop()
3835 		if (ffe_ctl->loop == LOOP_CACHING_NOWAIT) {  in find_free_extent_update_loop()
3841 			if (ffe_ctl->orig_have_caching_bg || !full_search)  in find_free_extent_update_loop()
3842 				ffe_ctl->loop = LOOP_CACHING_WAIT;  in find_free_extent_update_loop()
3844 				ffe_ctl->loop = LOOP_ALLOC_CHUNK;  in find_free_extent_update_loop()
3846 			ffe_ctl->loop++;  in find_free_extent_update_loop()
3849 		if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {  in find_free_extent_update_loop()
3853 			trans = current->journal_info;  in find_free_extent_update_loop()
3864 			ret = btrfs_chunk_alloc(trans, ffe_ctl->flags,  in find_free_extent_update_loop()
3868 			if (ret == -ENOSPC)  in find_free_extent_update_loop()
3880 		if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
3881 			if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)  in find_free_extent_update_loop()
3882 				return -ENOSPC;  in find_free_extent_update_loop()
3885 			 * Don't loop again if we already have no empty_size and  in find_free_extent_update_loop()
3886 			 * no empty_cluster.  in find_free_extent_update_loop()
3888 			if (ffe_ctl->empty_size == 0 &&  in find_free_extent_update_loop()
3889 			    ffe_ctl->empty_cluster == 0)  in find_free_extent_update_loop()
3890 				return -ENOSPC;  in find_free_extent_update_loop()
3891 			ffe_ctl->empty_size = 0;  in find_free_extent_update_loop()
3892 			ffe_ctl->empty_cluster = 0;  in find_free_extent_update_loop()
3896 	return -ENOSPC;  in find_free_extent_update_loop()
3914 	if (space_info->max_extent_size) {  in prepare_allocation_clustered()
3915 		spin_lock(&space_info->lock);  in prepare_allocation_clustered()
3916 		if (space_info->max_extent_size &&  in prepare_allocation_clustered()
3917 		    ffe_ctl->num_bytes > space_info->max_extent_size) {  in prepare_allocation_clustered()
3918 			ins->offset = space_info->max_extent_size;  in prepare_allocation_clustered()
3919 			spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
3920 			return -ENOSPC;  in prepare_allocation_clustered()
3921 		} else if (space_info->max_extent_size) {  in prepare_allocation_clustered()
3922 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
3924 		spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
3927 	ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,  in prepare_allocation_clustered()
3928 					       &ffe_ctl->empty_cluster);  in prepare_allocation_clustered()
3929 	if (ffe_ctl->last_ptr) {  in prepare_allocation_clustered()
3930 		struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in prepare_allocation_clustered()
3932 		spin_lock(&last_ptr->lock);  in prepare_allocation_clustered()
3933 		if (last_ptr->block_group)  in prepare_allocation_clustered()
3934 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
3935 		if (last_ptr->fragmented) {  in prepare_allocation_clustered()
3941 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
3942 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
3944 		spin_unlock(&last_ptr->lock);  in prepare_allocation_clustered()
3955 	switch (ffe_ctl->policy) {  in prepare_allocation()
3967  * ins->objectid == start position
3968  * ins->flags = BTRFS_EXTENT_ITEM_KEY
3969  * ins->offset == the size of the hole.
3972  * If there is no suitable free space, we will record the max size of
3978  * |- Iterate through all block groups
3979  * |  |- Get a valid block group
3980  * |  |- Try to do clustered allocation in that block group
3981  * |  |- Try to do unclustered allocation in that block group
3982  * |  |- Check if the result is valid
3983  * |  |  |- If valid, then exit
3984  * |  |- Jump to next block group
3986  * |- Push harder to find free extents
3987  *    |- If not found, re-iterate all block groups
3994 	struct btrfs_fs_info *fs_info = root->fs_info;  in find_free_extent()
4002 	WARN_ON(num_bytes < fs_info->sectorsize);  in find_free_extent()
4022 	ins->type = BTRFS_EXTENT_ITEM_KEY;  in find_free_extent()
4023 	ins->objectid = 0;  in find_free_extent()
4024 	ins->offset = 0;  in find_free_extent()
4030 		btrfs_err(fs_info, "No space info for %llu", flags);  in find_free_extent()
4031 		return -ENOSPC;  in find_free_extent()
4048 		 * However if we are re-searching with an ideal block group  in find_free_extent()
4052 		    block_group->cached != BTRFS_CACHE_NO) {  in find_free_extent()
4053 			down_read(&space_info->groups_sem);  in find_free_extent()
4054 			if (list_empty(&block_group->list) ||  in find_free_extent()
4055 			    block_group->ro) {  in find_free_extent()
4063 				up_read(&space_info->groups_sem);  in find_free_extent()
4066 						block_group->flags);  in find_free_extent()
4079 	down_read(&space_info->groups_sem);  in find_free_extent()
4081 			    &space_info->block_groups[ffe_ctl.index], list) {  in find_free_extent()
4084 		/* If the block group is read-only, we can skip it entirely. */  in find_free_extent()
4085 		if (unlikely(block_group->ro))  in find_free_extent()
4089 		ffe_ctl.search_start = block_group->start;  in find_free_extent()
4107 			if ((flags & extra) && !(block_group->flags & extra))  in find_free_extent()
4112 			 * It's possible that we have MIXED_GROUP flag but no  in find_free_extent()
4141 		if (unlikely(block_group->cached == BTRFS_CACHE_ERROR))  in find_free_extent()
4151 		} else if (ret == -EAGAIN) {  in find_free_extent()
4159 					     fs_info->stripesize);  in find_free_extent()
4163 		    block_group->start + block_group->length) {  in find_free_extent()
4171 				ffe_ctl.search_start - ffe_ctl.found_offset);  in find_free_extent()
4175 		if (ret == -EAGAIN) {  in find_free_extent()
4183 		ins->objectid = ffe_ctl.search_start;  in find_free_extent()
4184 		ins->offset = num_bytes;  in find_free_extent()
4194 	up_read(&space_info->groups_sem);  in find_free_extent()
4200 	if (ret == -ENOSPC && !cache_block_group_error) {  in find_free_extent()
4202 		 * Use ffe_ctl->total_free_space as fallback if we can't find  in find_free_extent()
4207 		spin_lock(&space_info->lock);  in find_free_extent()
4208 		space_info->max_extent_size = ffe_ctl.max_extent_size;  in find_free_extent()
4209 		spin_unlock(&space_info->lock);  in find_free_extent()
4210 		ins->offset = ffe_ctl.max_extent_size;  in find_free_extent()
4211 	} else if (ret == -ENOSPC) {  in find_free_extent()
4218  * btrfs_reserve_extent - entry point to the extent allocator. Tries to find a
4221  * @root           -	The root that will contain this extent
4223  * @ram_bytes      -	The amount of space in ram that @num_bytes take. This
4227  * @num_bytes      -	Number of bytes to allocate on-disk.
4229  * @min_alloc_size -	Indicates the minimum amount of space that the
4236  * @empty_size     -	A hint that you plan on doing more COW. This is the
4241  * @hint_byte      -	Hint to the allocator to start searching above the byte
4244  * @ins            -	This key is modified to record the found hole. It will
4246  *			ins->objectid == start position
4247  *			ins->flags = BTRFS_EXTENT_ITEM_KEY
4248  *			ins->offset == the size of the hole.
4250  * @is_data        -	Boolean flag indicating whether an extent is
4253  * @delalloc       -	Boolean flag indicating whether this allocation is for
4259  * case -ENOSPC is returned then @ins->offset will contain the size of the
4267 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_reserve_extent()
4274 	WARN_ON(num_bytes < fs_info->sectorsize);  in btrfs_reserve_extent()
4278 		btrfs_dec_block_group_reservations(fs_info, ins->objectid);  in btrfs_reserve_extent()
4279 	} else if (ret == -ENOSPC) {  in btrfs_reserve_extent()
4280 		if (!final_tried && ins->offset) {  in btrfs_reserve_extent()
4281 			num_bytes = min(num_bytes >> 1, ins->offset);  in btrfs_reserve_extent()
4283 					       fs_info->sectorsize);  in btrfs_reserve_extent()
4314 		return -ENOSPC;  in btrfs_free_reserved_extent()
4331 	cache = btrfs_lookup_block_group(trans->fs_info, start);  in btrfs_pin_reserved_extent()
4333 		btrfs_err(trans->fs_info, "unable to find block group for %llu",  in btrfs_pin_reserved_extent()
4335 		return -ENOSPC;  in btrfs_pin_reserved_extent()
4348 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_file_extent()
4366 		return -ENOMEM;  in alloc_reserved_file_extent()
4368 	path->leave_spinning = 1;  in alloc_reserved_file_extent()
4369 	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,  in alloc_reserved_file_extent()
4376 	leaf = path->nodes[0];  in alloc_reserved_file_extent()
4377 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_file_extent()
4380 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_file_extent()
4393 		ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in alloc_reserved_file_extent()
4400 	btrfs_mark_buffer_dirty(path->nodes[0]);  in alloc_reserved_file_extent()
4403 	ret = remove_from_free_space_tree(trans, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4407 	ret = btrfs_update_block_group(trans, ins->objectid, ins->offset, 1);  in alloc_reserved_file_extent()
4408 	if (ret) { /* -ENOENT, logic error */  in alloc_reserved_file_extent()
4410 			ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4413 	trace_btrfs_reserved_extent_alloc(fs_info, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4421 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_tree_block()
4432 	u64 flags = extent_op->flags_to_set;  in alloc_reserved_tree_block()
4437 	extent_key.objectid = node->bytenr;  in alloc_reserved_tree_block()
4439 		extent_key.offset = ref->level;  in alloc_reserved_tree_block()
4441 		num_bytes = fs_info->nodesize;  in alloc_reserved_tree_block()
4443 		extent_key.offset = node->num_bytes;  in alloc_reserved_tree_block()
4446 		num_bytes = node->num_bytes;  in alloc_reserved_tree_block()
4451 		return -ENOMEM;  in alloc_reserved_tree_block()
4453 	path->leave_spinning = 1;  in alloc_reserved_tree_block()
4454 	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,  in alloc_reserved_tree_block()
4461 	leaf = path->nodes[0];  in alloc_reserved_tree_block()
4462 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_tree_block()
4465 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_tree_block()
4473 		btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);  in alloc_reserved_tree_block()
4474 		btrfs_set_tree_block_level(leaf, block_info, ref->level);  in alloc_reserved_tree_block()
4478 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY) {  in alloc_reserved_tree_block()
4482 		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->parent);  in alloc_reserved_tree_block()
4486 		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->root);  in alloc_reserved_tree_block()
4498 				       fs_info->nodesize, 1);  in alloc_reserved_tree_block()
4499 	if (ret) { /* -ENOENT, logic error */  in alloc_reserved_tree_block()
4506 					  fs_info->nodesize);  in alloc_reserved_tree_block()
4517 	BUG_ON(root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);  in btrfs_alloc_reserved_file_extent()
4520 			       ins->objectid, ins->offset, 0);  in btrfs_alloc_reserved_file_extent()
4521 	btrfs_init_data_ref(&generic_ref, root->root_key.objectid, owner, offset);  in btrfs_alloc_reserved_file_extent()
4522 	btrfs_ref_tree_mod(root->fs_info, &generic_ref);  in btrfs_alloc_reserved_file_extent()
4536 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_alloc_logged_file_extent()
4546 		ret = __exclude_logged_extent(fs_info, ins->objectid,  in btrfs_alloc_logged_file_extent()
4547 					      ins->offset);  in btrfs_alloc_logged_file_extent()
4552 	block_group = btrfs_lookup_block_group(fs_info, ins->objectid);  in btrfs_alloc_logged_file_extent()
4554 		return -EINVAL;  in btrfs_alloc_logged_file_extent()
4556 	space_info = block_group->space_info;  in btrfs_alloc_logged_file_extent()
4557 	spin_lock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
4558 	spin_lock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
4559 	space_info->bytes_reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
4560 	block_group->reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
4561 	spin_unlock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
4562 	spin_unlock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
4567 		btrfs_pin_extent(trans, ins->objectid, ins->offset, 1);  in btrfs_alloc_logged_file_extent()
4577 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_init_new_buffer()
4589 	if (buf->lock_owner == current->pid) {  in btrfs_init_new_buffer()
4592 			buf->start, btrfs_header_owner(buf), current->pid);  in btrfs_init_new_buffer()
4594 		return ERR_PTR(-EUCLEAN);  in btrfs_init_new_buffer()
4600 	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);  in btrfs_init_new_buffer()
4607 	btrfs_set_header_bytenr(buf, buf->start);  in btrfs_init_new_buffer()
4608 	btrfs_set_header_generation(buf, trans->transid);  in btrfs_init_new_buffer()
4611 	write_extent_buffer_fsid(buf, fs_info->fs_devices->metadata_uuid);  in btrfs_init_new_buffer()
4612 	write_extent_buffer_chunk_tree_uuid(buf, fs_info->chunk_tree_uuid);  in btrfs_init_new_buffer()
4613 	if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {  in btrfs_init_new_buffer()
4614 		buf->log_index = root->log_transid % 2;  in btrfs_init_new_buffer()
4619 		if (buf->log_index == 0)  in btrfs_init_new_buffer()
4620 			set_extent_dirty(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
4621 					buf->start + buf->len - 1, GFP_NOFS);  in btrfs_init_new_buffer()
4623 			set_extent_new(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
4624 					buf->start + buf->len - 1);  in btrfs_init_new_buffer()
4626 		buf->log_index = -1;  in btrfs_init_new_buffer()
4627 		set_extent_dirty(&trans->transaction->dirty_pages, buf->start,  in btrfs_init_new_buffer()
4628 			 buf->start + buf->len - 1, GFP_NOFS);  in btrfs_init_new_buffer()
4630 	trans->dirty = true;  in btrfs_init_new_buffer()
4647 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_alloc_tree_block()
4655 	u32 blocksize = fs_info->nodesize;  in btrfs_alloc_tree_block()
4660 		buf = btrfs_init_new_buffer(trans, root, root->alloc_bytenr,  in btrfs_alloc_tree_block()
4663 			root->alloc_bytenr += blocksize;  in btrfs_alloc_tree_block()
4694 			ret = -ENOMEM;  in btrfs_alloc_tree_block()
4698 			memcpy(&extent_op->key, key, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
4700 			memset(&extent_op->key, 0, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
4701 		extent_op->flags_to_set = flags;  in btrfs_alloc_tree_block()
4702 		extent_op->update_key = skinny_metadata ? false : true;  in btrfs_alloc_tree_block()
4703 		extent_op->update_flags = true;  in btrfs_alloc_tree_block()
4704 		extent_op->is_data = false;  in btrfs_alloc_tree_block()
4705 		extent_op->level = level;  in btrfs_alloc_tree_block()
4709 		generic_ref.real_root = root->root_key.objectid;  in btrfs_alloc_tree_block()
4751 				     struct walk_control *wc,  in reada_walk_down()  argument
4754 	struct btrfs_fs_info *fs_info = root->fs_info;  in reada_walk_down()
4766 	if (path->slots[wc->level] < wc->reada_slot) {  in reada_walk_down()
4767 		wc->reada_count = wc->reada_count * 2 / 3;  in reada_walk_down()
4768 		wc->reada_count = max(wc->reada_count, 2);  in reada_walk_down()
4770 		wc->reada_count = wc->reada_count * 3 / 2;  in reada_walk_down()
4771 		wc->reada_count = min_t(int, wc->reada_count,  in reada_walk_down()
4775 	eb = path->nodes[wc->level];  in reada_walk_down()
4778 	for (slot = path->slots[wc->level]; slot < nritems; slot++) {  in reada_walk_down()
4779 		if (nread >= wc->reada_count)  in reada_walk_down()
4786 		if (slot == path->slots[wc->level])  in reada_walk_down()
4789 		if (wc->stage == UPDATE_BACKREF &&  in reada_walk_down()
4790 		    generation <= root->root_key.offset)  in reada_walk_down()
4795 					       wc->level - 1, 1, &refs,  in reada_walk_down()
4802 		if (wc->stage == DROP_REFERENCE) {  in reada_walk_down()
4806 			if (wc->level == 1 &&  in reada_walk_down()
4809 			if (!wc->update_ref ||  in reada_walk_down()
4810 			    generation <= root->root_key.offset)  in reada_walk_down()
4814 						  &wc->update_progress);  in reada_walk_down()
4818 			if (wc->level == 1 &&  in reada_walk_down()
4826 	wc->reada_slot = slot;  in reada_walk_down()
4832  * when wc->stage == UPDATE_BACKREF, this function updates
4840 				   struct walk_control *wc, int lookup_info)  in walk_down_proc()  argument
4842 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_down_proc()
4843 	int level = wc->level;  in walk_down_proc()
4844 	struct extent_buffer *eb = path->nodes[level];  in walk_down_proc()
4848 	if (wc->stage == UPDATE_BACKREF &&  in walk_down_proc()
4849 	    btrfs_header_owner(eb) != root->root_key.objectid)  in walk_down_proc()
4857 	    ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||  in walk_down_proc()
4858 	     (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {  in walk_down_proc()
4859 		BUG_ON(!path->locks[level]);  in walk_down_proc()
4861 					       eb->start, level, 1,  in walk_down_proc()
4862 					       &wc->refs[level],  in walk_down_proc()
4863 					       &wc->flags[level]);  in walk_down_proc()
4864 		BUG_ON(ret == -ENOMEM);  in walk_down_proc()
4867 		BUG_ON(wc->refs[level] == 0);  in walk_down_proc()
4870 	if (wc->stage == DROP_REFERENCE) {  in walk_down_proc()
4871 		if (wc->refs[level] > 1)  in walk_down_proc()
4874 		if (path->locks[level] && !wc->keep_locks) {  in walk_down_proc()
4875 			btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
4876 			path->locks[level] = 0;  in walk_down_proc()
4881 	/* wc->stage == UPDATE_BACKREF */  in walk_down_proc()
4882 	if (!(wc->flags[level] & flag)) {  in walk_down_proc()
4883 		BUG_ON(!path->locks[level]);  in walk_down_proc()
4885 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4887 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4890 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4891 		wc->flags[level] |= flag;  in walk_down_proc()
4898 	if (path->locks[level] && level > 0) {  in walk_down_proc()
4899 		btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
4900 		path->locks[level] = 0;  in walk_down_proc()
4919 		return -ENOMEM;  in check_ref_exists()
4922 				    root->fs_info->nodesize, parent,  in check_ref_exists()
4923 				    root->root_key.objectid, level, 0);  in check_ref_exists()
4925 	if (ret == -ENOENT)  in check_ref_exists()
4935  * when wc->stage == DROP_REFERENCE, this function checks
4938  * rooted at the block, this function changes wc->stage to
4939  * UPDATE_BACKREF. if the block is shared and there is no
4948 				 struct walk_control *wc, int *lookup_info)  in do_walk_down()  argument
4950 	struct btrfs_fs_info *fs_info = root->fs_info;  in do_walk_down()
4958 	int level = wc->level;  in do_walk_down()
4963 	generation = btrfs_node_ptr_generation(path->nodes[level],  in do_walk_down()
4964 					       path->slots[level]);  in do_walk_down()
4967 	 * was created, we know there is no need to update back refs  in do_walk_down()
4970 	if (wc->stage == UPDATE_BACKREF &&  in do_walk_down()
4971 	    generation <= root->root_key.offset) {  in do_walk_down()
4976 	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);  in do_walk_down()
4977 	btrfs_node_key_to_cpu(path->nodes[level], &first_key,  in do_walk_down()
4978 			      path->slots[level]);  in do_walk_down()
4986 		btrfs_set_buffer_lockdep_class(root->root_key.objectid, next,  in do_walk_down()
4987 					       level - 1);  in do_walk_down()
4993 	ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,  in do_walk_down()
4994 				       &wc->refs[level - 1],  in do_walk_down()
4995 				       &wc->flags[level - 1]);  in do_walk_down()
4999 	if (unlikely(wc->refs[level - 1] == 0)) {  in do_walk_down()
5001 		ret = -EIO;  in do_walk_down()
5006 	if (wc->stage == DROP_REFERENCE) {  in do_walk_down()
5007 		if (wc->refs[level - 1] > 1) {  in do_walk_down()
5010 			    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))  in do_walk_down()
5013 			if (!wc->update_ref ||  in do_walk_down()
5014 			    generation <= root->root_key.offset)  in do_walk_down()
5017 			btrfs_node_key_to_cpu(path->nodes[level], &key,  in do_walk_down()
5018 					      path->slots[level]);  in do_walk_down()
5019 			ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);  in do_walk_down()
5023 			wc->stage = UPDATE_BACKREF;  in do_walk_down()
5024 			wc->shared_level = level - 1;  in do_walk_down()
5028 		    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))  in do_walk_down()
5041 			reada_walk_down(trans, root, wc, path);  in do_walk_down()
5042 		next = read_tree_block(fs_info, bytenr, generation, level - 1,  in do_walk_down()
5048 			return -EIO;  in do_walk_down()
5054 	level--;  in do_walk_down()
5057 		btrfs_err(root->fs_info, "mismatched level");  in do_walk_down()
5058 		ret = -EIO;  in do_walk_down()
5061 	path->nodes[level] = next;  in do_walk_down()
5062 	path->slots[level] = 0;  in do_walk_down()
5063 	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in do_walk_down()
5064 	wc->level = level;  in do_walk_down()
5065 	if (wc->level == 1)  in do_walk_down()
5066 		wc->reada_slot = 0;  in do_walk_down()
5069 	wc->refs[level - 1] = 0;  in do_walk_down()
5070 	wc->flags[level - 1] = 0;  in do_walk_down()
5071 	if (wc->stage == DROP_REFERENCE) {  in do_walk_down()
5072 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {  in do_walk_down()
5073 			parent = path->nodes[level]->start;  in do_walk_down()
5075 			ASSERT(root->root_key.objectid ==  in do_walk_down()
5076 			       btrfs_header_owner(path->nodes[level]));  in do_walk_down()
5077 			if (root->root_key.objectid !=  in do_walk_down()
5078 			    btrfs_header_owner(path->nodes[level])) {  in do_walk_down()
5079 				btrfs_err(root->fs_info,  in do_walk_down()
5081 				ret = -EIO;  in do_walk_down()
5091 		 * ->restarted flag.  in do_walk_down()
5093 		if (wc->restarted) {  in do_walk_down()
5095 					       level - 1);  in do_walk_down()
5101 			wc->restarted = 0;  in do_walk_down()
5109 		if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&  in do_walk_down()
5112 							 generation, level - 1);  in do_walk_down()
5126 		wc->drop_level = level;  in do_walk_down()
5127 		find_next_key(path, level, &wc->drop_progress);  in do_walk_down()
5130 				       fs_info->nodesize, parent);  in do_walk_down()
5131 		btrfs_init_tree_ref(&ref, level - 1, root->root_key.objectid);  in do_walk_down()
5150  * when wc->stage == DROP_REFERENCE, this function drops
5153  * when wc->stage == UPDATE_BACKREF, this function changes
5154  * wc->stage back to DROP_REFERENCE if we changed wc->stage
5162 				 struct walk_control *wc)  in walk_up_proc()  argument
5164 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_up_proc()
5166 	int level = wc->level;  in walk_up_proc()
5167 	struct extent_buffer *eb = path->nodes[level];  in walk_up_proc()
5170 	if (wc->stage == UPDATE_BACKREF) {  in walk_up_proc()
5171 		BUG_ON(wc->shared_level < level);  in walk_up_proc()
5172 		if (level < wc->shared_level)  in walk_up_proc()
5175 		ret = find_next_key(path, level + 1, &wc->update_progress);  in walk_up_proc()
5177 			wc->update_ref = 0;  in walk_up_proc()
5179 		wc->stage = DROP_REFERENCE;  in walk_up_proc()
5180 		wc->shared_level = -1;  in walk_up_proc()
5181 		path->slots[level] = 0;  in walk_up_proc()
5188 		if (!path->locks[level]) {  in walk_up_proc()
5192 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in walk_up_proc()
5195 						       eb->start, level, 1,  in walk_up_proc()
5196 						       &wc->refs[level],  in walk_up_proc()
5197 						       &wc->flags[level]);  in walk_up_proc()
5199 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5200 				path->locks[level] = 0;  in walk_up_proc()
5203 			BUG_ON(wc->refs[level] == 0);  in walk_up_proc()
5204 			if (wc->refs[level] == 1) {  in walk_up_proc()
5205 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5206 				path->locks[level] = 0;  in walk_up_proc()
5212 	/* wc->stage == DROP_REFERENCE */  in walk_up_proc()
5213 	BUG_ON(wc->refs[level] > 1 && !path->locks[level]);  in walk_up_proc()
5215 	if (wc->refs[level] == 1) {  in walk_up_proc()
5217 			if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5221 			BUG_ON(ret); /* -ENOMEM */  in walk_up_proc()
5222 			if (is_fstree(root->root_key.objectid)) {  in walk_up_proc()
5232 		if (!path->locks[level] &&  in walk_up_proc()
5233 		    btrfs_header_generation(eb) == trans->transid) {  in walk_up_proc()
5236 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in walk_up_proc()
5241 	if (eb == root->node) {  in walk_up_proc()
5242 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5243 			parent = eb->start;  in walk_up_proc()
5244 		else if (root->root_key.objectid != btrfs_header_owner(eb))  in walk_up_proc()
5247 		if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5248 			parent = path->nodes[level + 1]->start;  in walk_up_proc()
5249 		else if (root->root_key.objectid !=  in walk_up_proc()
5250 			 btrfs_header_owner(path->nodes[level + 1]))  in walk_up_proc()
5254 	btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);  in walk_up_proc()
5256 	wc->refs[level] = 0;  in walk_up_proc()
5257 	wc->flags[level] = 0;  in walk_up_proc()
5262 		     btrfs_header_owner(eb), root->root_key.objectid);  in walk_up_proc()
5263 	return -EUCLEAN;  in walk_up_proc()
5269 				   struct walk_control *wc)  in walk_down_tree()  argument
5271 	int level = wc->level;  in walk_down_tree()
5276 		ret = walk_down_proc(trans, root, path, wc, lookup_info);  in walk_down_tree()
5283 		if (path->slots[level] >=  in walk_down_tree()
5284 		    btrfs_header_nritems(path->nodes[level]))  in walk_down_tree()
5287 		ret = do_walk_down(trans, root, path, wc, &lookup_info);  in walk_down_tree()
5289 			path->slots[level]++;  in walk_down_tree()
5293 		level = wc->level;  in walk_down_tree()
5301 				 struct walk_control *wc, int max_level)  in walk_up_tree()  argument
5303 	int level = wc->level;  in walk_up_tree()
5306 	path->slots[level] = btrfs_header_nritems(path->nodes[level]);  in walk_up_tree()
5307 	while (level < max_level && path->nodes[level]) {  in walk_up_tree()
5308 		wc->level = level;  in walk_up_tree()
5309 		if (path->slots[level] + 1 <  in walk_up_tree()
5310 		    btrfs_header_nritems(path->nodes[level])) {  in walk_up_tree()
5311 			path->slots[level]++;  in walk_up_tree()
5314 			ret = walk_up_proc(trans, root, path, wc);  in walk_up_tree()
5320 			if (path->locks[level]) {  in walk_up_tree()
5321 				btrfs_tree_unlock_rw(path->nodes[level],  in walk_up_tree()
5322 						     path->locks[level]);  in walk_up_tree()
5323 				path->locks[level] = 0;  in walk_up_tree()
5325 			free_extent_buffer(path->nodes[level]);  in walk_up_tree()
5326 			path->nodes[level] = NULL;  in walk_up_tree()
5344  * If called with for_reloc == 0, may exit early with -EAGAIN
5348 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_snapshot()
5351 	struct btrfs_root *tree_root = fs_info->tree_root;  in btrfs_drop_snapshot()
5352 	struct btrfs_root_item *root_item = &root->root_item;  in btrfs_drop_snapshot()
5353 	struct walk_control *wc;  in btrfs_drop_snapshot()  local
5360 	btrfs_debug(fs_info, "Drop subvolume %llu", root->root_key.objectid);  in btrfs_drop_snapshot()
5364 		err = -ENOMEM;  in btrfs_drop_snapshot()
5368 	wc = kzalloc(sizeof(*wc), GFP_NOFS);  in btrfs_drop_snapshot()
5369 	if (!wc) {  in btrfs_drop_snapshot()
5371 		err = -ENOMEM;  in btrfs_drop_snapshot()
5400 	set_bit(BTRFS_ROOT_DELETING, &root->state);  in btrfs_drop_snapshot()
5401 	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {  in btrfs_drop_snapshot()
5402 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
5403 		path->nodes[level] = btrfs_lock_root_node(root);  in btrfs_drop_snapshot()
5404 		btrfs_set_lock_blocking_write(path->nodes[level]);  in btrfs_drop_snapshot()
5405 		path->slots[level] = 0;  in btrfs_drop_snapshot()
5406 		path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_snapshot()
5407 		memset(&wc->update_progress, 0,  in btrfs_drop_snapshot()
5408 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
5410 		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);  in btrfs_drop_snapshot()
5411 		memcpy(&wc->update_progress, &key,  in btrfs_drop_snapshot()
5412 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
5414 		level = root_item->drop_level;  in btrfs_drop_snapshot()
5416 		path->lowest_level = level;  in btrfs_drop_snapshot()
5418 		path->lowest_level = 0;  in btrfs_drop_snapshot()
5431 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
5433 			btrfs_tree_lock(path->nodes[level]);  in btrfs_drop_snapshot()
5434 			btrfs_set_lock_blocking_write(path->nodes[level]);  in btrfs_drop_snapshot()
5435 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_snapshot()
5438 						path->nodes[level]->start,  in btrfs_drop_snapshot()
5439 						level, 1, &wc->refs[level],  in btrfs_drop_snapshot()
5440 						&wc->flags[level]);  in btrfs_drop_snapshot()
5445 			BUG_ON(wc->refs[level] == 0);  in btrfs_drop_snapshot()
5447 			if (level == root_item->drop_level)  in btrfs_drop_snapshot()
5450 			btrfs_tree_unlock(path->nodes[level]);  in btrfs_drop_snapshot()
5451 			path->locks[level] = 0;  in btrfs_drop_snapshot()
5452 			WARN_ON(wc->refs[level] != 1);  in btrfs_drop_snapshot()
5453 			level--;  in btrfs_drop_snapshot()
5457 	wc->restarted = test_bit(BTRFS_ROOT_DEAD_TREE, &root->state);  in btrfs_drop_snapshot()
5458 	wc->level = level;  in btrfs_drop_snapshot()
5459 	wc->shared_level = -1;  in btrfs_drop_snapshot()
5460 	wc->stage = DROP_REFERENCE;  in btrfs_drop_snapshot()
5461 	wc->update_ref = update_ref;  in btrfs_drop_snapshot()
5462 	wc->keep_locks = 0;  in btrfs_drop_snapshot()
5463 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_snapshot()
5467 		ret = walk_down_tree(trans, root, path, wc);  in btrfs_drop_snapshot()
5473 		ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);  in btrfs_drop_snapshot()
5480 			BUG_ON(wc->stage != DROP_REFERENCE);  in btrfs_drop_snapshot()
5484 		if (wc->stage == DROP_REFERENCE) {  in btrfs_drop_snapshot()
5485 			wc->drop_level = wc->level;  in btrfs_drop_snapshot()
5486 			btrfs_node_key_to_cpu(path->nodes[wc->drop_level],  in btrfs_drop_snapshot()
5487 					      &wc->drop_progress,  in btrfs_drop_snapshot()
5488 					      path->slots[wc->drop_level]);  in btrfs_drop_snapshot()
5490 		btrfs_cpu_key_to_disk(&root_item->drop_progress,  in btrfs_drop_snapshot()
5491 				      &wc->drop_progress);  in btrfs_drop_snapshot()
5492 		root_item->drop_level = wc->drop_level;  in btrfs_drop_snapshot()
5494 		BUG_ON(wc->level == 0);  in btrfs_drop_snapshot()
5498 						&root->root_key,  in btrfs_drop_snapshot()
5510 				err = -EAGAIN;  in btrfs_drop_snapshot()
5533 	ret = btrfs_del_root(trans, &root->root_key);  in btrfs_drop_snapshot()
5540 	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {  in btrfs_drop_snapshot()
5541 		ret = btrfs_find_root(tree_root, &root->root_key, path,  in btrfs_drop_snapshot()
5551 			 * The most common failure here is just -ENOENT.  in btrfs_drop_snapshot()
5554 					      root->root_key.objectid);  in btrfs_drop_snapshot()
5566 	if (test_bit(BTRFS_ROOT_IN_RADIX, &root->state))  in btrfs_drop_snapshot()
5574 	kfree(wc);  in btrfs_drop_snapshot()
5582 	 * or unmount) so we don't leak memory.  in btrfs_drop_snapshot()
5600 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_subtree()
5602 	struct walk_control *wc;  in btrfs_drop_subtree()  local
5608 	BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);  in btrfs_drop_subtree()
5612 		return -ENOMEM;  in btrfs_drop_subtree()
5614 	wc = kzalloc(sizeof(*wc), GFP_NOFS);  in btrfs_drop_subtree()
5615 	if (!wc) {  in btrfs_drop_subtree()
5617 		return -ENOMEM;  in btrfs_drop_subtree()
5622 	atomic_inc(&parent->refs);  in btrfs_drop_subtree()
5623 	path->nodes[parent_level] = parent;  in btrfs_drop_subtree()
5624 	path->slots[parent_level] = btrfs_header_nritems(parent);  in btrfs_drop_subtree()
5628 	path->nodes[level] = node;  in btrfs_drop_subtree()
5629 	path->slots[level] = 0;  in btrfs_drop_subtree()
5630 	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_subtree()
5632 	wc->refs[parent_level] = 1;  in btrfs_drop_subtree()
5633 	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;  in btrfs_drop_subtree()
5634 	wc->level = level;  in btrfs_drop_subtree()
5635 	wc->shared_level = -1;  in btrfs_drop_subtree()
5636 	wc->stage = DROP_REFERENCE;  in btrfs_drop_subtree()
5637 	wc->update_ref = 0;  in btrfs_drop_subtree()
5638 	wc->keep_locks = 1;  in btrfs_drop_subtree()
5639 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_subtree()
5642 		wret = walk_down_tree(trans, root, path, wc);  in btrfs_drop_subtree()
5648 		wret = walk_up_tree(trans, root, path, wc, parent_level);  in btrfs_drop_subtree()
5655 	kfree(wc);  in btrfs_drop_subtree()
5671 	if (list_empty(&sinfo->ro_bgs))  in btrfs_account_ro_block_groups_free_space()
5674 	spin_lock(&sinfo->lock);  in btrfs_account_ro_block_groups_free_space()
5675 	list_for_each_entry(block_group, &sinfo->ro_bgs, ro_list) {  in btrfs_account_ro_block_groups_free_space()
5676 		spin_lock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5678 		if (!block_group->ro) {  in btrfs_account_ro_block_groups_free_space()
5679 			spin_unlock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5683 		factor = btrfs_bg_type_to_factor(block_group->flags);  in btrfs_account_ro_block_groups_free_space()
5684 		free_bytes += (block_group->length -  in btrfs_account_ro_block_groups_free_space()
5685 			       block_group->used) * factor;  in btrfs_account_ro_block_groups_free_space()
5687 		spin_unlock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5689 	spin_unlock(&sinfo->lock);  in btrfs_account_ro_block_groups_free_space()
5714  * from committing and releasing the memory that the pending chunks
5728 	if (!blk_queue_discard(bdev_get_queue(device->bdev)))  in btrfs_trim_free_extents()
5732 	if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state))  in btrfs_trim_free_extents()
5735 	/* No free space = nothing to do. */  in btrfs_trim_free_extents()
5736 	if (device->total_bytes <= device->bytes_used)  in btrfs_trim_free_extents()
5742 		struct btrfs_fs_info *fs_info = device->fs_info;  in btrfs_trim_free_extents()
5745 		ret = mutex_lock_interruptible(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5749 		find_first_clear_extent_bit(&device->alloc_state, start,  in btrfs_trim_free_extents()
5754 		if (start > device->total_bytes) {  in btrfs_trim_free_extents()
5758 					  start, end - start + 1,  in btrfs_trim_free_extents()
5759 					  rcu_str_deref(device->name),  in btrfs_trim_free_extents()
5760 					  device->total_bytes);  in btrfs_trim_free_extents()
5761 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5771 		 * end of the device it will set end to -1, in this case it's up  in btrfs_trim_free_extents()
5774 		end = min(end, device->total_bytes - 1);  in btrfs_trim_free_extents()
5776 		len = end - start + 1;  in btrfs_trim_free_extents()
5780 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5785 		ret = btrfs_issue_discard(device->bdev, start, len,  in btrfs_trim_free_extents()
5788 			set_extent_bits(&device->alloc_state, start,  in btrfs_trim_free_extents()
5789 					start + bytes - 1,  in btrfs_trim_free_extents()
5791 		mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5800 			ret = -ERESTARTSYS;  in btrfs_trim_free_extents()
5836 	 * Check range overflow if range->len is set.  in btrfs_trim_fs()
5837 	 * The default range->len is U64_MAX.  in btrfs_trim_fs()
5839 	if (range->len != U64_MAX &&  in btrfs_trim_fs()
5840 	    check_add_overflow(range->start, range->len, &range_end))  in btrfs_trim_fs()
5841 		return -EINVAL;  in btrfs_trim_fs()
5843 	cache = btrfs_lookup_first_block_group(fs_info, range->start);  in btrfs_trim_fs()
5845 		if (cache->start >= range_end) {  in btrfs_trim_fs()
5850 		start = max(range->start, cache->start);  in btrfs_trim_fs()
5851 		end = min(range_end, cache->start + cache->length);  in btrfs_trim_fs()
5853 		if (end - start >= range->minlen) {  in btrfs_trim_fs()
5872 						     range->minlen);  in btrfs_trim_fs()
5887 	mutex_lock(&fs_info->fs_devices->device_list_mutex);  in btrfs_trim_fs()
5888 	devices = &fs_info->fs_devices->devices;  in btrfs_trim_fs()
5890 		if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))  in btrfs_trim_fs()
5902 	mutex_unlock(&fs_info->fs_devices->device_list_mutex);  in btrfs_trim_fs()
5908 	range->len = trimmed;  in btrfs_trim_fs()