1 // SPDX-License-Identifier: GPL-2.0
20 #include "extent-tree.h"
22 #include "disk-io.h"
23 #include "print-tree.h"
27 #include "free-space-cache.h"
28 #include "free-space-tree.h"
30 #include "ref-verify.h"
31 #include "space-info.h"
32 #include "block-rsv.h"
35 #include "dev-replace.h"
38 #include "root-tree.h"
39 #include "file-item.h"
41 #include "tree-checker.h"
42 #include "raid-stripe-tree.h"
64 static int block_group_bits(const struct btrfs_block_group *cache, u64 bits)  in block_group_bits()  argument
66 	return (cache->flags & bits) == bits;  in block_group_bits()
78 		return -ENOMEM;  in btrfs_lookup_data_extent()
87  * helper function to lookup reference count and flags of a tree block.
115 		offset = fs_info->nodesize;  in btrfs_lookup_extent_info()
121 		return -ENOMEM;  in btrfs_lookup_extent_info()
137 		if (path->slots[0]) {  in btrfs_lookup_extent_info()
138 			path->slots[0]--;  in btrfs_lookup_extent_info()
139 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in btrfs_lookup_extent_info()
140 					      path->slots[0]);  in btrfs_lookup_extent_info()
143 			    key.offset == fs_info->nodesize)  in btrfs_lookup_extent_info()
149 		struct extent_buffer *leaf = path->nodes[0];  in btrfs_lookup_extent_info()
151 		const u32 item_size = btrfs_item_size(leaf, path->slots[0]);  in btrfs_lookup_extent_info()
154 			ret = -EUCLEAN;  in btrfs_lookup_extent_info()
156 			"unexpected extent item size, has %u expect >= %zu",  in btrfs_lookup_extent_info()
162 		ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in btrfs_lookup_extent_info()
165 			ret = -EUCLEAN;  in btrfs_lookup_extent_info()
173 		owner = btrfs_get_extent_owner_root(fs_info, leaf, path->slots[0]);  in btrfs_lookup_extent_info()
180 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_lookup_extent_info()
181 	spin_lock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
184 		if (!mutex_trylock(&head->mutex)) {  in btrfs_lookup_extent_info()
185 			refcount_inc(&head->refs);  in btrfs_lookup_extent_info()
186 			spin_unlock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
191 			 * Mutex was contended, block until it's released and try  in btrfs_lookup_extent_info()
194 			mutex_lock(&head->mutex);  in btrfs_lookup_extent_info()
195 			mutex_unlock(&head->mutex);  in btrfs_lookup_extent_info()
199 		spin_lock(&head->lock);  in btrfs_lookup_extent_info()
200 		if (head->extent_op && head->extent_op->update_flags)  in btrfs_lookup_extent_info()
201 			extent_flags |= head->extent_op->flags_to_set;  in btrfs_lookup_extent_info()
203 		num_refs += head->ref_mod;  in btrfs_lookup_extent_info()
204 		spin_unlock(&head->lock);  in btrfs_lookup_extent_info()
205 		mutex_unlock(&head->mutex);  in btrfs_lookup_extent_info()
207 	spin_unlock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
228  *    if we notice a given block is corrupted or bad.
235  * for pointers in non-shared tree blocks. For a given pointer in a block,
236  * back refs of this kind provide information about the block's owner tree
237  * and the pointer's key. These information allow us to find the block by
238  * b-tree searching. The full back refs is for pointers in tree blocks not
239  * referenced by their owner trees. The location of tree block is recorded
242  * of the full back refs is its overhead. Every time a tree block gets
245  * For a newly allocated tree block, we use implicit back refs for
247  * implicit back refs. For a tree block created in old transaction, the
249  * event that tree block loses its owner tree's reference and do the
252  * When a tree block is COWed through a tree, there are four cases:
254  * The reference count of the block is one and the tree is the block's
257  * The reference count of the block is one and the tree is not the
258  * block's owner tree. In this case, full back refs is used for pointers
259  * in the block. Remove these full back refs, add implicit back refs for
260  * every pointers in the new block.
262  * The reference count of the block is greater than one and the tree is
263  * the block's owner tree. In this case, implicit back refs is used for
264  * pointers in the block. Add full back refs for every pointers in the
265  * block, increase lower level extents' reference counts. The original
266  * implicit back refs are entailed to the new block.
268  * The reference count of the block is greater than one and the tree is
269  * not the block's owner tree. Add implicit back refs for every pointer in
270  * the new block, increase lower level extents' reference count.
281  * - multiple snapshots, subvolumes, or different generations in one subvol
282  * - different files inside a single subvolume
283  * - different offsets inside a file (bookend extents in file.c)
287  * - Objectid of the subvolume root
288  * - objectid of the file holding the reference
289  * - original offset in the file
290  * - how many bookend extents
297  * - number of pointers in the tree leaf
314  * - Different subvolumes
318  * objectid of block's owner tree. The key offset for the full back refs
319  * is the first byte of parent block.
322  * level of the tree block are required. These information are stored in
323  * tree block info structure.
327  * is_data == BTRFS_REF_TYPE_BLOCK, tree block type is required,
335 	struct btrfs_fs_info *fs_info = eb->fs_info;  in btrfs_get_extent_inline_ref_type()
354 				 * Every shared one has parent tree block,  in btrfs_get_extent_inline_ref_type()
355 				 * which must be aligned to sector size.  in btrfs_get_extent_inline_ref_type()
357 				if (offset && IS_ALIGNED(offset, fs_info->sectorsize))  in btrfs_get_extent_inline_ref_type()
366 				 * Every shared one has parent tree block,  in btrfs_get_extent_inline_ref_type()
367 				 * which must be aligned to sector size.  in btrfs_get_extent_inline_ref_type()
370 				    IS_ALIGNED(offset, fs_info->sectorsize))  in btrfs_get_extent_inline_ref_type()
382 		  "eb %llu iref 0x%lx invalid extent inline ref type %d",  in btrfs_get_extent_inline_ref_type()
383 		  eb->start, (unsigned long)iref, type);  in btrfs_get_extent_inline_ref_type()
429 	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);  in lookup_extent_data_ref()
448 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in lookup_extent_data_ref()
454 			return -ENOENT;  in lookup_extent_data_ref()
458 	ret = -ENOENT;  in lookup_extent_data_ref()
459 	leaf = path->nodes[0];  in lookup_extent_data_ref()
462 		if (path->slots[0] >= nritems) {  in lookup_extent_data_ref()
466 					return -ENOENT;  in lookup_extent_data_ref()
470 			leaf = path->nodes[0];  in lookup_extent_data_ref()
475 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in lookup_extent_data_ref()
480 		ref = btrfs_item_ptr(leaf, path->slots[0],  in lookup_extent_data_ref()
492 		path->slots[0]++;  in lookup_extent_data_ref()
503 	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);  in insert_extent_data_ref()
508 	u32 size;  in insert_extent_data_ref()  local
513 	if (node->parent) {  in insert_extent_data_ref()
515 		key.offset = node->parent;  in insert_extent_data_ref()
516 		size = sizeof(struct btrfs_shared_data_ref);  in insert_extent_data_ref()
519 		key.offset = hash_extent_data_ref(node->ref_root, owner, offset);  in insert_extent_data_ref()
520 		size = sizeof(struct btrfs_extent_data_ref);  in insert_extent_data_ref()
523 	ret = btrfs_insert_empty_item(trans, root, path, &key, size);  in insert_extent_data_ref()
524 	if (ret && ret != -EEXIST)  in insert_extent_data_ref()
527 	leaf = path->nodes[0];  in insert_extent_data_ref()
528 	if (node->parent) {  in insert_extent_data_ref()
530 		ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
533 			btrfs_set_shared_data_ref_count(leaf, ref, node->ref_mod);  in insert_extent_data_ref()
536 			num_refs += node->ref_mod;  in insert_extent_data_ref()
541 		while (ret == -EEXIST) {  in insert_extent_data_ref()
542 			ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
544 			if (match_extent_data_ref(leaf, ref, node->ref_root,  in insert_extent_data_ref()
550 						      size);  in insert_extent_data_ref()
551 			if (ret && ret != -EEXIST)  in insert_extent_data_ref()
554 			leaf = path->nodes[0];  in insert_extent_data_ref()
556 		ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
559 			btrfs_set_extent_data_ref_root(leaf, ref, node->ref_root);  in insert_extent_data_ref()
562 			btrfs_set_extent_data_ref_count(leaf, ref, node->ref_mod);  in insert_extent_data_ref()
565 			num_refs += node->ref_mod;  in insert_extent_data_ref()
587 	leaf = path->nodes[0];  in remove_extent_data_ref()
588 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in remove_extent_data_ref()
591 		ref1 = btrfs_item_ptr(leaf, path->slots[0],  in remove_extent_data_ref()
595 		ref2 = btrfs_item_ptr(leaf, path->slots[0],  in remove_extent_data_ref()
599 		btrfs_err(trans->fs_info,  in remove_extent_data_ref()
602 		btrfs_abort_transaction(trans, -EUCLEAN);  in remove_extent_data_ref()
603 		return -EUCLEAN;  in remove_extent_data_ref()
607 	num_refs -= refs_to_drop;  in remove_extent_data_ref()
630 	leaf = path->nodes[0];  in extent_data_ref_count()
631 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in extent_data_ref_count()
641 			ref1 = (const struct btrfs_extent_data_ref *)(&iref->offset);  in extent_data_ref_count()
648 		ref1 = btrfs_item_ptr(leaf, path->slots[0],  in extent_data_ref_count()
652 		ref2 = btrfs_item_ptr(leaf, path->slots[0],  in extent_data_ref_count()
666 	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);  in lookup_tree_block_ref()
679 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in lookup_tree_block_ref()
681 		ret = -ENOENT;  in lookup_tree_block_ref()
690 	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);  in insert_tree_block_ref()
695 	if (node->parent) {  in insert_tree_block_ref()
697 		key.offset = node->parent;  in insert_tree_block_ref()
700 		key.offset = node->ref_root;  in insert_tree_block_ref()
730 		if (!path->nodes[level])  in find_next_key()
732 		if (path->slots[level] + 1 >=  in find_next_key()
733 		    btrfs_header_nritems(path->nodes[level]))  in find_next_key()
736 			btrfs_item_key_to_cpu(path->nodes[level], key,  in find_next_key()
737 					      path->slots[level] + 1);  in find_next_key()
739 			btrfs_node_key_to_cpu(path->nodes[level], key,  in find_next_key()
740 					      path->slots[level] + 1);  in find_next_key()
751  * should be inserted, and -ENOENT is returned.
754  * points to the extent item, and -EAGAIN is returned.
767 	struct btrfs_fs_info *fs_info = trans->fs_info;  in lookup_inline_extent_backref()
791 		path->search_for_extension = 1;  in lookup_inline_extent_backref()
793 		extra_size = -1;  in lookup_inline_extent_backref()
797 	 * block we are interested in.  in lookup_inline_extent_backref()
815 		if (path->slots[0]) {  in lookup_inline_extent_backref()
816 			path->slots[0]--;  in lookup_inline_extent_backref()
817 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in lookup_inline_extent_backref()
818 					      path->slots[0]);  in lookup_inline_extent_backref()
834 		ret = -ENOENT;  in lookup_inline_extent_backref()
837 		btrfs_print_leaf(path->nodes[0]);  in lookup_inline_extent_backref()
842 		ret = -EUCLEAN;  in lookup_inline_extent_backref()
846 	leaf = path->nodes[0];  in lookup_inline_extent_backref()
847 	item_size = btrfs_item_size(leaf, path->slots[0]);  in lookup_inline_extent_backref()
849 		ret = -EUCLEAN;  in lookup_inline_extent_backref()
851 			  "unexpected extent item size, has %llu expect >= %zu",  in lookup_inline_extent_backref()
857 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in lookup_inline_extent_backref()
873 	ret = -ENOENT;  in lookup_inline_extent_backref()
883 			ret = -EUCLEAN;  in lookup_inline_extent_backref()
896 			dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in lookup_inline_extent_backref()
928 		ret = -EUCLEAN;  in lookup_inline_extent_backref()
929 		btrfs_print_leaf(path->nodes[0]);  in lookup_inline_extent_backref()
931 "overrun extent record at slot %d while looking for inline extent for root %llu owner %llu offset %…  in lookup_inline_extent_backref()
932 			   path->slots[0], root_objectid, owner, offset, parent);  in lookup_inline_extent_backref()
936 	if (ret == -ENOENT && insert) {  in lookup_inline_extent_backref()
939 			ret = -EAGAIN;  in lookup_inline_extent_backref()
943 		if (path->slots[0] + 1 < btrfs_header_nritems(path->nodes[0])) {  in lookup_inline_extent_backref()
946 			btrfs_item_key_to_cpu(path->nodes[0], &tmp_key, path->slots[0] + 1);  in lookup_inline_extent_backref()
949 				ret = -EAGAIN;  in lookup_inline_extent_backref()
955 		if (!path->keep_locks) {  in lookup_inline_extent_backref()
957 			path->keep_locks = 1;  in lookup_inline_extent_backref()
965 		 * ref if there is any kind of item for this block  in lookup_inline_extent_backref()
970 			ret = -EAGAIN;  in lookup_inline_extent_backref()
977 	if (path->keep_locks) {  in lookup_inline_extent_backref()
978 		path->keep_locks = 0;  in lookup_inline_extent_backref()
982 		path->search_for_extension = 0;  in lookup_inline_extent_backref()
1003 	int size;  in setup_inline_extent_backref()  local
1006 	leaf = path->nodes[0];  in setup_inline_extent_backref()
1007 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in setup_inline_extent_backref()
1008 	item_offset = (unsigned long)iref - (unsigned long)ei;  in setup_inline_extent_backref()
1011 	size = btrfs_extent_inline_ref_size(type);  in setup_inline_extent_backref()
1013 	btrfs_extend_item(trans, path, size);  in setup_inline_extent_backref()
1015 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in setup_inline_extent_backref()
1023 	end = (unsigned long)ei + btrfs_item_size(leaf, path->slots[0]);  in setup_inline_extent_backref()
1024 	if (ptr < end - size)  in setup_inline_extent_backref()
1025 		memmove_extent_buffer(leaf, ptr + size, ptr,  in setup_inline_extent_backref()
1026 				      end - size - ptr);  in setup_inline_extent_backref()
1032 		dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in setup_inline_extent_backref()
1060 	if (ret != -ENOENT)  in lookup_extent_backref()
1086 	struct extent_buffer *leaf = path->nodes[0];  in update_inline_extent_backref()
1087 	struct btrfs_fs_info *fs_info = leaf->fs_info;  in update_inline_extent_backref()
1094 	int size;  in update_inline_extent_backref()  local
1098 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in update_inline_extent_backref()
1104 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in update_inline_extent_backref()
1106 			extent_size = fs_info->nodesize;  in update_inline_extent_backref()
1111 	"invalid refs_to_mod for extent %llu num_bytes %u, has %d expect >= -%llu",  in update_inline_extent_backref()
1113 		return -EUCLEAN;  in update_inline_extent_backref()
1126 		return -EUCLEAN;  in update_inline_extent_backref()
1129 		dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in update_inline_extent_backref()
1144 		if (unlikely(refs_to_mod != -1)) {  in update_inline_extent_backref()
1147 			btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in update_inline_extent_backref()
1151 			"invalid refs_to_mod for tree block %llu, has %d expect -1",  in update_inline_extent_backref()
1153 			return -EUCLEAN;  in update_inline_extent_backref()
1157 	if (unlikely(refs_to_mod < 0 && refs < -refs_to_mod)) {  in update_inline_extent_backref()
1161 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in update_inline_extent_backref()
1163 			extent_size = fs_info->nodesize;  in update_inline_extent_backref()
1168 "invalid refs_to_mod for backref entry, iref %lu extent %llu num_bytes %u, has %d expect >= -%llu",  in update_inline_extent_backref()
1171 		return -EUCLEAN;  in update_inline_extent_backref()
1181 		size =  btrfs_extent_inline_ref_size(type);  in update_inline_extent_backref()
1182 		item_size = btrfs_item_size(leaf, path->slots[0]);  in update_inline_extent_backref()
1185 		if (ptr + size < end)  in update_inline_extent_backref()
1186 			memmove_extent_buffer(leaf, ptr, ptr + size,  in update_inline_extent_backref()
1187 					      end - ptr - size);  in update_inline_extent_backref()
1188 		item_size -= size;  in update_inline_extent_backref()
1210 		 * We're adding refs to a tree block we already own, this  in insert_inline_extent_backref()
1214 			btrfs_print_leaf(path->nodes[0]);  in insert_inline_extent_backref()
1215 			btrfs_crit(trans->fs_info,  in insert_inline_extent_backref()
1217 				   bytenr, num_bytes, root_objectid, path->slots[0]);  in insert_inline_extent_backref()
1218 			return -EUCLEAN;  in insert_inline_extent_backref()
1222 	} else if (ret == -ENOENT) {  in insert_inline_extent_backref()
1242 						   -refs_to_drop, NULL);  in remove_extent_backref()
1259 		len -= aligned_start - start;  in btrfs_issue_discard()
1276 		u64 size = sb_start - start;  in btrfs_issue_discard()  local
1288 			start += sb_end - start;  in btrfs_issue_discard()
1293 			bytes_left = end - start;  in btrfs_issue_discard()
1297 		if (size) {  in btrfs_issue_discard()
1299 						   size >> SECTOR_SHIFT,  in btrfs_issue_discard()
1302 				*discarded_bytes += size;  in btrfs_issue_discard()
1303 			else if (ret != -EOPNOTSUPP)  in btrfs_issue_discard()
1312 		bytes_left = end - start;  in btrfs_issue_discard()
1323 			if (ret != -EOPNOTSUPP)  in btrfs_issue_discard()
1329 		bytes_left -= bytes_to_discard;  in btrfs_issue_discard()
1333 			ret = -ERESTARTSYS;  in btrfs_issue_discard()
1343 	struct btrfs_device *dev = stripe->dev;  in do_discard_extent()
1344 	struct btrfs_fs_info *fs_info = dev->fs_info;  in do_discard_extent()
1345 	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;  in do_discard_extent()
1346 	u64 phys = stripe->physical;  in do_discard_extent()
1347 	u64 len = stripe->length;  in do_discard_extent()
1360 		    dev != dev_replace->srcdev)  in do_discard_extent()
1366 		ret = btrfs_reset_device_zone(dev_replace->tgtdev, phys, len,  in do_discard_extent()
1369 	} else if (bdev_max_discard_sectors(stripe->dev->bdev)) {  in do_discard_extent()
1370 		ret = btrfs_issue_discard(dev->bdev, phys, len, &discarded);  in do_discard_extent()
1399 		num_bytes = end - cur;  in btrfs_discard_extent()
1403 			if (ret == -EOPNOTSUPP)  in btrfs_discard_extent()
1412 			if (!stripe->dev->bdev) {  in btrfs_discard_extent()
1418 					&stripe->dev->dev_state))  in btrfs_discard_extent()
1427 				if (ret != -EOPNOTSUPP)  in btrfs_discard_extent()
1445 /* Can return -ENOMEM */
1449 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_inc_extent_ref()
1452 	ASSERT(generic_ref->type != BTRFS_REF_NOT_SET &&  in btrfs_inc_extent_ref()
1453 	       generic_ref->action);  in btrfs_inc_extent_ref()
1454 	BUG_ON(generic_ref->type == BTRFS_REF_METADATA &&  in btrfs_inc_extent_ref()
1455 	       generic_ref->ref_root == BTRFS_TREE_LOG_OBJECTID);  in btrfs_inc_extent_ref()
1457 	if (generic_ref->type == BTRFS_REF_METADATA)  in btrfs_inc_extent_ref()
1479  *                  updating a tree block's flags
1490 	u64 bytenr = node->bytenr;  in __btrfs_inc_extent_ref()
1491 	u64 num_bytes = node->num_bytes;  in __btrfs_inc_extent_ref()
1495 	int refs_to_add = node->ref_mod;  in __btrfs_inc_extent_ref()
1500 		return -ENOMEM;  in __btrfs_inc_extent_ref()
1504 					   node->parent, node->ref_root, owner,  in __btrfs_inc_extent_ref()
1506 	if ((ret < 0 && ret != -EAGAIN) || !ret)  in __btrfs_inc_extent_ref()
1510 	 * Ok we had -EAGAIN which means we didn't have space to insert and  in __btrfs_inc_extent_ref()
1514 	leaf = path->nodes[0];  in __btrfs_inc_extent_ref()
1515 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in __btrfs_inc_extent_ref()
1516 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in __btrfs_inc_extent_ref()
1541 	u64 root = href->owning_root;  in free_head_ref_squota_rsv()
1548 	    !href->is_data || !btrfs_is_fstree(root))  in free_head_ref_squota_rsv()
1551 	btrfs_qgroup_free_refroot(fs_info, root, href->reserved_bytes,  in free_head_ref_squota_rsv()
1565 	trace_run_delayed_data_ref(trans->fs_info, node);  in run_delayed_data_ref()
1567 	if (node->type == BTRFS_SHARED_DATA_REF_KEY)  in run_delayed_data_ref()
1568 		parent = node->parent;  in run_delayed_data_ref()
1570 	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {  in run_delayed_data_ref()
1573 			.root = href->owning_root,  in run_delayed_data_ref()
1574 			.num_bytes = node->num_bytes,  in run_delayed_data_ref()
1577 			.generation = trans->transid,  in run_delayed_data_ref()
1583 			flags |= extent_op->flags_to_set;  in run_delayed_data_ref()
1585 		key.objectid = node->bytenr;  in run_delayed_data_ref()
1587 		key.offset = node->num_bytes;  in run_delayed_data_ref()
1589 		ret = alloc_reserved_file_extent(trans, parent, node->ref_root,  in run_delayed_data_ref()
1591 						 node->ref_mod,  in run_delayed_data_ref()
1592 						 href->owning_root);  in run_delayed_data_ref()
1593 		free_head_ref_squota_rsv(trans->fs_info, href);  in run_delayed_data_ref()
1595 			ret = btrfs_record_squota_delta(trans->fs_info, &delta);  in run_delayed_data_ref()
1596 	} else if (node->action == BTRFS_ADD_DELAYED_REF) {  in run_delayed_data_ref()
1598 	} else if (node->action == BTRFS_DROP_DELAYED_REF) {  in run_delayed_data_ref()
1611 	if (extent_op->update_flags) {  in __run_delayed_extent_op()
1612 		flags |= extent_op->flags_to_set;  in __run_delayed_extent_op()
1616 	if (extent_op->update_key) {  in __run_delayed_extent_op()
1620 		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);  in __run_delayed_extent_op()
1628 	struct btrfs_fs_info *fs_info = trans->fs_info;  in run_delayed_extent_op()
1646 		return -ENOMEM;  in run_delayed_extent_op()
1648 	key.objectid = head->bytenr;  in run_delayed_extent_op()
1652 		key.offset = head->level;  in run_delayed_extent_op()
1655 		key.offset = head->num_bytes;  in run_delayed_extent_op()
1665 			if (path->slots[0] > 0) {  in run_delayed_extent_op()
1666 				path->slots[0]--;  in run_delayed_extent_op()
1667 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in run_delayed_extent_op()
1668 						      path->slots[0]);  in run_delayed_extent_op()
1669 				if (key.objectid == head->bytenr &&  in run_delayed_extent_op()
1671 				    key.offset == head->num_bytes)  in run_delayed_extent_op()
1678 				key.objectid = head->bytenr;  in run_delayed_extent_op()
1680 				key.offset = head->num_bytes;  in run_delayed_extent_op()
1684 			ret = -EUCLEAN;  in run_delayed_extent_op()
1686 		  "missing extent item for extent %llu num_bytes %llu level %d",  in run_delayed_extent_op()
1687 				  head->bytenr, head->num_bytes, head->level);  in run_delayed_extent_op()
1692 	leaf = path->nodes[0];  in run_delayed_extent_op()
1693 	item_size = btrfs_item_size(leaf, path->slots[0]);  in run_delayed_extent_op()
1696 		ret = -EUCLEAN;  in run_delayed_extent_op()
1698 			  "unexpected extent item size, has %u expect >= %zu",  in run_delayed_extent_op()
1704 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in run_delayed_extent_op()
1717 	struct btrfs_fs_info *fs_info = trans->fs_info;  in run_delayed_tree_ref()
1721 	trace_run_delayed_tree_ref(trans->fs_info, node);  in run_delayed_tree_ref()
1723 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)  in run_delayed_tree_ref()
1724 		parent = node->parent;  in run_delayed_tree_ref()
1725 	ref_root = node->ref_root;  in run_delayed_tree_ref()
1727 	if (unlikely(node->ref_mod != 1)) {  in run_delayed_tree_ref()
1728 		btrfs_err(trans->fs_info,  in run_delayed_tree_ref()
1729 	"btree block %llu has %d references rather than 1: action %d ref_root %llu parent %llu",  in run_delayed_tree_ref()
1730 			  node->bytenr, node->ref_mod, node->action, ref_root,  in run_delayed_tree_ref()
1732 		return -EUCLEAN;  in run_delayed_tree_ref()
1734 	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {  in run_delayed_tree_ref()
1736 			.root = href->owning_root,  in run_delayed_tree_ref()
1737 			.num_bytes = fs_info->nodesize,  in run_delayed_tree_ref()
1740 			.generation = trans->transid,  in run_delayed_tree_ref()
1746 	} else if (node->action == BTRFS_ADD_DELAYED_REF) {  in run_delayed_tree_ref()
1748 	} else if (node->action == BTRFS_DROP_DELAYED_REF) {  in run_delayed_tree_ref()
1767 			btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);  in run_one_delayed_ref()
1768 			free_head_ref_squota_rsv(trans->fs_info, href);  in run_one_delayed_ref()
1773 	if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||  in run_one_delayed_ref()
1774 	    node->type == BTRFS_SHARED_BLOCK_REF_KEY)  in run_one_delayed_ref()
1777 	else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||  in run_one_delayed_ref()
1778 		 node->type == BTRFS_SHARED_DATA_REF_KEY)  in run_one_delayed_ref()
1781 	else if (node->type == BTRFS_EXTENT_OWNER_REF_KEY)  in run_one_delayed_ref()
1786 		btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);  in run_one_delayed_ref()
1788 		btrfs_err(trans->fs_info,  in run_one_delayed_ref()
1789 "failed to run delayed ref for logical %llu num_bytes %llu type %u action %u ref_mod %d: %d",  in run_one_delayed_ref()
1790 			  node->bytenr, node->num_bytes, node->type,  in run_one_delayed_ref()
1791 			  node->action, node->ref_mod, ret);  in run_one_delayed_ref()
1798 	struct btrfs_delayed_extent_op *extent_op = head->extent_op;  in cleanup_extent_op()
1803 	if (head->must_insert_reserved) {  in cleanup_extent_op()
1804 		head->extent_op = NULL;  in cleanup_extent_op()
1820 	head->extent_op = NULL;  in run_and_cleanup_extent_op()
1821 	spin_unlock(&head->lock);  in run_and_cleanup_extent_op()
1837 	if (head->total_ref_mod < 0 && head->is_data) {  in btrfs_cleanup_ref_head_accounting()
1840 		spin_lock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1841 		delayed_refs->pending_csums -= head->num_bytes;  in btrfs_cleanup_ref_head_accounting()
1842 		spin_unlock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1843 		nr_csums = btrfs_csum_bytes_to_leaves(fs_info, head->num_bytes);  in btrfs_cleanup_ref_head_accounting()
1850 	if (head->must_insert_reserved)  in btrfs_cleanup_ref_head_accounting()
1861 	struct btrfs_fs_info *fs_info = trans->fs_info;  in cleanup_ref_head()
1865 	delayed_refs = &trans->transaction->delayed_refs;  in cleanup_ref_head()
1870 		btrfs_debug(fs_info, "run_delayed_extent_op returned %d", ret);  in cleanup_ref_head()
1877 	 * Need to drop our head ref lock and re-acquire the delayed ref lock  in cleanup_ref_head()
1878 	 * and then re-check to make sure nobody got added.  in cleanup_ref_head()
1880 	spin_unlock(&head->lock);  in cleanup_ref_head()
1881 	spin_lock(&delayed_refs->lock);  in cleanup_ref_head()
1882 	spin_lock(&head->lock);  in cleanup_ref_head()
1883 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root) || head->extent_op) {  in cleanup_ref_head()
1884 		spin_unlock(&head->lock);  in cleanup_ref_head()
1885 		spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1889 	spin_unlock(&head->lock);  in cleanup_ref_head()
1890 	spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1892 	if (head->must_insert_reserved) {  in cleanup_ref_head()
1893 		btrfs_pin_extent(trans, head->bytenr, head->num_bytes, 1);  in cleanup_ref_head()
1894 		if (head->is_data) {  in cleanup_ref_head()
1897 			csum_root = btrfs_csum_root(fs_info, head->bytenr);  in cleanup_ref_head()
1898 			ret = btrfs_del_csums(trans, csum_root, head->bytenr,  in cleanup_ref_head()
1899 					      head->num_bytes);  in cleanup_ref_head()
1915 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs_for_head()
1922 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs_for_head()
1924 	lockdep_assert_held(&locked_ref->mutex);  in btrfs_run_delayed_refs_for_head()
1925 	lockdep_assert_held(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1928 		if (ref->seq &&  in btrfs_run_delayed_refs_for_head()
1929 		    btrfs_check_delayed_seq(fs_info, ref->seq)) {  in btrfs_run_delayed_refs_for_head()
1930 			spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1932 			return -EAGAIN;  in btrfs_run_delayed_refs_for_head()
1935 		rb_erase_cached(&ref->ref_node, &locked_ref->ref_tree);  in btrfs_run_delayed_refs_for_head()
1936 		RB_CLEAR_NODE(&ref->ref_node);  in btrfs_run_delayed_refs_for_head()
1937 		if (!list_empty(&ref->add_list))  in btrfs_run_delayed_refs_for_head()
1938 			list_del(&ref->add_list);  in btrfs_run_delayed_refs_for_head()
1943 		switch (ref->action) {  in btrfs_run_delayed_refs_for_head()
1946 			locked_ref->ref_mod -= ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1949 			locked_ref->ref_mod += ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1959 		must_insert_reserved = locked_ref->must_insert_reserved;  in btrfs_run_delayed_refs_for_head()
1966 		locked_ref->must_insert_reserved = false;  in btrfs_run_delayed_refs_for_head()
1968 		extent_op = locked_ref->extent_op;  in btrfs_run_delayed_refs_for_head()
1969 		locked_ref->extent_op = NULL;  in btrfs_run_delayed_refs_for_head()
1970 		spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1987 		spin_lock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1996  * Returns -ENOMEM or -EIO on failure and will abort the transaction.
2001 	struct btrfs_fs_info *fs_info = trans->fs_info;  in __btrfs_run_delayed_refs()
2009 	delayed_refs = &trans->transaction->delayed_refs;  in __btrfs_run_delayed_refs()
2016 		max_count = data_race(delayed_refs->num_heads_ready);  in __btrfs_run_delayed_refs()
2024 				if (PTR_ERR(locked_ref) == -EAGAIN) {  in __btrfs_run_delayed_refs()
2036 		 * finish.  If we merged anything we need to re-loop so we can  in __btrfs_run_delayed_refs()
2044 		spin_lock(&locked_ref->lock);  in __btrfs_run_delayed_refs()
2048 		if (ret < 0 && ret != -EAGAIN) {  in __btrfs_run_delayed_refs()
2071 		 * returned -EAGAIN, meaning we need to select another head  in __btrfs_run_delayed_refs()
2091 	struct rb_node *n = root->rb_node;  in find_middle()
2100 		first = entry->bytenr;  in find_middle()
2105 		last = entry->bytenr;  in find_middle()
2107 	n = root->rb_node;  in find_middle()
2111 		WARN_ON(!entry->in_tree);  in find_middle()
2113 		middle = entry->bytenr;  in find_middle()
2116 			n = n->rb_left;  in find_middle()
2118 			n = n->rb_right;  in find_middle()
2120 		alt = 1 - alt;  in find_middle()
2135  *		Use (u64)-1 (U64_MAX) to run all existing delayed references
2143 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs()
2151 	if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags))  in btrfs_run_delayed_refs()
2154 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs()
2157 	delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);  in btrfs_run_delayed_refs()
2168 		spin_lock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2169 		if (xa_empty(&delayed_refs->head_refs)) {  in btrfs_run_delayed_refs()
2170 			spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2173 		spin_unlock(&delayed_refs->lock);  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()
2196 	ret = btrfs_add_delayed_extent_op(trans, eb->start, eb->len,  in btrfs_set_disk_extent_flags()
2207 	struct btrfs_root *root = inode->root;  in check_delayed_ref()
2215 	spin_lock(&root->fs_info->trans_lock);  in check_delayed_ref()
2216 	cur_trans = root->fs_info->running_transaction;  in check_delayed_ref()
2218 		refcount_inc(&cur_trans->use_count);  in check_delayed_ref()
2219 	spin_unlock(&root->fs_info->trans_lock);  in check_delayed_ref()
2223 	delayed_refs = &cur_trans->delayed_refs;  in check_delayed_ref()
2224 	spin_lock(&delayed_refs->lock);  in check_delayed_ref()
2225 	head = btrfs_find_delayed_ref_head(root->fs_info, delayed_refs, bytenr);  in check_delayed_ref()
2227 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2232 	if (!mutex_trylock(&head->mutex)) {  in check_delayed_ref()
2233 		if (path->nowait) {  in check_delayed_ref()
2234 			spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2236 			return -EAGAIN;  in check_delayed_ref()
2239 		refcount_inc(&head->refs);  in check_delayed_ref()
2240 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2245 		 * Mutex was contended, block until it's released and let  in check_delayed_ref()
2248 		mutex_lock(&head->mutex);  in check_delayed_ref()
2249 		mutex_unlock(&head->mutex);  in check_delayed_ref()
2252 		return -EAGAIN;  in check_delayed_ref()
2254 	spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2256 	spin_lock(&head->lock);  in check_delayed_ref()
2261 	for (node = rb_first_cached(&head->ref_tree); node;  in check_delayed_ref()
2268 		if (ref->type != BTRFS_EXTENT_DATA_REF_KEY) {  in check_delayed_ref()
2280 		if (ref->ref_root != btrfs_root_id(root) ||  in check_delayed_ref()
2286 	spin_unlock(&head->lock);  in check_delayed_ref()
2287 	mutex_unlock(&head->mutex);  in check_delayed_ref()
2303  * leaf that contains the extent's extent item - this is necessary to ensure
2305  * have such a path when calling check_delayed_ref() - it must lock a delayed
2307  * in the extent tree, we return -ENOENT with the path having the leaf (locked)
2320  *       plus non-inline references may be located on leaves other than the one
2330  *          < 0 in case of an error. In case of -ENOENT the leaf in the extent
2338 	struct btrfs_root *root = inode->root;  in check_committed_ref()
2339 	struct btrfs_fs_info *fs_info = root->fs_info;  in check_committed_ref()
2353 	key.offset = (u64)-1;  in check_committed_ref()
2360 		 * Key with offset -1 found, there would have to exist an extent  in check_committed_ref()
2363 		return -EUCLEAN;  in check_committed_ref()
2366 	if (path->slots[0] == 0)  in check_committed_ref()
2367 		return -ENOENT;  in check_committed_ref()
2369 	path->slots[0]--;  in check_committed_ref()
2370 	leaf = path->nodes[0];  in check_committed_ref()
2371 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in check_committed_ref()
2374 		return -ENOENT;  in check_committed_ref()
2376 	item_size = btrfs_item_size(leaf, path->slots[0]);  in check_committed_ref()
2377 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in check_committed_ref()
2401 	ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in check_committed_ref()
2419 		if (ret && ret != -ENOENT)  in btrfs_cross_ref_exist()
2433 			struct extent_buffer *leaf = path->nodes[0];  in btrfs_cross_ref_exist()
2438 			if (ret != -ENOENT) {  in btrfs_cross_ref_exist()
2441 				btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in btrfs_cross_ref_exist()
2448 	} while (ret == -EAGAIN && !path->nowait);  in btrfs_cross_ref_exist()
2452 	if (btrfs_is_data_reloc_root(inode->root))  in btrfs_cross_ref_exist()
2462 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_mod_ref()
2481 	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && level == 0)  in __btrfs_mod_ref()
2485 		parent = buf->start;  in __btrfs_mod_ref()
2516 			key.offset -= btrfs_file_extent_offset(buf, fi);  in __btrfs_mod_ref()
2528 			ref.num_bytes = fs_info->nodesize;  in __btrfs_mod_ref()
2530 			btrfs_init_tree_ref(&ref, level - 1,  in __btrfs_mod_ref()
2559 	struct btrfs_fs_info *fs_info = root->fs_info;  in get_alloc_profile_by_root()
2565 	else if (root == fs_info->chunk_root)  in get_alloc_profile_by_root()
2579 	read_lock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2580 	/* Get the block group with the lowest logical start address. */  in first_logical_byte()
2581 	leftmost = rb_first_cached(&fs_info->block_group_cache_tree);  in first_logical_byte()
2586 		bytenr = bg->start;  in first_logical_byte()
2588 	read_unlock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2594 			   struct btrfs_block_group *cache,  in pin_down_extent()  argument
2597 	spin_lock(&cache->space_info->lock);  in pin_down_extent()
2598 	spin_lock(&cache->lock);  in pin_down_extent()
2599 	cache->pinned += num_bytes;  in pin_down_extent()
2600 	btrfs_space_info_update_bytes_pinned(cache->space_info, num_bytes);  in pin_down_extent()
2602 		cache->reserved -= num_bytes;  in pin_down_extent()
2603 		cache->space_info->bytes_reserved -= num_bytes;  in pin_down_extent()
2605 	spin_unlock(&cache->lock);  in pin_down_extent()
2606 	spin_unlock(&cache->space_info->lock);  in pin_down_extent()
2608 	btrfs_set_extent_bit(&trans->transaction->pinned_extents, bytenr,  in pin_down_extent()
2609 			     bytenr + num_bytes - 1, EXTENT_DIRTY, NULL);  in pin_down_extent()
2616 	struct btrfs_block_group *cache;  in btrfs_pin_extent()  local
2618 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent()
2619 	BUG_ON(!cache); /* Logic error */  in btrfs_pin_extent()
2621 	pin_down_extent(trans, cache, bytenr, num_bytes, reserved);  in btrfs_pin_extent()
2623 	btrfs_put_block_group(cache);  in btrfs_pin_extent()
2630 	struct btrfs_block_group *cache;  in btrfs_pin_extent_for_log_replay()  local
2633 	cache = btrfs_lookup_block_group(trans->fs_info, eb->start);  in btrfs_pin_extent_for_log_replay()
2634 	if (!cache)  in btrfs_pin_extent_for_log_replay()
2635 		return -EINVAL;  in btrfs_pin_extent_for_log_replay()
2638 	 * Fully cache the free space first so that our pin removes the free space  in btrfs_pin_extent_for_log_replay()
2639 	 * from the cache.  in btrfs_pin_extent_for_log_replay()
2641 	ret = btrfs_cache_block_group(cache, true);  in btrfs_pin_extent_for_log_replay()
2645 	pin_down_extent(trans, cache, eb->start, eb->len, 0);  in btrfs_pin_extent_for_log_replay()
2647 	/* remove us from the free space cache (if we're there at all) */  in btrfs_pin_extent_for_log_replay()
2648 	ret = btrfs_remove_free_space(cache, eb->start, eb->len);  in btrfs_pin_extent_for_log_replay()
2650 	btrfs_put_block_group(cache);  in btrfs_pin_extent_for_log_replay()
2662 		return -EINVAL;  in __exclude_logged_extent()
2676 	struct btrfs_fs_info *fs_info = eb->fs_info;  in btrfs_exclude_logged_extents()
2709 	atomic_inc(&bg->reservations);  in btrfs_inc_block_group_reservations()
2726 	if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {  in fetch_cluster_info()
2727 		ret = &fs_info->meta_alloc_cluster;  in fetch_cluster_info()
2732 	} else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) &&  in fetch_cluster_info()
2735 		ret = &fs_info->data_alloc_cluster;  in fetch_cluster_info()
2745 	struct btrfs_block_group *cache = NULL;  in unpin_extent_range()  local
2757 		if (!cache ||  in unpin_extent_range()
2758 		    start >= cache->start + cache->length) {  in unpin_extent_range()
2759 			if (cache)  in unpin_extent_range()
2760 				btrfs_put_block_group(cache);  in unpin_extent_range()
2762 			cache = btrfs_lookup_block_group(fs_info, start);  in unpin_extent_range()
2763 			if (unlikely(cache == NULL)) {  in unpin_extent_range()
2764 				/* Logic error, something removed the block group. */  in unpin_extent_range()
2765 				ret = -EUCLEAN;  in unpin_extent_range()
2770 						     cache->space_info,  in unpin_extent_range()
2775 		len = cache->start + cache->length - start;  in unpin_extent_range()
2776 		len = min(len, end + 1 - start);  in unpin_extent_range()
2779 			btrfs_add_free_space(cache, start, len);  in unpin_extent_range()
2783 		space_info = cache->space_info;  in unpin_extent_range()
2787 		 * unpinned enough in this block group to potentially allow a  in unpin_extent_range()
2791 		if (cluster && cluster->fragmented &&  in unpin_extent_range()
2793 			spin_lock(&cluster->lock);  in unpin_extent_range()
2794 			cluster->fragmented = 0;  in unpin_extent_range()
2795 			spin_unlock(&cluster->lock);  in unpin_extent_range()
2798 		spin_lock(&space_info->lock);  in unpin_extent_range()
2799 		spin_lock(&cache->lock);  in unpin_extent_range()
2800 		cache->pinned -= len;  in unpin_extent_range()
2801 		btrfs_space_info_update_bytes_pinned(space_info, -len);  in unpin_extent_range()
2802 		space_info->max_extent_size = 0;  in unpin_extent_range()
2803 		if (cache->ro) {  in unpin_extent_range()
2804 			space_info->bytes_readonly += len;  in unpin_extent_range()
2807 			/* Need reset before reusing in a zoned block group */  in unpin_extent_range()
2811 		spin_unlock(&cache->lock);  in unpin_extent_range()
2814 		spin_unlock(&space_info->lock);  in unpin_extent_range()
2817 	if (cache)  in unpin_extent_range()
2818 		btrfs_put_block_group(cache);  in unpin_extent_range()
2825 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_finish_extent_commit()
2828 	struct extent_io_tree *unpin = &trans->transaction->pinned_extents;  in btrfs_finish_extent_commit()
2835 	mutex_lock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2843 						   end + 1 - start, NULL);  in btrfs_finish_extent_commit()
2853 		 * the space will be available as it was pinned by in-memory  in btrfs_finish_extent_commit()
2858 "failed to unpin extent range [%llu, %llu] when committing transaction %llu: %s (%d)",  in btrfs_finish_extent_commit()
2859 				     start, end, trans->transid,  in btrfs_finish_extent_commit()
2869 			mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2872 			mutex_lock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2878 				start = cached_state->start;  in btrfs_finish_extent_commit()
2879 				end = cached_state->end;  in btrfs_finish_extent_commit()
2883 	mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2887 		btrfs_discard_calc_delay(&fs_info->discard_ctl);  in btrfs_finish_extent_commit()
2888 		btrfs_discard_schedule_work(&fs_info->discard_ctl, true);  in btrfs_finish_extent_commit()
2893 	 * do need to clean up the block groups in case of a transaction  in btrfs_finish_extent_commit()
2896 	deleted_bgs = &trans->transaction->deleted_bgs;  in btrfs_finish_extent_commit()
2898 		ret = -EROFS;  in btrfs_finish_extent_commit()
2900 			ret = btrfs_discard_extent(fs_info, block_group->start,  in btrfs_finish_extent_commit()
2901 						   block_group->length, NULL);  in btrfs_finish_extent_commit()
2905 		 * read-only from btrfs_delete_unused_bgs().  in btrfs_finish_extent_commit()
2907 		ASSERT(block_group->ro);  in btrfs_finish_extent_commit()
2908 		spin_lock(&fs_info->unused_bgs_lock);  in btrfs_finish_extent_commit()
2909 		list_del_init(&block_group->bg_list);  in btrfs_finish_extent_commit()
2910 		spin_unlock(&fs_info->unused_bgs_lock);  in btrfs_finish_extent_commit()
2918 			   "discard failed while removing blockgroup: errno=%d %s",  in btrfs_finish_extent_commit()
2966 		oref = (struct btrfs_extent_owner_ref *)(&iref->offset);  in btrfs_get_extent_owner_root()
2978 	u64 num_bytes = delta->num_bytes;  in do_free_extent_accounting()
2980 	if (delta->is_data) {  in do_free_extent_accounting()
2983 		csum_root = btrfs_csum_root(trans->fs_info, bytenr);  in do_free_extent_accounting()
2997 	ret = btrfs_record_squota_delta(trans->fs_info, delta);  in do_free_extent_accounting()
3018 	btrfs_abort_transaction(trans, -EUCLEAN);	\
3019 	btrfs_print_leaf(path->nodes[0]);		\
3020 	btrfs_crit(trans->fs_info, fmt, ##args);	\
3043  *    node->bytenr = 13631488
3044  *    node->num_bytes = 1048576
3068  *    node->bytenr = 13631488
3069  *    node->num_bytes = 1048576
3087 	struct btrfs_fs_info *info = trans->fs_info;  in __btrfs_free_extent()
3099 	int refs_to_drop = node->ref_mod;  in __btrfs_free_extent()
3102 	u64 bytenr = node->bytenr;  in __btrfs_free_extent()
3103 	u64 num_bytes = node->num_bytes;  in __btrfs_free_extent()
3107 	u64 delayed_ref_root = href->owning_root;  in __btrfs_free_extent()
3114 		return -ENOMEM;  in __btrfs_free_extent()
3120 "invalid refs_to_drop, dropping more than 1 refs for tree block %llu refs_to_drop %u",  in __btrfs_free_extent()
3121 			   node->bytenr, refs_to_drop);  in __btrfs_free_extent()
3122 		ret = -EINVAL;  in __btrfs_free_extent()
3131 				    node->parent, node->ref_root, owner_objectid,  in __btrfs_free_extent()
3141 		extent_slot = path->slots[0];  in __btrfs_free_extent()
3143 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3159 			if (path->slots[0] - extent_slot > 5)  in __btrfs_free_extent()
3161 			extent_slot--;  in __btrfs_free_extent()
3168 					   path->slots[0]);  in __btrfs_free_extent()
3169 				ret = -EUCLEAN;  in __btrfs_free_extent()
3192 						&key, path, -1, 1);  in __btrfs_free_extent()
3193 			if (ret > 0 && skinny_metadata && path->slots[0]) {  in __btrfs_free_extent()
3198 				path->slots[0]--;  in __btrfs_free_extent()
3199 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3200 						      path->slots[0]);  in __btrfs_free_extent()
3214 							&key, path, -1, 1);  in __btrfs_free_extent()
3219 					btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3221 			"umm, got %d back from search, was looking for %llu, slot %d",  in __btrfs_free_extent()
3222 					  ret, bytenr, path->slots[0]);  in __btrfs_free_extent()
3228 			extent_slot = path->slots[0];  in __btrfs_free_extent()
3230 	} else if (WARN_ON(ret == -ENOENT)) {  in __btrfs_free_extent()
3232 "unable to find ref byte nr %llu parent %llu root %llu owner %llu offset %llu slot %d",  in __btrfs_free_extent()
3233 			       bytenr, node->parent, node->ref_root, owner_objectid,  in __btrfs_free_extent()
3234 			       owner_offset, path->slots[0]);  in __btrfs_free_extent()
3241 	leaf = path->nodes[0];  in __btrfs_free_extent()
3244 		ret = -EUCLEAN;  in __btrfs_free_extent()
3245 		btrfs_err(trans->fs_info,  in __btrfs_free_extent()
3246 			  "unexpected extent item size, has %u expect >= %zu",  in __btrfs_free_extent()
3259 "invalid extent item size for key (%llu, %u, %llu) slot %u owner %llu, has %u expect >= %zu",  in __btrfs_free_extent()
3261 				       path->slots[0], owner_objectid, item_size,  in __btrfs_free_extent()
3263 			ret = -EUCLEAN;  in __btrfs_free_extent()
3273 		"trying to drop %d refs but we only have %llu for bytenr %llu slot %u",  in __btrfs_free_extent()
3274 			       refs_to_drop, refs, bytenr, path->slots[0]);  in __btrfs_free_extent()
3275 		ret = -EUCLEAN;  in __btrfs_free_extent()
3278 	refs -= refs_to_drop;  in __btrfs_free_extent()
3291 					       path->slots[0]);  in __btrfs_free_extent()
3292 				ret = -EUCLEAN;  in __btrfs_free_extent()
3322 					       refs_to_drop, path->slots[0]);  in __btrfs_free_extent()
3323 				ret = -EUCLEAN;  in __btrfs_free_extent()
3327 				if (unlikely(path->slots[0] != extent_slot)) {  in __btrfs_free_extent()
3331 						       key.offset, path->slots[0]);  in __btrfs_free_extent()
3332 					ret = -EUCLEAN;  in __btrfs_free_extent()
3342 				if (unlikely(path->slots[0] != extent_slot + 1)) {  in __btrfs_free_extent()
3345 						       path->slots[0]);  in __btrfs_free_extent()
3346 					ret = -EUCLEAN;  in __btrfs_free_extent()
3349 				path->slots[0] = extent_slot;  in __btrfs_free_extent()
3361 			delta.root = btrfs_get_extent_owner_root(trans->fs_info,  in __btrfs_free_extent()
3364 		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],  in __btrfs_free_extent()
3382  * when we free an block, it is possible (and likely) that we free the last
3390 	struct btrfs_fs_info *fs_info = trans->fs_info;  in check_ref_cleanup()
3395 	delayed_refs = &trans->transaction->delayed_refs;  in check_ref_cleanup()
3396 	spin_lock(&delayed_refs->lock);  in check_ref_cleanup()
3401 	spin_lock(&head->lock);  in check_ref_cleanup()
3402 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in check_ref_cleanup()
3412 	if (!mutex_trylock(&head->mutex))  in check_ref_cleanup()
3416 	head->processing = false;  in check_ref_cleanup()
3418 	spin_unlock(&head->lock);  in check_ref_cleanup()
3419 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3421 	BUG_ON(head->extent_op);  in check_ref_cleanup()
3422 	if (head->must_insert_reserved)  in check_ref_cleanup()
3426 	mutex_unlock(&head->mutex);  in check_ref_cleanup()
3430 	spin_unlock(&head->lock);  in check_ref_cleanup()
3433 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3442 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_free_tree_block()
3449 			.bytenr = buf->start,  in btrfs_free_tree_block()
3450 			.num_bytes = buf->len,  in btrfs_free_tree_block()
3474 	if (btrfs_header_generation(buf) != trans->transid)  in btrfs_free_tree_block()
3478 		ret = check_ref_cleanup(trans, buf->start);  in btrfs_free_tree_block()
3483 	bg = btrfs_lookup_block_group(fs_info, buf->start);  in btrfs_free_tree_block()
3486 		pin_down_extent(trans, bg, buf->start, buf->len, 1);  in btrfs_free_tree_block()
3493 	 * operations for this node.  If we re-allocate this node we  in btrfs_free_tree_block()
3498 	 * operations that happened when the block was part of root A,  in btrfs_free_tree_block()
3508 	if (test_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags)  in btrfs_free_tree_block()
3510 		pin_down_extent(trans, bg, buf->start, buf->len, 1);  in btrfs_free_tree_block()
3515 	WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));  in btrfs_free_tree_block()
3517 	btrfs_add_free_space(bg, buf->start, buf->len);  in btrfs_free_tree_block()
3518 	btrfs_free_reserved_bytes(bg, buf->len, false);  in btrfs_free_tree_block()
3520 	trace_btrfs_reserved_extent_free(fs_info, buf->start, buf->len);  in btrfs_free_tree_block()
3526 /* Can return -ENOMEM */
3529 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_free_extent()
3539 	if (ref->ref_root == BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_extent()
3540 		btrfs_pin_extent(trans, ref->bytenr, ref->num_bytes, 1);  in btrfs_free_extent()
3542 	} else if (ref->type == BTRFS_REF_METADATA) {  in btrfs_free_extent()
3548 	if (ref->ref_root != BTRFS_TREE_LOG_OBJECTID)  in btrfs_free_extent()
3556 	 * Start caching block groups but do not wait for progress or for them
3562 	 * Wait for the block group free_space >= the space we're waiting for if
3563 	 * the block group isn't cached.
3568 	 * Allow allocations to happen from block groups that do not yet have a
3569 	 * size classification.
3579 	 * Ignore the size class restrictions for this allocation.
3584 	 * Ignore the empty size, only try to allocate the number of bytes
3591 btrfs_lock_block_group(struct btrfs_block_group *cache,  in btrfs_lock_block_group()  argument
3595 		down_read(&cache->data_rwsem);  in btrfs_lock_block_group()
3598 static inline void btrfs_grab_block_group(struct btrfs_block_group *cache,  in btrfs_grab_block_group()  argument
3601 	btrfs_get_block_group(cache);  in btrfs_grab_block_group()
3603 		down_read(&cache->data_rwsem);  in btrfs_grab_block_group()
3610 	__acquires(&cluster->refill_lock)  in btrfs_lock_cluster()
3614 	spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3616 		used_bg = cluster->block_group;  in btrfs_lock_cluster()
3628 		if (down_read_trylock(&used_bg->data_rwsem))  in btrfs_lock_cluster()
3631 		spin_unlock(&cluster->refill_lock);  in btrfs_lock_cluster()
3633 		/* We should only have one-level nested. */  in btrfs_lock_cluster()
3634 		down_read_nested(&used_bg->data_rwsem, SINGLE_DEPTH_NESTING);  in btrfs_lock_cluster()
3636 		spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3637 		if (used_bg == cluster->block_group)  in btrfs_lock_cluster()
3640 		up_read(&used_bg->data_rwsem);  in btrfs_lock_cluster()
3646 btrfs_release_block_group(struct btrfs_block_group *cache,  in btrfs_release_block_group()  argument
3650 		up_read(&cache->data_rwsem);  in btrfs_release_block_group()
3651 	btrfs_put_block_group(cache);  in btrfs_release_block_group()
3657 	if (ffe_ctl->policy == BTRFS_EXTENT_ALLOC_ZONED)  in find_free_extent_check_size_class()
3661 	if (ffe_ctl->loop >= LOOP_WRONG_SIZE_CLASS)  in find_free_extent_check_size_class()
3663 	if (ffe_ctl->loop >= LOOP_UNSET_SIZE_CLASS &&  in find_free_extent_check_size_class()
3664 	    bg->size_class == BTRFS_BG_SZ_NONE)  in find_free_extent_check_size_class()
3666 	return ffe_ctl->size_class == bg->size_class;  in find_free_extent_check_size_class()
3672  * Return -ENOENT to inform caller that we need fallback to unclustered mode.
3674  * Return 0 means we have found a location and set ffe_ctl->found_offset.
3681 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_clustered()
3686 	cluster_bg = btrfs_lock_cluster(bg, last_ptr, ffe_ctl->delalloc);  in find_free_extent_clustered()
3689 	if (cluster_bg != bg && (cluster_bg->ro ||  in find_free_extent_clustered()
3690 	    !block_group_bits(cluster_bg, ffe_ctl->flags) ||  in find_free_extent_clustered()
3695 			ffe_ctl->num_bytes, cluster_bg->start,  in find_free_extent_clustered()
3696 			&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3698 		/* We have a block, we're done */  in find_free_extent_clustered()
3699 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3702 		ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3705 	WARN_ON(last_ptr->block_group != cluster_bg);  in find_free_extent_clustered()
3710 	 * lets just skip it and let the allocator find whatever block it can  in find_free_extent_clustered()
3715 	 * However, if the cluster is taken from the current block group,  in find_free_extent_clustered()
3719 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE && cluster_bg != bg) {  in find_free_extent_clustered()
3720 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3721 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3722 		return -ENOENT;  in find_free_extent_clustered()
3729 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3732 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE) {  in find_free_extent_clustered()
3733 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3734 		return -ENOENT;  in find_free_extent_clustered()
3738 			ffe_ctl->empty_cluster + ffe_ctl->empty_size,  in find_free_extent_clustered()
3739 			bg->full_stripe_len);  in find_free_extent_clustered()
3740 	ret = btrfs_find_space_cluster(bg, last_ptr, ffe_ctl->search_start,  in find_free_extent_clustered()
3741 			ffe_ctl->num_bytes, aligned_cluster);  in find_free_extent_clustered()
3745 				ffe_ctl->num_bytes, ffe_ctl->search_start,  in find_free_extent_clustered()
3746 				&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3749 			spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3750 			ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3757 	 * allocate a block from our cluster.  Free the cluster we've been  in find_free_extent_clustered()
3758 	 * trying to use, and go to the next block group.  in find_free_extent_clustered()
3761 	spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3767  * Return 0 when we found an free extent and set ffe_ctrl->found_offset
3772 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_unclustered()
3781 		spin_lock(&last_ptr->lock);  in find_free_extent_unclustered()
3782 		last_ptr->fragmented = 1;  in find_free_extent_unclustered()
3783 		spin_unlock(&last_ptr->lock);  in find_free_extent_unclustered()
3785 	if (ffe_ctl->cached) {  in find_free_extent_unclustered()
3788 		free_space_ctl = bg->free_space_ctl;  in find_free_extent_unclustered()
3789 		spin_lock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3790 		if (free_space_ctl->free_space <  in find_free_extent_unclustered()
3791 		    ffe_ctl->num_bytes + ffe_ctl->empty_cluster +  in find_free_extent_unclustered()
3792 		    ffe_ctl->empty_size) {  in find_free_extent_unclustered()
3793 			ffe_ctl->total_free_space = max_t(u64,  in find_free_extent_unclustered()
3794 					ffe_ctl->total_free_space,  in find_free_extent_unclustered()
3795 					free_space_ctl->free_space);  in find_free_extent_unclustered()
3796 			spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3799 		spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3802 	offset = btrfs_find_space_for_alloc(bg, ffe_ctl->search_start,  in find_free_extent_unclustered()
3803 			ffe_ctl->num_bytes, ffe_ctl->empty_size,  in find_free_extent_unclustered()
3804 			&ffe_ctl->max_extent_size);  in find_free_extent_unclustered()
3807 	ffe_ctl->found_offset = offset;  in find_free_extent_unclustered()
3818 	if (ffe_ctl->last_ptr && ffe_ctl->use_cluster) {  in do_allocation_clustered()
3822 		/* ret == -ENOENT case falls through */  in do_allocation_clustered()
3829  * Tree-log block group locking
3833  * indicates the starting address of a block group, which is reserved only
3834  * for tree-log metadata.
3845  * Simple allocator for sequential-only block group. It only allows sequential
3853 	struct btrfs_fs_info *fs_info = block_group->fs_info;  in do_allocation_zoned()
3854 	struct btrfs_space_info *space_info = block_group->space_info;  in do_allocation_zoned()
3855 	struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;  in do_allocation_zoned()
3856 	u64 start = block_group->start;  in do_allocation_zoned()
3857 	u64 num_bytes = ffe_ctl->num_bytes;  in do_allocation_zoned()
3859 	u64 bytenr = block_group->start;  in do_allocation_zoned()
3865 	ASSERT(btrfs_is_zoned(block_group->fs_info));  in do_allocation_zoned()
3868 	 * Do not allow non-tree-log blocks in the dedicated tree-log block  in do_allocation_zoned()
3871 	spin_lock(&fs_info->treelog_bg_lock);  in do_allocation_zoned()
3872 	log_bytenr = fs_info->treelog_bg;  in do_allocation_zoned()
3873 	if (log_bytenr && ((ffe_ctl->for_treelog && bytenr != log_bytenr) ||  in do_allocation_zoned()
3874 			   (!ffe_ctl->for_treelog && bytenr == log_bytenr)))  in do_allocation_zoned()
3876 	spin_unlock(&fs_info->treelog_bg_lock);  in do_allocation_zoned()
3881 	 * Do not allow non-relocation blocks in the dedicated relocation block  in do_allocation_zoned()
3884 	spin_lock(&fs_info->relocation_bg_lock);  in do_allocation_zoned()
3885 	data_reloc_bytenr = fs_info->data_reloc_bg;  in do_allocation_zoned()
3887 	    ((ffe_ctl->for_data_reloc && bytenr != data_reloc_bytenr) ||  in do_allocation_zoned()
3888 	     (!ffe_ctl->for_data_reloc && bytenr == data_reloc_bytenr)))  in do_allocation_zoned()
3890 	spin_unlock(&fs_info->relocation_bg_lock);  in do_allocation_zoned()
3895 	spin_lock(&block_group->lock);  in do_allocation_zoned()
3896 	if (block_group->ro || btrfs_zoned_bg_is_full(block_group)) {  in do_allocation_zoned()
3899 		 * May need to clear fs_info->{treelog,data_reloc}_bg.  in do_allocation_zoned()
3903 	spin_unlock(&block_group->lock);  in do_allocation_zoned()
3905 	/* Metadata block group is activated at write time. */  in do_allocation_zoned()
3906 	if (!ret && (block_group->flags & BTRFS_BLOCK_GROUP_DATA) &&  in do_allocation_zoned()
3910 		 * May need to clear fs_info->{treelog,data_reloc}_bg.  in do_allocation_zoned()
3915 	spin_lock(&space_info->lock);  in do_allocation_zoned()
3916 	spin_lock(&block_group->lock);  in do_allocation_zoned()
3917 	spin_lock(&fs_info->treelog_bg_lock);  in do_allocation_zoned()
3918 	spin_lock(&fs_info->relocation_bg_lock);  in do_allocation_zoned()
3923 	ASSERT(!ffe_ctl->for_treelog ||  in do_allocation_zoned()
3924 	       block_group->start == fs_info->treelog_bg ||  in do_allocation_zoned()
3925 	       fs_info->treelog_bg == 0);  in do_allocation_zoned()
3926 	ASSERT(!ffe_ctl->for_data_reloc ||  in do_allocation_zoned()
3927 	       block_group->start == fs_info->data_reloc_bg ||  in do_allocation_zoned()
3928 	       fs_info->data_reloc_bg == 0);  in do_allocation_zoned()
3930 	if (block_group->ro ||  in do_allocation_zoned()
3931 	    (!ffe_ctl->for_data_reloc &&  in do_allocation_zoned()
3932 	     test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags))) {  in do_allocation_zoned()
3938 	 * Do not allow currently using block group to be tree-log dedicated  in do_allocation_zoned()
3939 	 * block group.  in do_allocation_zoned()
3941 	if (ffe_ctl->for_treelog && !fs_info->treelog_bg &&  in do_allocation_zoned()
3942 	    (block_group->used || block_group->reserved)) {  in do_allocation_zoned()
3948 	 * Do not allow currently used block group to be the data relocation  in do_allocation_zoned()
3949 	 * dedicated block group.  in do_allocation_zoned()
3951 	if (ffe_ctl->for_data_reloc && !fs_info->data_reloc_bg &&  in do_allocation_zoned()
3952 	    (block_group->used || block_group->reserved)) {  in do_allocation_zoned()
3957 	WARN_ON_ONCE(block_group->alloc_offset > block_group->zone_capacity);  in do_allocation_zoned()
3958 	avail = block_group->zone_capacity - block_group->alloc_offset;  in do_allocation_zoned()
3960 		if (ffe_ctl->max_extent_size < avail) {  in do_allocation_zoned()
3965 			ffe_ctl->max_extent_size = avail;  in do_allocation_zoned()
3966 			ffe_ctl->total_free_space = avail;  in do_allocation_zoned()
3972 	if (ffe_ctl->for_treelog && !fs_info->treelog_bg)  in do_allocation_zoned()
3973 		fs_info->treelog_bg = block_group->start;  in do_allocation_zoned()
3975 	if (ffe_ctl->for_data_reloc) {  in do_allocation_zoned()
3976 		if (!fs_info->data_reloc_bg)  in do_allocation_zoned()
3977 			fs_info->data_reloc_bg = block_group->start;  in do_allocation_zoned()
3979 		 * Do not allow allocations from this block group, unless it is  in do_allocation_zoned()
3980 		 * for data relocation. Compared to increasing the ->ro, setting  in do_allocation_zoned()
3981 		 * the ->zoned_data_reloc_ongoing flag still allows nocow  in do_allocation_zoned()
3985 		 * regular (non-relocation data) extent. With mix of relocation  in do_allocation_zoned()
3991 		 * Also, this flag avoids this block group to be zone finished.  in do_allocation_zoned()
3993 		set_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags);  in do_allocation_zoned()
3996 	ffe_ctl->found_offset = start + block_group->alloc_offset;  in do_allocation_zoned()
3997 	block_group->alloc_offset += num_bytes;  in do_allocation_zoned()
3998 	spin_lock(&ctl->tree_lock);  in do_allocation_zoned()
3999 	ctl->free_space -= num_bytes;  in do_allocation_zoned()
4000 	spin_unlock(&ctl->tree_lock);  in do_allocation_zoned()
4007 	ffe_ctl->search_start = ffe_ctl->found_offset;  in do_allocation_zoned()
4010 	if (ret && ffe_ctl->for_treelog)  in do_allocation_zoned()
4011 		fs_info->treelog_bg = 0;  in do_allocation_zoned()
4012 	if (ret && ffe_ctl->for_data_reloc)  in do_allocation_zoned()
4013 		fs_info->data_reloc_bg = 0;  in do_allocation_zoned()
4014 	spin_unlock(&fs_info->relocation_bg_lock);  in do_allocation_zoned()
4015 	spin_unlock(&fs_info->treelog_bg_lock);  in do_allocation_zoned()
4016 	spin_unlock(&block_group->lock);  in do_allocation_zoned()
4017 	spin_unlock(&space_info->lock);  in do_allocation_zoned()
4025 	switch (ffe_ctl->policy) {  in do_allocation()
4039 	switch (ffe_ctl->policy) {  in release_block_group()
4041 		ffe_ctl->retry_uncached = false;  in release_block_group()
4050 	BUG_ON(btrfs_bg_flags_to_raid_index(block_group->flags) !=  in release_block_group()
4051 	       ffe_ctl->index);  in release_block_group()
4058 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in found_extent_clustered()
4060 	if (!ffe_ctl->use_cluster && last_ptr) {  in found_extent_clustered()
4061 		spin_lock(&last_ptr->lock);  in found_extent_clustered()
4062 		last_ptr->window_start = ins->objectid;  in found_extent_clustered()
4063 		spin_unlock(&last_ptr->lock);  in found_extent_clustered()
4070 	switch (ffe_ctl->policy) {  in found_extent()
4085 	/* Block group's activeness is not a requirement for METADATA block groups. */  in can_allocate_chunk_zoned()
4086 	if (!(ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA))  in can_allocate_chunk_zoned()
4090 	if (btrfs_can_activate_zone(fs_info->fs_devices, ffe_ctl->flags))  in can_allocate_chunk_zoned()
4094 	 * We already reached the max active zones. Try to finish one block  in can_allocate_chunk_zoned()
4095 	 * group to make a room for a new block group. This is only possible  in can_allocate_chunk_zoned()
4096 	 * for a data block group because btrfs_zone_finish() may need to wait  in can_allocate_chunk_zoned()
4100 	if (ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA) {  in can_allocate_chunk_zoned()
4110 	 * If we have enough free space left in an already active block group  in can_allocate_chunk_zoned()
4112 	 * new chunk and let find_free_extent() retry with a smaller size.  in can_allocate_chunk_zoned()
4114 	if (ffe_ctl->max_extent_size >= ffe_ctl->min_alloc_size)  in can_allocate_chunk_zoned()
4115 		return -ENOSPC;  in can_allocate_chunk_zoned()
4118 	 * Even min_alloc_size is not left in any block groups. Since we cannot  in can_allocate_chunk_zoned()
4119 	 * activate a new block group, allocating it may not help. Let's tell a  in can_allocate_chunk_zoned()
4121 	 * parts of the region. That is only possible for data block groups,  in can_allocate_chunk_zoned()
4124 	if (ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA)  in can_allocate_chunk_zoned()
4125 		return -EAGAIN;  in can_allocate_chunk_zoned()
4128 	 * We cannot activate a new block group and no enough space left in any  in can_allocate_chunk_zoned()
4129 	 * block groups. So, allocating a new block group may not help. But,  in can_allocate_chunk_zoned()
4138 	switch (ffe_ctl->policy) {  in can_allocate_chunk()
4149  * Return >0 means caller needs to re-search for free extent
4159 	struct btrfs_root *root = fs_info->chunk_root;  in find_free_extent_update_loop()
4162 	if ((ffe_ctl->loop == LOOP_CACHING_NOWAIT) &&  in find_free_extent_update_loop()
4163 	    ffe_ctl->have_caching_bg && !ffe_ctl->orig_have_caching_bg)  in find_free_extent_update_loop()
4164 		ffe_ctl->orig_have_caching_bg = true;  in find_free_extent_update_loop()
4166 	if (ins->objectid) {  in find_free_extent_update_loop()
4171 	if (ffe_ctl->loop >= LOOP_CACHING_WAIT && ffe_ctl->have_caching_bg)  in find_free_extent_update_loop()
4174 	ffe_ctl->index++;  in find_free_extent_update_loop()
4175 	if (ffe_ctl->index < BTRFS_NR_RAID_TYPES)  in find_free_extent_update_loop()
4179 	if (ffe_ctl->loop < LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
4180 		ffe_ctl->index = 0;  in find_free_extent_update_loop()
4186 		if (ffe_ctl->loop == LOOP_CACHING_NOWAIT &&  in find_free_extent_update_loop()
4187 		    (!ffe_ctl->orig_have_caching_bg && full_search))  in find_free_extent_update_loop()
4188 			ffe_ctl->loop++;  in find_free_extent_update_loop()
4189 		ffe_ctl->loop++;  in find_free_extent_update_loop()
4191 		if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {  in find_free_extent_update_loop()
4200 			trans = current->journal_info;  in find_free_extent_update_loop()
4211 			ret = btrfs_chunk_alloc(trans, space_info, ffe_ctl->flags,  in find_free_extent_update_loop()
4215 			if (ret == -ENOSPC) {  in find_free_extent_update_loop()
4217 				ffe_ctl->loop++;  in find_free_extent_update_loop()
4229 		if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
4230 			if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)  in find_free_extent_update_loop()
4231 				return -ENOSPC;  in find_free_extent_update_loop()
4237 			if (ffe_ctl->empty_size == 0 &&  in find_free_extent_update_loop()
4238 			    ffe_ctl->empty_cluster == 0)  in find_free_extent_update_loop()
4239 				return -ENOSPC;  in find_free_extent_update_loop()
4240 			ffe_ctl->empty_size = 0;  in find_free_extent_update_loop()
4241 			ffe_ctl->empty_cluster = 0;  in find_free_extent_update_loop()
4245 	return -ENOSPC;  in find_free_extent_update_loop()
4263 	if (space_info->max_extent_size) {  in prepare_allocation_clustered()
4264 		spin_lock(&space_info->lock);  in prepare_allocation_clustered()
4265 		if (space_info->max_extent_size &&  in prepare_allocation_clustered()
4266 		    ffe_ctl->num_bytes > space_info->max_extent_size) {  in prepare_allocation_clustered()
4267 			ins->offset = space_info->max_extent_size;  in prepare_allocation_clustered()
4268 			spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
4269 			return -ENOSPC;  in prepare_allocation_clustered()
4270 		} else if (space_info->max_extent_size) {  in prepare_allocation_clustered()
4271 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
4273 		spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
4276 	ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,  in prepare_allocation_clustered()
4277 					       &ffe_ctl->empty_cluster);  in prepare_allocation_clustered()
4278 	if (ffe_ctl->last_ptr) {  in prepare_allocation_clustered()
4279 		struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in prepare_allocation_clustered()
4281 		spin_lock(&last_ptr->lock);  in prepare_allocation_clustered()
4282 		if (last_ptr->block_group)  in prepare_allocation_clustered()
4283 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
4284 		if (last_ptr->fragmented) {  in prepare_allocation_clustered()
4290 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
4291 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
4293 		spin_unlock(&last_ptr->lock);  in prepare_allocation_clustered()
4303 	if (ffe_ctl->for_treelog) {  in prepare_allocation_zoned()
4304 		spin_lock(&fs_info->treelog_bg_lock);  in prepare_allocation_zoned()
4305 		if (fs_info->treelog_bg)  in prepare_allocation_zoned()
4306 			ffe_ctl->hint_byte = fs_info->treelog_bg;  in prepare_allocation_zoned()
4307 		spin_unlock(&fs_info->treelog_bg_lock);  in prepare_allocation_zoned()
4308 	} else if (ffe_ctl->for_data_reloc) {  in prepare_allocation_zoned()
4309 		spin_lock(&fs_info->relocation_bg_lock);  in prepare_allocation_zoned()
4310 		if (fs_info->data_reloc_bg)  in prepare_allocation_zoned()
4311 			ffe_ctl->hint_byte = fs_info->data_reloc_bg;  in prepare_allocation_zoned()
4312 		spin_unlock(&fs_info->relocation_bg_lock);  in prepare_allocation_zoned()
4313 	} else if (ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA) {  in prepare_allocation_zoned()
4316 		spin_lock(&fs_info->zone_active_bgs_lock);  in prepare_allocation_zoned()
4317 		list_for_each_entry(block_group, &fs_info->zone_active_bgs, active_bg_list) {  in prepare_allocation_zoned()
4322 			u64 avail = block_group->zone_capacity - block_group->alloc_offset;  in prepare_allocation_zoned()
4324 			if (block_group_bits(block_group, ffe_ctl->flags) &&  in prepare_allocation_zoned()
4325 			    block_group->space_info == space_info &&  in prepare_allocation_zoned()
4326 			    avail >= ffe_ctl->num_bytes) {  in prepare_allocation_zoned()
4327 				ffe_ctl->hint_byte = block_group->start;  in prepare_allocation_zoned()
4331 		spin_unlock(&fs_info->zone_active_bgs_lock);  in prepare_allocation_zoned()
4342 	switch (ffe_ctl->policy) {  in prepare_allocation()
4354  * walks the btree of allocated extents and find a hole of a given size.
4356  * ins->objectid == start position
4357  * ins->flags = BTRFS_EXTENT_ITEM_KEY
4358  * ins->offset == the size of the hole.
4361  * If there is no suitable free space, we will record the max size of
4367  * |- Iterate through all block groups
4368  * |  |- Get a valid block group
4369  * |  |- Try to do clustered allocation in that block group
4370  * |  |- Try to do unclustered allocation in that block group
4371  * |  |- Check if the result is valid
4372  * |  |  |- If valid, then exit
4373  * |  |- Jump to next block group
4375  * |- Push harder to find free extents
4376  *    |- If not found, re-iterate all block groups
4382 	struct btrfs_fs_info *fs_info = root->fs_info;  in find_free_extent()
4389 	WARN_ON(ffe_ctl->num_bytes < fs_info->sectorsize);  in find_free_extent()
4391 	ffe_ctl->search_start = 0;  in find_free_extent()
4393 	ffe_ctl->empty_cluster = 0;  in find_free_extent()
4394 	ffe_ctl->last_ptr = NULL;  in find_free_extent()
4395 	ffe_ctl->use_cluster = true;  in find_free_extent()
4396 	ffe_ctl->have_caching_bg = false;  in find_free_extent()
4397 	ffe_ctl->orig_have_caching_bg = false;  in find_free_extent()
4398 	ffe_ctl->index = btrfs_bg_flags_to_raid_index(ffe_ctl->flags);  in find_free_extent()
4399 	ffe_ctl->loop = 0;  in find_free_extent()
4400 	ffe_ctl->retry_uncached = false;  in find_free_extent()
4401 	ffe_ctl->cached = 0;  in find_free_extent()
4402 	ffe_ctl->max_extent_size = 0;  in find_free_extent()
4403 	ffe_ctl->total_free_space = 0;  in find_free_extent()
4404 	ffe_ctl->found_offset = 0;  in find_free_extent()
4405 	ffe_ctl->policy = BTRFS_EXTENT_ALLOC_CLUSTERED;  in find_free_extent()
4406 	ffe_ctl->size_class = btrfs_calc_block_group_size_class(ffe_ctl->num_bytes);  in find_free_extent()
4409 		ffe_ctl->policy = BTRFS_EXTENT_ALLOC_ZONED;  in find_free_extent()
4411 	ins->type = BTRFS_EXTENT_ITEM_KEY;  in find_free_extent()
4412 	ins->objectid = 0;  in find_free_extent()
4413 	ins->offset = 0;  in find_free_extent()
4417 	space_info = btrfs_find_space_info(fs_info, ffe_ctl->flags);  in find_free_extent()
4419 		/* Use dedicated sub-space_info for dedicated block group users. */  in find_free_extent()
4420 		if (ffe_ctl->for_data_reloc) {  in find_free_extent()
4421 			space_info = space_info->sub_group[0];  in find_free_extent()
4422 			ASSERT(space_info->subgroup_id == BTRFS_SUB_GROUP_DATA_RELOC);  in find_free_extent()
4423 		} else if (ffe_ctl->for_treelog) {  in find_free_extent()
4424 			space_info = space_info->sub_group[0];  in find_free_extent()
4425 			ASSERT(space_info->subgroup_id == BTRFS_SUB_GROUP_TREELOG);  in find_free_extent()
4429 		btrfs_err(fs_info, "no space info for %llu, tree-log %d, relocation %d",  in find_free_extent()
4430 			  ffe_ctl->flags, ffe_ctl->for_treelog, ffe_ctl->for_data_reloc);  in find_free_extent()
4431 		return -ENOSPC;  in find_free_extent()
4438 	ffe_ctl->search_start = max(ffe_ctl->search_start,  in find_free_extent()
4440 	ffe_ctl->search_start = max(ffe_ctl->search_start, ffe_ctl->hint_byte);  in find_free_extent()
4441 	if (ffe_ctl->search_start == ffe_ctl->hint_byte) {  in find_free_extent()
4443 						       ffe_ctl->search_start);  in find_free_extent()
4445 		 * we don't want to use the block group if it doesn't match our  in find_free_extent()
4448 		 * However if we are re-searching with an ideal block group  in find_free_extent()
4449 		 * picked out then we don't care that the block group is cached.  in find_free_extent()
4451 		if (block_group && block_group_bits(block_group, ffe_ctl->flags) &&  in find_free_extent()
4452 		    block_group->space_info == space_info &&  in find_free_extent()
4453 		    block_group->cached != BTRFS_CACHE_NO) {  in find_free_extent()
4454 			down_read(&space_info->groups_sem);  in find_free_extent()
4455 			if (list_empty(&block_group->list) ||  in find_free_extent()
4456 			    block_group->ro) {  in find_free_extent()
4458 				 * someone is removing this block group,  in find_free_extent()
4464 				up_read(&space_info->groups_sem);  in find_free_extent()
4466 				ffe_ctl->index = btrfs_bg_flags_to_raid_index(  in find_free_extent()
4467 							block_group->flags);  in find_free_extent()
4469 						       ffe_ctl->delalloc);  in find_free_extent()
4470 				ffe_ctl->hinted = true;  in find_free_extent()
4479 	ffe_ctl->have_caching_bg = false;  in find_free_extent()
4480 	if (ffe_ctl->index == btrfs_bg_flags_to_raid_index(ffe_ctl->flags) ||  in find_free_extent()
4481 	    ffe_ctl->index == 0)  in find_free_extent()
4483 	down_read(&space_info->groups_sem);  in find_free_extent()
4485 			    &space_info->block_groups[ffe_ctl->index], list) {  in find_free_extent()
4488 		ffe_ctl->hinted = false;  in find_free_extent()
4489 		/* If the block group is read-only, we can skip it entirely. */  in find_free_extent()
4490 		if (unlikely(block_group->ro)) {  in find_free_extent()
4491 			if (ffe_ctl->for_treelog)  in find_free_extent()
4493 			if (ffe_ctl->for_data_reloc)  in find_free_extent()
4498 		btrfs_grab_block_group(block_group, ffe_ctl->delalloc);  in find_free_extent()
4499 		ffe_ctl->search_start = block_group->start;  in find_free_extent()
4506 		if (!block_group_bits(block_group, ffe_ctl->flags)) {  in find_free_extent()
4513 			 * if they asked for extra copies and this block group  in find_free_extent()
4517 			if ((ffe_ctl->flags & extra) && !(block_group->flags & extra))  in find_free_extent()
4521 			 * This block group has different flags than we want.  in find_free_extent()
4523 			 * block group is mixed.  Just skip such block group.  in find_free_extent()
4525 			btrfs_release_block_group(block_group, ffe_ctl->delalloc);  in find_free_extent()
4531 		ffe_ctl->cached = btrfs_block_group_done(block_group);  in find_free_extent()
4532 		if (unlikely(!ffe_ctl->cached)) {  in find_free_extent()
4533 			ffe_ctl->have_caching_bg = true;  in find_free_extent()
4538 			 * try other block groups, because it may not be fatal.  in find_free_extent()
4552 		if (unlikely(block_group->cached == BTRFS_CACHE_ERROR)) {  in find_free_extent()
4554 				cache_block_group_error = -EIO;  in find_free_extent()
4567 			btrfs_release_block_group(block_group, ffe_ctl->delalloc);  in find_free_extent()
4572 		ffe_ctl->search_start = round_up(ffe_ctl->found_offset,  in find_free_extent()
4573 						 fs_info->stripesize);  in find_free_extent()
4576 		if (ffe_ctl->search_start + ffe_ctl->num_bytes >  in find_free_extent()
4577 		    block_group->start + block_group->length) {  in find_free_extent()
4579 					    ffe_ctl->found_offset,  in find_free_extent()
4580 					    ffe_ctl->num_bytes);  in find_free_extent()
4584 		if (ffe_ctl->found_offset < ffe_ctl->search_start)  in find_free_extent()
4586 					ffe_ctl->found_offset,  in find_free_extent()
4587 					ffe_ctl->search_start - ffe_ctl->found_offset);  in find_free_extent()
4589 		ret = btrfs_add_reserved_bytes(block_group, ffe_ctl->ram_bytes,  in find_free_extent()
4590 					       ffe_ctl->num_bytes,  in find_free_extent()
4591 					       ffe_ctl->delalloc,  in find_free_extent()
4592 					       ffe_ctl->loop >= LOOP_WRONG_SIZE_CLASS);  in find_free_extent()
4593 		if (ret == -EAGAIN) {  in find_free_extent()
4595 					ffe_ctl->found_offset,  in find_free_extent()
4596 					ffe_ctl->num_bytes);  in find_free_extent()
4602 		ins->objectid = ffe_ctl->search_start;  in find_free_extent()
4603 		ins->offset = ffe_ctl->num_bytes;  in find_free_extent()
4606 		btrfs_release_block_group(block_group, ffe_ctl->delalloc);  in find_free_extent()
4609 		if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&  in find_free_extent()
4610 		    !ffe_ctl->retry_uncached) {  in find_free_extent()
4611 			ffe_ctl->retry_uncached = true;  in find_free_extent()
4613 						ffe_ctl->num_bytes +  in find_free_extent()
4614 						ffe_ctl->empty_cluster +  in find_free_extent()
4615 						ffe_ctl->empty_size);  in find_free_extent()
4618 		release_block_group(block_group, ffe_ctl, ffe_ctl->delalloc);  in find_free_extent()
4621 	up_read(&space_info->groups_sem);  in find_free_extent()
4628 	if (ret == -ENOSPC && !cache_block_group_error) {  in find_free_extent()
4630 		 * Use ffe_ctl->total_free_space as fallback if we can't find  in find_free_extent()
4633 		if (!ffe_ctl->max_extent_size)  in find_free_extent()
4634 			ffe_ctl->max_extent_size = ffe_ctl->total_free_space;  in find_free_extent()
4635 		spin_lock(&space_info->lock);  in find_free_extent()
4636 		space_info->max_extent_size = ffe_ctl->max_extent_size;  in find_free_extent()
4637 		spin_unlock(&space_info->lock);  in find_free_extent()
4638 		ins->offset = ffe_ctl->max_extent_size;  in find_free_extent()
4639 	} else if (ret == -ENOSPC) {  in find_free_extent()
4649  * @root           -	The root that will contain this extent
4651  * @ram_bytes      -	The amount of space in ram that @num_bytes take. This
4655  * @num_bytes      -	Number of bytes to allocate on-disk.
4657  * @min_alloc_size -	Indicates the minimum amount of space that the
4664  * @empty_size     -	A hint that you plan on doing more COW. This is the
4665  *			size in bytes the allocator should try to find free
4666  *			next to the block it returns.  This is just a hint and
4669  * @hint_byte      -	Hint to the allocator to start searching above the byte
4672  * @ins            -	This key is modified to record the found hole. It will
4674  *			ins->objectid == start position
4675  *			ins->flags = BTRFS_EXTENT_ITEM_KEY
4676  *			ins->offset == the size of the hole.
4678  * @is_data        -	Boolean flag indicating whether an extent is
4681  * @delalloc       -	Boolean flag indicating whether this allocation is for
4682  *			delalloc or not. If 'true' data_rwsem of block groups
4687  * case -ENOSPC is returned then @ins->offset will contain the size of the
4695 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_reserve_extent()
4705 	WARN_ON(num_bytes < fs_info->sectorsize);  in btrfs_reserve_extent()
4719 		btrfs_dec_block_group_reservations(fs_info, ins->objectid);  in btrfs_reserve_extent()
4720 	} else if (ret == -ENOSPC) {  in btrfs_reserve_extent()
4721 		if (!final_tried && ins->offset) {  in btrfs_reserve_extent()
4722 			num_bytes = min(num_bytes >> 1, ins->offset);  in btrfs_reserve_extent()
4724 					       fs_info->sectorsize);  in btrfs_reserve_extent()
4735 	"allocation failed flags %llu, wanted %llu tree-log %d, relocation: %d",  in btrfs_reserve_extent()
4749 	struct btrfs_block_group *cache;  in btrfs_free_reserved_extent()  local
4751 	cache = btrfs_lookup_block_group(fs_info, start);  in btrfs_free_reserved_extent()
4752 	if (!cache) {  in btrfs_free_reserved_extent()
4753 		btrfs_err(fs_info, "Unable to find block group for %llu",  in btrfs_free_reserved_extent()
4755 		return -ENOSPC;  in btrfs_free_reserved_extent()
4758 	btrfs_add_free_space(cache, start, len);  in btrfs_free_reserved_extent()
4759 	btrfs_free_reserved_bytes(cache, len, is_delalloc);  in btrfs_free_reserved_extent()
4762 	btrfs_put_block_group(cache);  in btrfs_free_reserved_extent()
4769 	struct btrfs_block_group *cache;  in btrfs_pin_reserved_extent()  local
4772 	cache = btrfs_lookup_block_group(trans->fs_info, eb->start);  in btrfs_pin_reserved_extent()
4773 	if (!cache) {  in btrfs_pin_reserved_extent()
4774 		btrfs_err(trans->fs_info, "unable to find block group for %llu",  in btrfs_pin_reserved_extent()
4775 			  eb->start);  in btrfs_pin_reserved_extent()
4776 		return -ENOSPC;  in btrfs_pin_reserved_extent()
4779 	ret = pin_down_extent(trans, cache, eb->start, eb->len, 1);  in btrfs_pin_reserved_extent()
4780 	btrfs_put_block_group(cache);  in btrfs_pin_reserved_extent()
4787 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_extent()
4797 		btrfs_err(fs_info, "update block group failed for %llu %llu",  in alloc_reserved_extent()
4811 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_file_extent()
4820 	u32 size;  in alloc_reserved_file_extent()  local
4828 	size = sizeof(*extent_item);  in alloc_reserved_file_extent()
4830 		size += btrfs_extent_inline_ref_size(BTRFS_EXTENT_OWNER_REF_KEY);  in alloc_reserved_file_extent()
4831 	size += btrfs_extent_inline_ref_size(type);  in alloc_reserved_file_extent()
4835 		return -ENOMEM;  in alloc_reserved_file_extent()
4837 	extent_root = btrfs_extent_root(fs_info, ins->objectid);  in alloc_reserved_file_extent()
4838 	ret = btrfs_insert_empty_item(trans, extent_root, path, ins, size);  in alloc_reserved_file_extent()
4844 	leaf = path->nodes[0];  in alloc_reserved_file_extent()
4845 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_file_extent()
4848 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_file_extent()
4855 		oref = (struct btrfs_extent_owner_ref *)(&iref->offset);  in alloc_reserved_file_extent()
4868 		ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in alloc_reserved_file_extent()
4877 	return alloc_reserved_extent(trans, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4884 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_tree_block()
4893 	u32 size = sizeof(*extent_item) + sizeof(*iref);  in alloc_reserved_tree_block()  local
4894 	const u64 flags = (extent_op ? extent_op->flags_to_set : 0);  in alloc_reserved_tree_block()
4895 	/* The owner of a tree block is the level. */  in alloc_reserved_tree_block()
4899 	extent_key.objectid = node->bytenr;  in alloc_reserved_tree_block()
4901 		/* The owner of a tree block is the level. */  in alloc_reserved_tree_block()
4905 		extent_key.offset = node->num_bytes;  in alloc_reserved_tree_block()
4907 		size += sizeof(*block_info);  in alloc_reserved_tree_block()
4912 		return -ENOMEM;  in alloc_reserved_tree_block()
4916 				      size);  in alloc_reserved_tree_block()
4922 	leaf = path->nodes[0];  in alloc_reserved_tree_block()
4923 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_tree_block()
4926 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_tree_block()
4934 		btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);  in alloc_reserved_tree_block()
4939 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY) {  in alloc_reserved_tree_block()
4942 		btrfs_set_extent_inline_ref_offset(leaf, iref, node->parent);  in alloc_reserved_tree_block()
4946 		btrfs_set_extent_inline_ref_offset(leaf, iref, node->ref_root);  in alloc_reserved_tree_block()
4951 	return alloc_reserved_extent(trans, node->bytenr, fs_info->nodesize);  in alloc_reserved_tree_block()
4961 		.bytenr = ins->objectid,  in btrfs_alloc_reserved_file_extent()
4962 		.num_bytes = ins->offset,  in btrfs_alloc_reserved_file_extent()
4969 	if (btrfs_is_data_reloc_root(root) && btrfs_is_fstree(root->relocation_src_root))  in btrfs_alloc_reserved_file_extent()
4970 		generic_ref.owning_root = root->relocation_src_root;  in btrfs_alloc_reserved_file_extent()
4973 	btrfs_ref_tree_mod(root->fs_info, &generic_ref);  in btrfs_alloc_reserved_file_extent()
4981  * space cache bits as well
4987 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_alloc_logged_file_extent()
4993 		.num_bytes = ins->offset,  in btrfs_alloc_logged_file_extent()
4994 		.generation = trans->transid,  in btrfs_alloc_logged_file_extent()
5000 	 * Mixed block groups will exclude before processing the log so we only  in btrfs_alloc_logged_file_extent()
5004 		ret = __exclude_logged_extent(fs_info, ins->objectid,  in btrfs_alloc_logged_file_extent()
5005 					      ins->offset);  in btrfs_alloc_logged_file_extent()
5010 	block_group = btrfs_lookup_block_group(fs_info, ins->objectid);  in btrfs_alloc_logged_file_extent()
5012 		return -EINVAL;  in btrfs_alloc_logged_file_extent()
5014 	space_info = block_group->space_info;  in btrfs_alloc_logged_file_extent()
5015 	spin_lock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
5016 	spin_lock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
5017 	space_info->bytes_reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
5018 	block_group->reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
5019 	spin_unlock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
5020 	spin_unlock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
5025 		btrfs_pin_extent(trans, ins->objectid, ins->offset, 1);  in btrfs_alloc_logged_file_extent()
5034  * chooses to use a tree block which is already used and locked.
5038 	if (eb->lock_owner == current->pid) {  in check_eb_lock_owner()
5039 		btrfs_err_rl(eb->fs_info,  in check_eb_lock_owner()
5040 "tree block %llu owner %llu already locked by pid=%d, extent tree corruption detected",  in check_eb_lock_owner()
5041 			     eb->start, btrfs_header_owner(eb), current->pid);  in check_eb_lock_owner()
5058 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_init_new_buffer()
5068 		return ERR_PTR(-EUCLEAN);  in btrfs_init_new_buffer()
5082 	    !test_bit(BTRFS_ROOT_RESET_LOCKDEP_CLASS, &root->state))  in btrfs_init_new_buffer()
5086 	btrfs_set_header_generation(buf, trans->transid);  in btrfs_init_new_buffer()
5089 	 * This needs to stay, because we could allocate a freed block from an  in btrfs_init_new_buffer()
5090 	 * old tree into a new tree, so we need to make sure this new block is  in btrfs_init_new_buffer()
5097 	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);  in btrfs_init_new_buffer()
5098 	clear_bit(EXTENT_BUFFER_ZONED_ZEROOUT, &buf->bflags);  in btrfs_init_new_buffer()
5104 	btrfs_set_header_bytenr(buf, buf->start);  in btrfs_init_new_buffer()
5105 	btrfs_set_header_generation(buf, trans->transid);  in btrfs_init_new_buffer()
5108 	write_extent_buffer_fsid(buf, fs_info->fs_devices->metadata_uuid);  in btrfs_init_new_buffer()
5109 	write_extent_buffer_chunk_tree_uuid(buf, fs_info->chunk_tree_uuid);  in btrfs_init_new_buffer()
5111 		buf->log_index = root->log_transid % 2;  in btrfs_init_new_buffer()
5116 		if (buf->log_index == 0)  in btrfs_init_new_buffer()
5117 			btrfs_set_extent_bit(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
5118 					     buf->start + buf->len - 1,  in btrfs_init_new_buffer()
5121 			btrfs_set_extent_bit(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
5122 					     buf->start + buf->len - 1,  in btrfs_init_new_buffer()
5125 		buf->log_index = -1;  in btrfs_init_new_buffer()
5126 		btrfs_set_extent_bit(&trans->transaction->dirty_pages, buf->start,  in btrfs_init_new_buffer()
5127 				     buf->start + buf->len - 1, EXTENT_DIRTY, NULL);  in btrfs_init_new_buffer()
5146 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_alloc_tree_block()
5152 	u32 blocksize = fs_info->nodesize;  in btrfs_alloc_tree_block()
5158 		buf = btrfs_init_new_buffer(trans, root, root->alloc_bytenr,  in btrfs_alloc_tree_block()
5161 			root->alloc_bytenr += blocksize;  in btrfs_alloc_tree_block()
5205 				ret = -ENOMEM;  in btrfs_alloc_tree_block()
5209 				memcpy(&extent_op->key, key, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
5211 				memset(&extent_op->key, 0, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
5212 			extent_op->flags_to_set = flags;  in btrfs_alloc_tree_block()
5213 			extent_op->update_key = (skinny_metadata ? false : true);  in btrfs_alloc_tree_block()
5214 			extent_op->update_flags = (flags != 0);  in btrfs_alloc_tree_block()
5260  * then freeing the block once we've processed all of the children.
5265  * We enter this stage when we have to walk into a child block (meaning we can't
5279  * @refs:	the number of refs for wc->level - 1
5280  * @flags:	the flags for wc->level - 1
5284  * wc->level should be read and walked into, or if we can simply delete our
5297 	int level = wc->level;  in visit_node_for_delete()
5300 	ASSERT(wc->refs[level - 1] > 0);  in visit_node_for_delete()
5306 	if (wc->stage == UPDATE_BACKREF) {  in visit_node_for_delete()
5313 	 * We're the last ref on this block, we must walk into it and process  in visit_node_for_delete()
5316 	if (wc->refs[level - 1] == 1)  in visit_node_for_delete()
5327 	 * This block is older than our creation generation, we can drop our  in visit_node_for_delete()
5331 	if (!wc->update_ref || generation <= btrfs_root_origin_generation(root))  in visit_node_for_delete()
5335 	 * This block was processed from a previous snapshot deletion run, we  in visit_node_for_delete()
5339 	if (btrfs_comp_cpu_keys(&key, &wc->update_progress) < 0)  in visit_node_for_delete()
5351 	struct btrfs_fs_info *fs_info = root->fs_info;  in reada_walk_down()
5362 	if (path->slots[wc->level] < wc->reada_slot) {  in reada_walk_down()
5363 		wc->reada_count = wc->reada_count * 2 / 3;  in reada_walk_down()
5364 		wc->reada_count = max(wc->reada_count, 2);  in reada_walk_down()
5366 		wc->reada_count = wc->reada_count * 3 / 2;  in reada_walk_down()
5367 		wc->reada_count = min_t(int, wc->reada_count,  in reada_walk_down()
5371 	eb = path->nodes[wc->level];  in reada_walk_down()
5374 	for (slot = path->slots[wc->level]; slot < nritems; slot++) {  in reada_walk_down()
5375 		if (nread >= wc->reada_count)  in reada_walk_down()
5382 		if (slot == path->slots[wc->level])  in reada_walk_down()
5385 		if (wc->stage == UPDATE_BACKREF &&  in reada_walk_down()
5389 		/* We don't lock the tree block, it's OK to be racy here */  in reada_walk_down()
5391 					       wc->level - 1, 1, &refs,  in reada_walk_down()
5413 	wc->reada_slot = slot;  in reada_walk_down()
5417  * helper to process tree block while walking down the tree.
5419  * when wc->stage == UPDATE_BACKREF, this function updates
5420  * back refs for pointers in the block.
5429 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_down_proc()
5430 	int level = wc->level;  in walk_down_proc()
5431 	struct extent_buffer *eb = path->nodes[level];  in walk_down_proc()
5435 	if (wc->stage == UPDATE_BACKREF && btrfs_header_owner(eb) != btrfs_root_id(root))  in walk_down_proc()
5439 	 * when reference count of tree block is 1, it won't increase  in walk_down_proc()
5442 	if (wc->lookup_info &&  in walk_down_proc()
5443 	    ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||  in walk_down_proc()
5444 	     (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {  in walk_down_proc()
5445 		ASSERT(path->locks[level]);  in walk_down_proc()
5447 					       eb->start, level, 1,  in walk_down_proc()
5448 					       &wc->refs[level],  in walk_down_proc()
5449 					       &wc->flags[level],  in walk_down_proc()
5453 		if (unlikely(wc->refs[level] == 0)) {  in walk_down_proc()
5455 				  eb->start);  in walk_down_proc()
5456 			return -EUCLEAN;  in walk_down_proc()
5460 	if (wc->stage == DROP_REFERENCE) {  in walk_down_proc()
5461 		if (wc->refs[level] > 1)  in walk_down_proc()
5464 		if (path->locks[level] && !wc->keep_locks) {  in walk_down_proc()
5465 			btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
5466 			path->locks[level] = 0;  in walk_down_proc()
5471 	/* wc->stage == UPDATE_BACKREF */  in walk_down_proc()
5472 	if (!(wc->flags[level] & flag)) {  in walk_down_proc()
5473 		ASSERT(path->locks[level]);  in walk_down_proc()
5489 		wc->flags[level] |= flag;  in walk_down_proc()
5493 	 * the block is shared by multiple trees, so it's not good to  in walk_down_proc()
5496 	if (path->locks[level] && level > 0) {  in walk_down_proc()
5497 		btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
5498 		path->locks[level] = 0;  in walk_down_proc()
5520 		return -ENOMEM;  in check_ref_exists()
5523 				    root->fs_info->nodesize, parent,  in check_ref_exists()
5525 	if (ret != -ENOENT) {  in check_ref_exists()
5528 		 * return the error if it's not -ENOENT;  in check_ref_exists()
5538 	delayed_refs = &trans->transaction->delayed_refs;  in check_ref_exists()
5539 	spin_lock(&delayed_refs->lock);  in check_ref_exists()
5540 	head = btrfs_find_delayed_ref_head(root->fs_info, delayed_refs, bytenr);  in check_ref_exists()
5543 	if (!mutex_trylock(&head->mutex)) {  in check_ref_exists()
5549 		refcount_inc(&head->refs);  in check_ref_exists()
5550 		spin_unlock(&delayed_refs->lock);  in check_ref_exists()
5554 		mutex_lock(&head->mutex);  in check_ref_exists()
5555 		mutex_unlock(&head->mutex);  in check_ref_exists()
5561 	mutex_unlock(&head->mutex);  in check_ref_exists()
5563 	spin_unlock(&delayed_refs->lock);  in check_ref_exists()
5568  * We may not have an uptodate block, so if we are going to walk down into this
5569  * block we need to drop the lock, read it off of the disk, re-lock it and
5580 	int level = wc->level;  in check_next_block_uptodate()
5585 	generation = btrfs_node_ptr_generation(path->nodes[level], path->slots[level]);  in check_next_block_uptodate()
5590 	check.level = level - 1;  in check_next_block_uptodate()
5594 	btrfs_node_key_to_cpu(path->nodes[level], &check.first_key, path->slots[level]);  in check_next_block_uptodate()
5605 	wc->lookup_info = 1;  in check_next_block_uptodate()
5610  * If we determine that we don't have to visit wc->level - 1 then we need to
5625 		.bytenr = next->start,  in maybe_drop_reference()
5626 		.num_bytes = root->fs_info->nodesize,  in maybe_drop_reference()
5630 	int level = wc->level;  in maybe_drop_reference()
5634 	if (wc->stage == UPDATE_BACKREF)  in maybe_drop_reference()
5637 	if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {  in maybe_drop_reference()
5638 		ref.parent = path->nodes[level]->start;  in maybe_drop_reference()
5640 		ASSERT(btrfs_root_id(root) == btrfs_header_owner(path->nodes[level]));  in maybe_drop_reference()
5641 		if (unlikely(btrfs_root_id(root) != btrfs_header_owner(path->nodes[level]))) {  in maybe_drop_reference()
5642 			btrfs_err(root->fs_info, "mismatched block owner");  in maybe_drop_reference()
5643 			return -EIO;  in maybe_drop_reference()
5651 	 * ->restarted flag.  in maybe_drop_reference()
5653 	if (wc->restarted) {  in maybe_drop_reference()
5654 		ret = check_ref_exists(trans, root, next->start, ref.parent,  in maybe_drop_reference()
5655 				       level - 1);  in maybe_drop_reference()
5659 		wc->restarted = 0;  in maybe_drop_reference()
5668 	    wc->refs[level - 1] > 1) {  in maybe_drop_reference()
5669 		u64 generation = btrfs_node_ptr_generation(path->nodes[level],  in maybe_drop_reference()
5670 							   path->slots[level]);  in maybe_drop_reference()
5672 		ret = btrfs_qgroup_trace_subtree(trans, next, generation, level - 1);  in maybe_drop_reference()
5674 			btrfs_err_rl(root->fs_info,  in maybe_drop_reference()
5675 "error %d accounting shared subtree, quota is out of sync, rescan required",  in maybe_drop_reference()
5686 	wc->drop_level = level;  in maybe_drop_reference()
5687 	find_next_key(path, level, &wc->drop_progress);  in maybe_drop_reference()
5689 	btrfs_init_tree_ref(&ref, level - 1, 0, false);  in maybe_drop_reference()
5694  * helper to process tree block pointer.
5696  * when wc->stage == DROP_REFERENCE, this function checks
5697  * reference count of the block pointed to. if the block
5699  * rooted at the block, this function changes wc->stage to
5700  * UPDATE_BACKREF. if the block is shared and there is no
5702  * to the block.
5711 	struct btrfs_fs_info *fs_info = root->fs_info;  in do_walk_down()
5716 	int level = wc->level;  in do_walk_down()
5719 	generation = btrfs_node_ptr_generation(path->nodes[level],  in do_walk_down()
5720 					       path->slots[level]);  in do_walk_down()
5722 	 * if the lower level block was created before the snapshot  in do_walk_down()
5726 	if (wc->stage == UPDATE_BACKREF &&  in do_walk_down()
5728 		wc->lookup_info = 1;  in do_walk_down()
5732 	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);  in do_walk_down()
5735 					    level - 1);  in do_walk_down()
5741 	ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,  in do_walk_down()
5742 				       &wc->refs[level - 1],  in do_walk_down()
5743 				       &wc->flags[level - 1],  in do_walk_down()
5748 	if (unlikely(wc->refs[level - 1] == 0)) {  in do_walk_down()
5751 		ret = -EUCLEAN;  in do_walk_down()
5754 	wc->lookup_info = 0;  in do_walk_down()
5757 	if (!visit_node_for_delete(root, wc, path->nodes[level],  in do_walk_down()
5758 				   wc->flags[level - 1], path->slots[level]))  in do_walk_down()
5763 	 * DROP_REFERENCE stage and this block is shared then we need to switch  in do_walk_down()
5766 	if (wc->stage == DROP_REFERENCE && wc->refs[level - 1] > 1) {  in do_walk_down()
5767 		wc->stage = UPDATE_BACKREF;  in do_walk_down()
5768 		wc->shared_level = level - 1;  in do_walk_down()
5775 	level--;  in do_walk_down()
5778 		btrfs_err(root->fs_info, "mismatched level");  in do_walk_down()
5779 		ret = -EIO;  in do_walk_down()
5782 	path->nodes[level] = next;  in do_walk_down()
5783 	path->slots[level] = 0;  in do_walk_down()
5784 	path->locks[level] = BTRFS_WRITE_LOCK;  in do_walk_down()
5785 	wc->level = level;  in do_walk_down()
5786 	if (wc->level == 1)  in do_walk_down()
5787 		wc->reada_slot = 0;  in do_walk_down()
5793 	wc->refs[level - 1] = 0;  in do_walk_down()
5794 	wc->flags[level - 1] = 0;  in do_walk_down()
5795 	wc->lookup_info = 1;  in do_walk_down()
5806  * helper to process tree block while walking up the tree.
5808  * when wc->stage == DROP_REFERENCE, this function drops
5809  * reference count on the block.
5811  * when wc->stage == UPDATE_BACKREF, this function changes
5812  * wc->stage back to DROP_REFERENCE if we changed wc->stage
5813  * to UPDATE_BACKREF previously while processing the block.
5822 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_up_proc()
5824 	int level = wc->level;  in walk_up_proc()
5825 	struct extent_buffer *eb = path->nodes[level];  in walk_up_proc()
5828 	if (wc->stage == UPDATE_BACKREF) {  in walk_up_proc()
5829 		ASSERT(wc->shared_level >= level);  in walk_up_proc()
5830 		if (level < wc->shared_level)  in walk_up_proc()
5833 		ret = find_next_key(path, level + 1, &wc->update_progress);  in walk_up_proc()
5835 			wc->update_ref = 0;  in walk_up_proc()
5837 		wc->stage = DROP_REFERENCE;  in walk_up_proc()
5838 		wc->shared_level = -1;  in walk_up_proc()
5839 		path->slots[level] = 0;  in walk_up_proc()
5842 		 * check reference count again if the block isn't locked.  in walk_up_proc()
5846 		if (!path->locks[level]) {  in walk_up_proc()
5849 			path->locks[level] = BTRFS_WRITE_LOCK;  in walk_up_proc()
5852 						       eb->start, level, 1,  in walk_up_proc()
5853 						       &wc->refs[level],  in walk_up_proc()
5854 						       &wc->flags[level],  in walk_up_proc()
5857 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5858 				path->locks[level] = 0;  in walk_up_proc()
5861 			if (unlikely(wc->refs[level] == 0)) {  in walk_up_proc()
5862 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5864 					  eb->start);  in walk_up_proc()
5865 				return -EUCLEAN;  in walk_up_proc()
5867 			if (wc->refs[level] == 1) {  in walk_up_proc()
5868 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5869 				path->locks[level] = 0;  in walk_up_proc()
5875 	/* wc->stage == DROP_REFERENCE */  in walk_up_proc()
5876 	ASSERT(path->locks[level] || wc->refs[level] == 1);  in walk_up_proc()
5878 	if (wc->refs[level] == 1) {  in walk_up_proc()
5880 			if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {  in walk_up_proc()
5897 	"error %d accounting leaf items, quota is out of sync, rescan required",  in walk_up_proc()
5902 		/* Make block locked assertion in btrfs_clear_buffer_dirty happy. */  in walk_up_proc()
5903 		if (!path->locks[level]) {  in walk_up_proc()
5905 			path->locks[level] = BTRFS_WRITE_LOCK;  in walk_up_proc()
5910 	if (eb == root->node) {  in walk_up_proc()
5911 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5912 			parent = eb->start;  in walk_up_proc()
5916 		if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5917 			parent = path->nodes[level + 1]->start;  in walk_up_proc()
5919 				  btrfs_header_owner(path->nodes[level + 1])))  in walk_up_proc()
5924 				    wc->refs[level] == 1);  in walk_up_proc()
5928 	wc->refs[level] = 0;  in walk_up_proc()
5929 	wc->flags[level] = 0;  in walk_up_proc()
5935 	return -EUCLEAN;  in walk_up_proc()
5942  * wc->level.  At this point path->nodes[wc->level] should be populated and
5951  * our current path->nodes[wc->level].  For DROP_REFERENCE that means dropping
5964 	int level = wc->level;  in walk_down_tree()
5967 	wc->lookup_info = 1;  in walk_down_tree()
5976 		if (path->slots[level] >=  in walk_down_tree()
5977 		    btrfs_header_nritems(path->nodes[level]))  in walk_down_tree()
5982 			path->slots[level]++;  in walk_down_tree()
5986 		level = wc->level;  in walk_down_tree()
5997  * UPDATE_BACKREF.  If we wc->level is currently less than our wc->shared_level
6000  * wc->shared_level.  Once we're at or above our wc->shared_level we can switch
6003  * DROP_REFERENCE. If our refs == 1 then we're going to free this tree block.
6013 	int level = wc->level;  in walk_up_tree()
6016 	path->slots[level] = btrfs_header_nritems(path->nodes[level]);  in walk_up_tree()
6017 	while (level < max_level && path->nodes[level]) {  in walk_up_tree()
6018 		wc->level = level;  in walk_up_tree()
6019 		if (path->slots[level] + 1 <  in walk_up_tree()
6020 		    btrfs_header_nritems(path->nodes[level])) {  in walk_up_tree()
6021 			path->slots[level]++;  in walk_up_tree()
6030 			if (path->locks[level]) {  in walk_up_tree()
6031 				btrfs_tree_unlock_rw(path->nodes[level],  in walk_up_tree()
6032 						     path->locks[level]);  in walk_up_tree()
6033 				path->locks[level] = 0;  in walk_up_tree()
6035 			free_extent_buffer(path->nodes[level]);  in walk_up_tree()
6036 			path->nodes[level] = NULL;  in walk_up_tree()
6049  * when a shared tree block is found. this function decreases its
6051  * also make sure backrefs for the shared block and all lower level
6054  * If called with for_reloc set, may exit early with -EAGAIN
6059 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_snapshot()
6062 	struct btrfs_root *tree_root = fs_info->tree_root;  in btrfs_drop_snapshot()
6063 	struct btrfs_root_item *root_item = &root->root_item;  in btrfs_drop_snapshot()
6076 		ret = -ENOMEM;  in btrfs_drop_snapshot()
6083 		ret = -ENOMEM;  in btrfs_drop_snapshot()
6112 	set_bit(BTRFS_ROOT_DELETING, &root->state);  in btrfs_drop_snapshot()
6113 	unfinished_drop = test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state);  in btrfs_drop_snapshot()
6115 	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {  in btrfs_drop_snapshot()
6116 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
6117 		path->nodes[level] = btrfs_lock_root_node(root);  in btrfs_drop_snapshot()
6118 		path->slots[level] = 0;  in btrfs_drop_snapshot()
6119 		path->locks[level] = BTRFS_WRITE_LOCK;  in btrfs_drop_snapshot()
6120 		memset(&wc->update_progress, 0,  in btrfs_drop_snapshot()
6121 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
6123 		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);  in btrfs_drop_snapshot()
6124 		memcpy(&wc->update_progress, &key,  in btrfs_drop_snapshot()
6125 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
6129 		path->lowest_level = level;  in btrfs_drop_snapshot()
6131 		path->lowest_level = 0;  in btrfs_drop_snapshot()
6144 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
6146 			btrfs_tree_lock(path->nodes[level]);  in btrfs_drop_snapshot()
6147 			path->locks[level] = BTRFS_WRITE_LOCK;  in btrfs_drop_snapshot()
6154 						path->nodes[level]->start,  in btrfs_drop_snapshot()
6155 						level, 1, &wc->refs[level],  in btrfs_drop_snapshot()
6156 						&wc->flags[level], NULL);  in btrfs_drop_snapshot()
6160 			BUG_ON(wc->refs[level] == 0);  in btrfs_drop_snapshot()
6165 			btrfs_tree_unlock(path->nodes[level]);  in btrfs_drop_snapshot()
6166 			path->locks[level] = 0;  in btrfs_drop_snapshot()
6167 			WARN_ON(wc->refs[level] != 1);  in btrfs_drop_snapshot()
6168 			level--;  in btrfs_drop_snapshot()
6172 	wc->restarted = test_bit(BTRFS_ROOT_DEAD_TREE, &root->state);  in btrfs_drop_snapshot()
6173 	wc->level = level;  in btrfs_drop_snapshot()
6174 	wc->shared_level = -1;  in btrfs_drop_snapshot()
6175 	wc->stage = DROP_REFERENCE;  in btrfs_drop_snapshot()
6176 	wc->update_ref = update_ref;  in btrfs_drop_snapshot()
6177 	wc->keep_locks = 0;  in btrfs_drop_snapshot()
6178 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_snapshot()
6195 			BUG_ON(wc->stage != DROP_REFERENCE);  in btrfs_drop_snapshot()
6200 		if (wc->stage == DROP_REFERENCE) {  in btrfs_drop_snapshot()
6201 			wc->drop_level = wc->level;  in btrfs_drop_snapshot()
6202 			btrfs_node_key_to_cpu(path->nodes[wc->drop_level],  in btrfs_drop_snapshot()
6203 					      &wc->drop_progress,  in btrfs_drop_snapshot()
6204 					      path->slots[wc->drop_level]);  in btrfs_drop_snapshot()
6206 		btrfs_cpu_key_to_disk(&root_item->drop_progress,  in btrfs_drop_snapshot()
6207 				      &wc->drop_progress);  in btrfs_drop_snapshot()
6208 		btrfs_set_root_drop_level(root_item, wc->drop_level);  in btrfs_drop_snapshot()
6210 		BUG_ON(wc->level == 0);  in btrfs_drop_snapshot()
6214 						&root->root_key,  in btrfs_drop_snapshot()
6222 				btrfs_set_last_root_drop_gen(fs_info, trans->transid);  in btrfs_drop_snapshot()
6228 				ret = -EAGAIN;  in btrfs_drop_snapshot()
6251 	ret = btrfs_del_root(trans, &root->root_key);  in btrfs_drop_snapshot()
6258 		ret = btrfs_find_root(tree_root, &root->root_key, path,  in btrfs_drop_snapshot()
6269 			 * The most common failure here is just -ENOENT.  in btrfs_drop_snapshot()
6283 	if (test_bit(BTRFS_ROOT_IN_RADIX, &root->state))  in btrfs_drop_snapshot()
6290 		btrfs_set_last_root_drop_gen(fs_info, trans->transid);  in btrfs_drop_snapshot()
6301 				      "failed to cleanup qgroup 0/%llu: %d",  in btrfs_drop_snapshot()
6325  * drop subtree rooted at tree block 'node'.
6327  * NOTE: this function will unlock and release tree block 'node'
6335 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_subtree()
6346 		return -ENOMEM;  in btrfs_drop_subtree()
6350 		return -ENOMEM;  in btrfs_drop_subtree()
6354 	refcount_inc(&parent->refs);  in btrfs_drop_subtree()
6355 	path->nodes[parent_level] = parent;  in btrfs_drop_subtree()
6356 	path->slots[parent_level] = btrfs_header_nritems(parent);  in btrfs_drop_subtree()
6360 	path->nodes[level] = node;  in btrfs_drop_subtree()
6361 	path->slots[level] = 0;  in btrfs_drop_subtree()
6362 	path->locks[level] = BTRFS_WRITE_LOCK;  in btrfs_drop_subtree()
6364 	wc->refs[parent_level] = 1;  in btrfs_drop_subtree()
6365 	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;  in btrfs_drop_subtree()
6366 	wc->level = level;  in btrfs_drop_subtree()
6367 	wc->shared_level = -1;  in btrfs_drop_subtree()
6368 	wc->stage = DROP_REFERENCE;  in btrfs_drop_subtree()
6369 	wc->update_ref = 0;  in btrfs_drop_subtree()
6370 	wc->keep_locks = 1;  in btrfs_drop_subtree()
6371 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_subtree()
6400  * It used to be that old block groups would be left around forever.
6427 	if (!bdev_max_discard_sectors(device->bdev))  in btrfs_trim_free_extents()
6431 	if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state))  in btrfs_trim_free_extents()
6435 	if (device->total_bytes <= device->bytes_used)  in btrfs_trim_free_extents()
6441 		struct btrfs_fs_info *fs_info = device->fs_info;  in btrfs_trim_free_extents()
6444 		ret = mutex_lock_interruptible(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
6448 		btrfs_find_first_clear_extent_bit(&device->alloc_state, start,  in btrfs_trim_free_extents()
6453 		if (start > device->total_bytes) {  in btrfs_trim_free_extents()
6456 "ignoring attempt to trim beyond device size: offset %llu length %llu device %s device size %llu",  in btrfs_trim_free_extents()
6457 					  start, end - start + 1,  in btrfs_trim_free_extents()
6459 					  device->total_bytes);  in btrfs_trim_free_extents()
6460 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
6470 		 * end of the device it will set end to -1, in this case it's up  in btrfs_trim_free_extents()
6471 		 * to the caller to trim the value to the size of the device.  in btrfs_trim_free_extents()
6473 		end = min(end, device->total_bytes - 1);  in btrfs_trim_free_extents()
6475 		len = end - start + 1;  in btrfs_trim_free_extents()
6479 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
6484 		ret = btrfs_issue_discard(device->bdev, start, len,  in btrfs_trim_free_extents()
6487 			btrfs_set_extent_bit(&device->alloc_state, start,  in btrfs_trim_free_extents()
6488 					     start + bytes - 1, CHUNK_TRIMMED, NULL);  in btrfs_trim_free_extents()
6489 		mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
6498 			ret = -ERESTARTSYS;  in btrfs_trim_free_extents()
6510  * 1) trimming the free space in each block group
6513  * This will also continue trimming even if a block group or device encounters
6519 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;  in btrfs_trim_fs()
6520 	struct btrfs_block_group *cache = NULL;  in btrfs_trim_fs()  local
6533 	if (range->start == U64_MAX)  in btrfs_trim_fs()
6534 		return -EINVAL;  in btrfs_trim_fs()
6537 	 * Check range overflow if range->len is set.  in btrfs_trim_fs()
6538 	 * The default range->len is U64_MAX.  in btrfs_trim_fs()
6540 	if (range->len != U64_MAX &&  in btrfs_trim_fs()
6541 	    check_add_overflow(range->start, range->len, &range_end))  in btrfs_trim_fs()
6542 		return -EINVAL;  in btrfs_trim_fs()
6544 	cache = btrfs_lookup_first_block_group(fs_info, range->start);  in btrfs_trim_fs()
6545 	for (; cache; cache = btrfs_next_block_group(cache)) {  in btrfs_trim_fs()
6546 		if (cache->start >= range_end) {  in btrfs_trim_fs()
6547 			btrfs_put_block_group(cache);  in btrfs_trim_fs()
6551 		start = max(range->start, cache->start);  in btrfs_trim_fs()
6552 		end = min(range_end, cache->start + cache->length);  in btrfs_trim_fs()
6554 		if (end - start >= range->minlen) {  in btrfs_trim_fs()
6555 			if (!btrfs_block_group_done(cache)) {  in btrfs_trim_fs()
6556 				ret = btrfs_cache_block_group(cache, true);  in btrfs_trim_fs()
6563 			ret = btrfs_trim_block_group(cache,  in btrfs_trim_fs()
6567 						     range->minlen);  in btrfs_trim_fs()
6580 			"failed to trim %llu block group(s), last error %d",  in btrfs_trim_fs()
6583 	mutex_lock(&fs_devices->device_list_mutex);  in btrfs_trim_fs()
6584 	list_for_each_entry(device, &fs_devices->devices, dev_list) {  in btrfs_trim_fs()
6585 		if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))  in btrfs_trim_fs()
6597 	mutex_unlock(&fs_devices->device_list_mutex);  in btrfs_trim_fs()
6601 			"failed to trim %llu device(s), last error %d",  in btrfs_trim_fs()
6603 	range->len = trimmed;  in btrfs_trim_fs()