1 // SPDX-License-Identifier: GPL-2.0
20 #include "tree-log.h"
21 #include "disk-io.h"
22 #include "print-tree.h"
26 #include "free-space-cache.h"
27 #include "free-space-tree.h"
30 #include "ref-verify.h"
31 #include "space-info.h"
32 #include "block-rsv.h"
33 #include "delalloc-space.h"
34 #include "block-group.h"
36 #include "rcu-string.h"
61 	return (cache->flags & bits) == bits;  in block_group_bits()
67 	u64 end = start + num_bytes - 1;  in btrfs_add_excluded_extent()
68 	set_extent_bits(&fs_info->excluded_extents, start, end,  in btrfs_add_excluded_extent()
75 	struct btrfs_fs_info *fs_info = cache->fs_info;  in btrfs_free_excluded_extents()
78 	start = cache->start;  in btrfs_free_excluded_extents()
79 	end = start + cache->length - 1;  in btrfs_free_excluded_extents()
81 	clear_extent_bits(&fs_info->excluded_extents, start, end,  in btrfs_free_excluded_extents()
87 	if (ref->type == BTRFS_REF_METADATA) {  in generic_ref_to_space_flags()
88 		if (ref->tree_ref.root == BTRFS_CHUNK_TREE_OBJECTID)  in generic_ref_to_space_flags()
104 	percpu_counter_add_batch(&space_info->total_bytes_pinned, ref->len,  in add_pinned_bytes()
116 	percpu_counter_add_batch(&space_info->total_bytes_pinned, -ref->len,  in sub_pinned_bytes()
129 		return -ENOMEM;  in btrfs_lookup_data_extent()
134 	ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0);  in btrfs_lookup_data_extent()
168 		offset = fs_info->nodesize;  in btrfs_lookup_extent_info()
174 		return -ENOMEM;  in btrfs_lookup_extent_info()
177 		path->skip_locking = 1;  in btrfs_lookup_extent_info()
178 		path->search_commit_root = 1;  in btrfs_lookup_extent_info()
189 	ret = btrfs_search_slot(trans, fs_info->extent_root, &key, path, 0, 0);  in btrfs_lookup_extent_info()
194 		if (path->slots[0]) {  in btrfs_lookup_extent_info()
195 			path->slots[0]--;  in btrfs_lookup_extent_info()
196 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in btrfs_lookup_extent_info()
197 					      path->slots[0]);  in btrfs_lookup_extent_info()
200 			    key.offset == fs_info->nodesize)  in btrfs_lookup_extent_info()
206 		leaf = path->nodes[0];  in btrfs_lookup_extent_info()
207 		item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in btrfs_lookup_extent_info()
209 			ei = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_lookup_extent_info()
214 			ret = -EINVAL;  in btrfs_lookup_extent_info()
234 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_lookup_extent_info()
235 	spin_lock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
238 		if (!mutex_trylock(&head->mutex)) {  in btrfs_lookup_extent_info()
239 			refcount_inc(&head->refs);  in btrfs_lookup_extent_info()
240 			spin_unlock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
248 			mutex_lock(&head->mutex);  in btrfs_lookup_extent_info()
249 			mutex_unlock(&head->mutex);  in btrfs_lookup_extent_info()
253 		spin_lock(&head->lock);  in btrfs_lookup_extent_info()
254 		if (head->extent_op && head->extent_op->update_flags)  in btrfs_lookup_extent_info()
255 			extent_flags |= head->extent_op->flags_to_set;  in btrfs_lookup_extent_info()
259 		num_refs += head->ref_mod;  in btrfs_lookup_extent_info()
260 		spin_unlock(&head->lock);  in btrfs_lookup_extent_info()
261 		mutex_unlock(&head->mutex);  in btrfs_lookup_extent_info()
263 	spin_unlock(&delayed_refs->lock);  in btrfs_lookup_extent_info()
290  * for pointers in non-shared tree blocks. For a given pointer in a block,
293  * b-tree searching. The full back refs is for pointers in tree blocks not
336  * - multiple snapshots, subvolumes, or different generations in one subvol
337  * - different files inside a single subvolume
338  * - different offsets inside a file (bookend extents in file.c)
342  * - Objectid of the subvolume root
343  * - objectid of the file holding the reference
344  * - original offset in the file
345  * - how many bookend extents
352  * - number of pointers in the tree leaf
369  * - Different subvolumes
401 				ASSERT(eb->fs_info);  in btrfs_get_extent_inline_ref_type()
407 				    IS_ALIGNED(offset, eb->fs_info->sectorsize))  in btrfs_get_extent_inline_ref_type()
414 				ASSERT(eb->fs_info);  in btrfs_get_extent_inline_ref_type()
420 				    IS_ALIGNED(offset, eb->fs_info->sectorsize))  in btrfs_get_extent_inline_ref_type()
430 	btrfs_err(eb->fs_info,  in btrfs_get_extent_inline_ref_type()
432 		  eb->start, (unsigned long)iref, type);  in btrfs_get_extent_inline_ref_type()
479 	struct btrfs_root *root = trans->fs_info->extent_root;  in lookup_extent_data_ref()
486 	int err = -ENOENT;  in lookup_extent_data_ref()
499 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in lookup_extent_data_ref()
511 	leaf = path->nodes[0];  in lookup_extent_data_ref()
514 		if (path->slots[0] >= nritems) {  in lookup_extent_data_ref()
521 			leaf = path->nodes[0];  in lookup_extent_data_ref()
526 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in lookup_extent_data_ref()
531 		ref = btrfs_item_ptr(leaf, path->slots[0],  in lookup_extent_data_ref()
543 		path->slots[0]++;  in lookup_extent_data_ref()
555 	struct btrfs_root *root = trans->fs_info->extent_root;  in insert_extent_data_ref()
575 	if (ret && ret != -EEXIST)  in insert_extent_data_ref()
578 	leaf = path->nodes[0];  in insert_extent_data_ref()
581 		ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
592 		while (ret == -EEXIST) {  in insert_extent_data_ref()
593 			ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
602 			if (ret && ret != -EEXIST)  in insert_extent_data_ref()
605 			leaf = path->nodes[0];  in insert_extent_data_ref()
607 		ref = btrfs_item_ptr(leaf, path->slots[0],  in insert_extent_data_ref()
639 	leaf = path->nodes[0];  in remove_extent_data_ref()
640 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in remove_extent_data_ref()
643 		ref1 = btrfs_item_ptr(leaf, path->slots[0],  in remove_extent_data_ref()
647 		ref2 = btrfs_item_ptr(leaf, path->slots[0],  in remove_extent_data_ref()
651 		btrfs_print_v0_err(trans->fs_info);  in remove_extent_data_ref()
652 		btrfs_abort_transaction(trans, -EINVAL);  in remove_extent_data_ref()
653 		return -EINVAL;  in remove_extent_data_ref()
659 	num_refs -= refs_to_drop;  in remove_extent_data_ref()
662 		ret = btrfs_del_item(trans, trans->fs_info->extent_root, path);  in remove_extent_data_ref()
684 	leaf = path->nodes[0];  in extent_data_ref_count()
685 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in extent_data_ref_count()
696 			ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);  in extent_data_ref_count()
703 		ref1 = btrfs_item_ptr(leaf, path->slots[0],  in extent_data_ref_count()
707 		ref2 = btrfs_item_ptr(leaf, path->slots[0],  in extent_data_ref_count()
721 	struct btrfs_root *root = trans->fs_info->extent_root;  in lookup_tree_block_ref()
734 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in lookup_tree_block_ref()
736 		ret = -ENOENT;  in lookup_tree_block_ref()
757 	ret = btrfs_insert_empty_item(trans, trans->fs_info->extent_root,  in insert_tree_block_ref()
785 		if (!path->nodes[level])  in find_next_key()
787 		if (path->slots[level] + 1 >=  in find_next_key()
788 		    btrfs_header_nritems(path->nodes[level]))  in find_next_key()
791 			btrfs_item_key_to_cpu(path->nodes[level], key,  in find_next_key()
792 					      path->slots[level] + 1);  in find_next_key()
794 			btrfs_node_key_to_cpu(path->nodes[level], key,  in find_next_key()
795 					      path->slots[level] + 1);  in find_next_key()
806  * should be inserted, and -ENOENT is returned.
809  * points to the extent item, and -EAGAIN is returned.
822 	struct btrfs_fs_info *fs_info = trans->fs_info;  in lookup_inline_extent_backref()
823 	struct btrfs_root *root = fs_info->extent_root;  in lookup_inline_extent_backref()
847 		path->keep_locks = 1;  in lookup_inline_extent_backref()
849 		extra_size = -1;  in lookup_inline_extent_backref()
873 		if (path->slots[0]) {  in lookup_inline_extent_backref()
874 			path->slots[0]--;  in lookup_inline_extent_backref()
875 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in lookup_inline_extent_backref()
876 					      path->slots[0]);  in lookup_inline_extent_backref()
892 		err = -ENOENT;  in lookup_inline_extent_backref()
895 		err = -EIO;  in lookup_inline_extent_backref()
899 	leaf = path->nodes[0];  in lookup_inline_extent_backref()
900 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in lookup_inline_extent_backref()
902 		err = -EINVAL;  in lookup_inline_extent_backref()
908 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in lookup_inline_extent_backref()
924 	err = -ENOENT;  in lookup_inline_extent_backref()
933 			err = -EUCLEAN;  in lookup_inline_extent_backref()
946 			dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in lookup_inline_extent_backref()
976 	if (err == -ENOENT && insert) {  in lookup_inline_extent_backref()
979 			err = -EAGAIN;  in lookup_inline_extent_backref()
984 		 * there is no corresponding back ref item.  in lookup_inline_extent_backref()
991 			err = -EAGAIN;  in lookup_inline_extent_backref()
998 		path->keep_locks = 0;  in lookup_inline_extent_backref()
1024 	leaf = path->nodes[0];  in setup_inline_extent_backref()
1025 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in setup_inline_extent_backref()
1026 	item_offset = (unsigned long)iref - (unsigned long)ei;  in setup_inline_extent_backref()
1033 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in setup_inline_extent_backref()
1041 	end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);  in setup_inline_extent_backref()
1042 	if (ptr < end - size)  in setup_inline_extent_backref()
1044 				      end - size - ptr);  in setup_inline_extent_backref()
1050 		dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in setup_inline_extent_backref()
1079 	if (ret != -ENOENT)  in lookup_extent_backref()
1105 	struct extent_buffer *leaf = path->nodes[0];  in update_inline_extent_backref()
1116 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in update_inline_extent_backref()
1132 		dref = (struct btrfs_extent_data_ref *)(&iref->offset);  in update_inline_extent_backref()
1139 		BUG_ON(refs_to_mod != -1);  in update_inline_extent_backref()
1142 	BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);  in update_inline_extent_backref()
1153 		item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in update_inline_extent_backref()
1158 					      end - ptr - size);  in update_inline_extent_backref()
1159 		item_size -= size;  in update_inline_extent_backref()
1185 			btrfs_crit(trans->fs_info,  in insert_inline_extent_backref()
1190 				btrfs_crit(trans->fs_info,  in insert_inline_extent_backref()
1191 			"path->slots[0]=%d path->nodes[0]:", path->slots[0]);  in insert_inline_extent_backref()
1192 				btrfs_print_leaf(path->nodes[0]);  in insert_inline_extent_backref()
1194 			return -EUCLEAN;  in insert_inline_extent_backref()
1198 	} else if (ret == -ENOENT) {  in insert_inline_extent_backref()
1199 		setup_inline_extent_backref(trans->fs_info, path, iref, parent,  in insert_inline_extent_backref()
1216 		update_inline_extent_backref(path, iref, -refs_to_drop, NULL,  in remove_extent_backref()
1223 		ret = btrfs_del_item(trans, trans->fs_info->extent_root, path);  in remove_extent_backref()
1236 		len -= aligned_start - start;  in btrfs_issue_discard()
1253 		u64 size = sb_start - start;  in btrfs_issue_discard()
1265 			start += sb_end - start;  in btrfs_issue_discard()
1270 			bytes_left = end - start;  in btrfs_issue_discard()
1279 			else if (ret != -EOPNOTSUPP)  in btrfs_issue_discard()
1288 		bytes_left = end - start;  in btrfs_issue_discard()
1319 		num_bytes = end - cur;  in btrfs_discard_extent()
1324 		 * Error can be -ENOMEM, -ENOENT (no such chunk mapping) or  in btrfs_discard_extent()
1325 		 * -EOPNOTSUPP. For any such error, @num_bytes is not updated,  in btrfs_discard_extent()
1331 		stripe = bbio->stripes;  in btrfs_discard_extent()
1332 		for (i = 0; i < bbio->num_stripes; i++, stripe++) {  in btrfs_discard_extent()
1336 			if (!stripe->dev->bdev) {  in btrfs_discard_extent()
1340 			req_q = bdev_get_queue(stripe->dev->bdev);  in btrfs_discard_extent()
1344 			ret = btrfs_issue_discard(stripe->dev->bdev,  in btrfs_discard_extent()
1345 						  stripe->physical,  in btrfs_discard_extent()
1346 						  stripe->length,  in btrfs_discard_extent()
1350 			} else if (ret != -EOPNOTSUPP) {  in btrfs_discard_extent()
1352 				 * Logic errors or -ENOMEM, or -EIO, but  in btrfs_discard_extent()
1379 	if (ret == -EOPNOTSUPP)  in btrfs_discard_extent()
1384 /* Can return -ENOMEM */
1388 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_inc_extent_ref()
1392 	ASSERT(generic_ref->type != BTRFS_REF_NOT_SET &&  in btrfs_inc_extent_ref()
1393 	       generic_ref->action);  in btrfs_inc_extent_ref()
1394 	BUG_ON(generic_ref->type == BTRFS_REF_METADATA &&  in btrfs_inc_extent_ref()
1395 	       generic_ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID);  in btrfs_inc_extent_ref()
1397 	if (generic_ref->type == BTRFS_REF_METADATA)  in btrfs_inc_extent_ref()
1413  * __btrfs_inc_extent_ref - insert backreference for a given extent
1432  *		    this can be either one of the well-known metadata trees or
1459 	u64 bytenr = node->bytenr;  in __btrfs_inc_extent_ref()
1460 	u64 num_bytes = node->num_bytes;  in __btrfs_inc_extent_ref()
1466 		return -ENOMEM;  in __btrfs_inc_extent_ref()
1468 	path->leave_spinning = 1;  in __btrfs_inc_extent_ref()
1473 	if ((ret < 0 && ret != -EAGAIN) || !ret)  in __btrfs_inc_extent_ref()
1477 	 * Ok we had -EAGAIN which means we didn't have space to insert and  in __btrfs_inc_extent_ref()
1481 	leaf = path->nodes[0];  in __btrfs_inc_extent_ref()
1482 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in __btrfs_inc_extent_ref()
1483 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in __btrfs_inc_extent_ref()
1492 	path->leave_spinning = 1;  in __btrfs_inc_extent_ref()
1522 	ins.objectid = node->bytenr;  in run_delayed_data_ref()
1523 	ins.offset = node->num_bytes;  in run_delayed_data_ref()
1527 	trace_run_delayed_data_ref(trans->fs_info, node, ref, node->action);  in run_delayed_data_ref()
1529 	if (node->type == BTRFS_SHARED_DATA_REF_KEY)  in run_delayed_data_ref()
1530 		parent = ref->parent;  in run_delayed_data_ref()
1531 	ref_root = ref->root;  in run_delayed_data_ref()
1533 	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {  in run_delayed_data_ref()
1535 			flags |= extent_op->flags_to_set;  in run_delayed_data_ref()
1537 						 flags, ref->objectid,  in run_delayed_data_ref()
1538 						 ref->offset, &ins,  in run_delayed_data_ref()
1539 						 node->ref_mod);  in run_delayed_data_ref()
1540 	} else if (node->action == BTRFS_ADD_DELAYED_REF) {  in run_delayed_data_ref()
1542 					     ref->objectid, ref->offset,  in run_delayed_data_ref()
1543 					     node->ref_mod, extent_op);  in run_delayed_data_ref()
1544 	} else if (node->action == BTRFS_DROP_DELAYED_REF) {  in run_delayed_data_ref()
1546 					  ref_root, ref->objectid,  in run_delayed_data_ref()
1547 					  ref->offset, node->ref_mod,  in run_delayed_data_ref()
1560 	if (extent_op->update_flags) {  in __run_delayed_extent_op()
1561 		flags |= extent_op->flags_to_set;  in __run_delayed_extent_op()
1565 	if (extent_op->update_key) {  in __run_delayed_extent_op()
1569 		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);  in __run_delayed_extent_op()
1577 	struct btrfs_fs_info *fs_info = trans->fs_info;  in run_delayed_extent_op()
1585 	int metadata = !extent_op->is_data;  in run_delayed_extent_op()
1595 		return -ENOMEM;  in run_delayed_extent_op()
1597 	key.objectid = head->bytenr;  in run_delayed_extent_op()
1601 		key.offset = extent_op->level;  in run_delayed_extent_op()
1604 		key.offset = head->num_bytes;  in run_delayed_extent_op()
1608 	path->leave_spinning = 1;  in run_delayed_extent_op()
1609 	ret = btrfs_search_slot(trans, fs_info->extent_root, &key, path, 0, 1);  in run_delayed_extent_op()
1616 			if (path->slots[0] > 0) {  in run_delayed_extent_op()
1617 				path->slots[0]--;  in run_delayed_extent_op()
1618 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in run_delayed_extent_op()
1619 						      path->slots[0]);  in run_delayed_extent_op()
1620 				if (key.objectid == head->bytenr &&  in run_delayed_extent_op()
1622 				    key.offset == head->num_bytes)  in run_delayed_extent_op()
1629 				key.objectid = head->bytenr;  in run_delayed_extent_op()
1630 				key.offset = head->num_bytes;  in run_delayed_extent_op()
1635 			err = -EIO;  in run_delayed_extent_op()
1640 	leaf = path->nodes[0];  in run_delayed_extent_op()
1641 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in run_delayed_extent_op()
1644 		err = -EINVAL;  in run_delayed_extent_op()
1650 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in run_delayed_extent_op()
1670 	trace_run_delayed_tree_ref(trans->fs_info, node, ref, node->action);  in run_delayed_tree_ref()
1672 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)  in run_delayed_tree_ref()
1673 		parent = ref->parent;  in run_delayed_tree_ref()
1674 	ref_root = ref->root;  in run_delayed_tree_ref()
1676 	if (node->ref_mod != 1) {  in run_delayed_tree_ref()
1677 		btrfs_err(trans->fs_info,  in run_delayed_tree_ref()
1679 			  node->bytenr, node->ref_mod, node->action, ref_root,  in run_delayed_tree_ref()
1681 		return -EIO;  in run_delayed_tree_ref()
1683 	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {  in run_delayed_tree_ref()
1684 		BUG_ON(!extent_op || !extent_op->update_flags);  in run_delayed_tree_ref()
1686 	} else if (node->action == BTRFS_ADD_DELAYED_REF) {  in run_delayed_tree_ref()
1688 					     ref->level, 0, 1, extent_op);  in run_delayed_tree_ref()
1689 	} else if (node->action == BTRFS_DROP_DELAYED_REF) {  in run_delayed_tree_ref()
1691 					  ref->level, 0, 1, extent_op);  in run_delayed_tree_ref()
1708 			btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);  in run_one_delayed_ref()
1712 	if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||  in run_one_delayed_ref()
1713 	    node->type == BTRFS_SHARED_BLOCK_REF_KEY)  in run_one_delayed_ref()
1716 	else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||  in run_one_delayed_ref()
1717 		 node->type == BTRFS_SHARED_DATA_REF_KEY)  in run_one_delayed_ref()
1723 		btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);  in run_one_delayed_ref()
1732 	if (RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in select_delayed_ref()
1741 	if (!list_empty(&head->ref_add_list))  in select_delayed_ref()
1742 		return list_first_entry(&head->ref_add_list,  in select_delayed_ref()
1745 	ref = rb_entry(rb_first_cached(&head->ref_tree),  in select_delayed_ref()
1747 	ASSERT(list_empty(&ref->add_list));  in select_delayed_ref()
1754 	spin_lock(&delayed_refs->lock);  in unselect_delayed_ref_head()
1755 	head->processing = 0;  in unselect_delayed_ref_head()
1756 	delayed_refs->num_heads_ready++;  in unselect_delayed_ref_head()
1757 	spin_unlock(&delayed_refs->lock);  in unselect_delayed_ref_head()
1764 	struct btrfs_delayed_extent_op *extent_op = head->extent_op;  in cleanup_extent_op()
1769 	if (head->must_insert_reserved) {  in cleanup_extent_op()
1770 		head->extent_op = NULL;  in cleanup_extent_op()
1786 	head->extent_op = NULL;  in run_and_cleanup_extent_op()
1787 	spin_unlock(&head->lock);  in run_and_cleanup_extent_op()
1799 	if (head->total_ref_mod < 0) {  in btrfs_cleanup_ref_head_accounting()
1803 		if (head->is_data)  in btrfs_cleanup_ref_head_accounting()
1805 		else if (head->is_system)  in btrfs_cleanup_ref_head_accounting()
1811 		percpu_counter_add_batch(&space_info->total_bytes_pinned,  in btrfs_cleanup_ref_head_accounting()
1812 				   -head->num_bytes,  in btrfs_cleanup_ref_head_accounting()
1820 		if (head->is_data) {  in btrfs_cleanup_ref_head_accounting()
1821 			spin_lock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1822 			delayed_refs->pending_csums -= head->num_bytes;  in btrfs_cleanup_ref_head_accounting()
1823 			spin_unlock(&delayed_refs->lock);  in btrfs_cleanup_ref_head_accounting()
1825 				head->num_bytes);  in btrfs_cleanup_ref_head_accounting()
1836 	struct btrfs_fs_info *fs_info = trans->fs_info;  in cleanup_ref_head()
1840 	delayed_refs = &trans->transaction->delayed_refs;  in cleanup_ref_head()
1852 	 * Need to drop our head ref lock and re-acquire the delayed ref lock  in cleanup_ref_head()
1853 	 * and then re-check to make sure nobody got added.  in cleanup_ref_head()
1855 	spin_unlock(&head->lock);  in cleanup_ref_head()
1856 	spin_lock(&delayed_refs->lock);  in cleanup_ref_head()
1857 	spin_lock(&head->lock);  in cleanup_ref_head()
1858 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root) || head->extent_op) {  in cleanup_ref_head()
1859 		spin_unlock(&head->lock);  in cleanup_ref_head()
1860 		spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1864 	spin_unlock(&head->lock);  in cleanup_ref_head()
1865 	spin_unlock(&delayed_refs->lock);  in cleanup_ref_head()
1867 	if (head->must_insert_reserved) {  in cleanup_ref_head()
1868 		btrfs_pin_extent(trans, head->bytenr, head->num_bytes, 1);  in cleanup_ref_head()
1869 		if (head->is_data) {  in cleanup_ref_head()
1870 			ret = btrfs_del_csums(trans, fs_info->csum_root,  in cleanup_ref_head()
1871 					      head->bytenr, head->num_bytes);  in cleanup_ref_head()
1887 		&trans->transaction->delayed_refs;  in btrfs_obtain_ref_head()
1891 	spin_lock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1894 		spin_unlock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1903 	spin_unlock(&delayed_refs->lock);  in btrfs_obtain_ref_head()
1910 	if (ret == -EAGAIN)  in btrfs_obtain_ref_head()
1911 		head = ERR_PTR(-EAGAIN);  in btrfs_obtain_ref_head()
1920 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs_for_head()
1927 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs_for_head()
1929 	lockdep_assert_held(&locked_ref->mutex);  in btrfs_run_delayed_refs_for_head()
1930 	lockdep_assert_held(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1933 		if (ref->seq &&  in btrfs_run_delayed_refs_for_head()
1934 		    btrfs_check_delayed_seq(fs_info, ref->seq)) {  in btrfs_run_delayed_refs_for_head()
1935 			spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1937 			return -EAGAIN;  in btrfs_run_delayed_refs_for_head()
1941 		ref->in_tree = 0;  in btrfs_run_delayed_refs_for_head()
1942 		rb_erase_cached(&ref->ref_node, &locked_ref->ref_tree);  in btrfs_run_delayed_refs_for_head()
1943 		RB_CLEAR_NODE(&ref->ref_node);  in btrfs_run_delayed_refs_for_head()
1944 		if (!list_empty(&ref->add_list))  in btrfs_run_delayed_refs_for_head()
1945 			list_del(&ref->add_list);  in btrfs_run_delayed_refs_for_head()
1950 		switch (ref->action) {  in btrfs_run_delayed_refs_for_head()
1953 			locked_ref->ref_mod -= ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1956 			locked_ref->ref_mod += ref->ref_mod;  in btrfs_run_delayed_refs_for_head()
1961 		atomic_dec(&delayed_refs->num_entries);  in btrfs_run_delayed_refs_for_head()
1967 		must_insert_reserved = locked_ref->must_insert_reserved;  in btrfs_run_delayed_refs_for_head()
1968 		locked_ref->must_insert_reserved = 0;  in btrfs_run_delayed_refs_for_head()
1970 		extent_op = locked_ref->extent_op;  in btrfs_run_delayed_refs_for_head()
1971 		locked_ref->extent_op = NULL;  in btrfs_run_delayed_refs_for_head()
1972 		spin_unlock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1989 		spin_lock(&locked_ref->lock);  in btrfs_run_delayed_refs_for_head()
1998  * Returns -ENOMEM or -EIO on failure and will abort the transaction.
2003 	struct btrfs_fs_info *fs_info = trans->fs_info;  in __btrfs_run_delayed_refs()
2011 	delayed_refs = &trans->transaction->delayed_refs;  in __btrfs_run_delayed_refs()
2016 				if (PTR_ERR(locked_ref) == -EAGAIN) {  in __btrfs_run_delayed_refs()
2028 		 * finish.  If we merged anything we need to re-loop so we can  in __btrfs_run_delayed_refs()
2036 		spin_lock(&locked_ref->lock);  in __btrfs_run_delayed_refs()
2041 		if (ret < 0 && ret != -EAGAIN) {  in __btrfs_run_delayed_refs()
2064 		 * returned -EAGAIN, meaning we need to select another head  in __btrfs_run_delayed_refs()
2069 	} while ((nr != -1 && count < nr) || locked_ref);  in __btrfs_run_delayed_refs()
2074 	 * accounting, no actual extent tree updates.  in __btrfs_run_delayed_refs()
2084 		spin_lock(&delayed_refs->lock);  in __btrfs_run_delayed_refs()
2085 		avg = fs_info->avg_delayed_ref_runtime * 3 + runtime;  in __btrfs_run_delayed_refs()
2086 		fs_info->avg_delayed_ref_runtime = avg >> 2;	/* div by 4 */  in __btrfs_run_delayed_refs()
2087 		spin_unlock(&delayed_refs->lock);  in __btrfs_run_delayed_refs()
2100 	struct rb_node *n = root->rb_node;  in find_middle()
2109 		first = entry->bytenr;  in find_middle()
2114 		last = entry->bytenr;  in find_middle()
2116 	n = root->rb_node;  in find_middle()
2120 		WARN_ON(!entry->in_tree);  in find_middle()
2122 		middle = entry->bytenr;  in find_middle()
2125 			n = n->rb_left;  in find_middle()
2127 			n = n->rb_right;  in find_middle()
2129 		alt = 1 - alt;  in find_middle()
2147 			(u64)btrfs_super_csum_size(fs_info->super_copy));  in btrfs_csum_bytes_to_leaves()
2148 	num_csums = div64_u64(csum_bytes, fs_info->sectorsize);  in btrfs_csum_bytes_to_leaves()
2149 	num_csums += num_csums_per_leaf - 1;  in btrfs_csum_bytes_to_leaves()
2167 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_run_delayed_refs()
2172 	int run_all = count == (unsigned long)-1;  in btrfs_run_delayed_refs()
2178 	if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags))  in btrfs_run_delayed_refs()
2181 	delayed_refs = &trans->transaction->delayed_refs;  in btrfs_run_delayed_refs()
2183 		count = atomic_read(&delayed_refs->num_entries) * 2;  in btrfs_run_delayed_refs()
2187 	delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);  in btrfs_run_delayed_refs()
2198 		spin_lock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2199 		node = rb_first_cached(&delayed_refs->href_root);  in btrfs_run_delayed_refs()
2201 			spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2206 		refcount_inc(&head->refs);  in btrfs_run_delayed_refs()
2207 		spin_unlock(&delayed_refs->lock);  in btrfs_run_delayed_refs()
2210 		mutex_lock(&head->mutex);  in btrfs_run_delayed_refs()
2211 		mutex_unlock(&head->mutex);  in btrfs_run_delayed_refs()
2230 		return -ENOMEM;  in btrfs_set_disk_extent_flags()
2232 	extent_op->flags_to_set = flags;  in btrfs_set_disk_extent_flags()
2233 	extent_op->update_flags = true;  in btrfs_set_disk_extent_flags()
2234 	extent_op->update_key = false;  in btrfs_set_disk_extent_flags()
2235 	extent_op->is_data = is_data ? true : false;  in btrfs_set_disk_extent_flags()
2236 	extent_op->level = level;  in btrfs_set_disk_extent_flags()
2238 	ret = btrfs_add_delayed_extent_op(trans, eb->start, eb->len, extent_op);  in btrfs_set_disk_extent_flags()
2256 	spin_lock(&root->fs_info->trans_lock);  in check_delayed_ref()
2257 	cur_trans = root->fs_info->running_transaction;  in check_delayed_ref()
2259 		refcount_inc(&cur_trans->use_count);  in check_delayed_ref()
2260 	spin_unlock(&root->fs_info->trans_lock);  in check_delayed_ref()
2264 	delayed_refs = &cur_trans->delayed_refs;  in check_delayed_ref()
2265 	spin_lock(&delayed_refs->lock);  in check_delayed_ref()
2268 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2273 	if (!mutex_trylock(&head->mutex)) {  in check_delayed_ref()
2274 		refcount_inc(&head->refs);  in check_delayed_ref()
2275 		spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2283 		mutex_lock(&head->mutex);  in check_delayed_ref()
2284 		mutex_unlock(&head->mutex);  in check_delayed_ref()
2287 		return -EAGAIN;  in check_delayed_ref()
2289 	spin_unlock(&delayed_refs->lock);  in check_delayed_ref()
2291 	spin_lock(&head->lock);  in check_delayed_ref()
2296 	for (node = rb_first_cached(&head->ref_tree); node;  in check_delayed_ref()
2300 		if (ref->type != BTRFS_EXTENT_DATA_REF_KEY) {  in check_delayed_ref()
2311 		if (data_ref->root != root->root_key.objectid ||  in check_delayed_ref()
2312 		    data_ref->objectid != objectid ||  in check_delayed_ref()
2313 		    data_ref->offset != offset) {  in check_delayed_ref()
2318 	spin_unlock(&head->lock);  in check_delayed_ref()
2319 	mutex_unlock(&head->mutex);  in check_delayed_ref()
2329 	struct btrfs_fs_info *fs_info = root->fs_info;  in check_committed_ref()
2330 	struct btrfs_root *extent_root = fs_info->extent_root;  in check_committed_ref()
2341 	key.offset = (u64)-1;  in check_committed_ref()
2349 	ret = -ENOENT;  in check_committed_ref()
2350 	if (path->slots[0] == 0)  in check_committed_ref()
2353 	path->slots[0]--;  in check_committed_ref()
2354 	leaf = path->nodes[0];  in check_committed_ref()
2355 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in check_committed_ref()
2361 	item_size = btrfs_item_size_nr(leaf, path->slots[0]);  in check_committed_ref()
2362 	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);  in check_committed_ref()
2375 	     btrfs_root_last_snapshot(&root->root_item)))  in check_committed_ref()
2385 	ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in check_committed_ref()
2389 	    root->root_key.objectid ||  in check_committed_ref()
2407 		return -ENOMEM;  in btrfs_cross_ref_exist()
2412 		if (ret && ret != -ENOENT)  in btrfs_cross_ref_exist()
2416 	} while (ret == -EAGAIN);  in btrfs_cross_ref_exist()
2420 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in btrfs_cross_ref_exist()
2430 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_mod_ref()
2452 	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && level == 0)  in __btrfs_mod_ref()
2456 		parent = buf->start;  in __btrfs_mod_ref()
2479 			key.offset -= btrfs_file_extent_offset(buf, fi);  in __btrfs_mod_ref()
2482 			generic_ref.real_root = root->root_key.objectid;  in __btrfs_mod_ref()
2494 			num_bytes = fs_info->nodesize;  in __btrfs_mod_ref()
2497 			generic_ref.real_root = root->root_key.objectid;  in __btrfs_mod_ref()
2498 			btrfs_init_tree_ref(&generic_ref, level - 1, ref_root);  in __btrfs_mod_ref()
2531 	if (!block_group || block_group->ro)  in btrfs_extent_readonly()
2540 	struct btrfs_fs_info *fs_info = root->fs_info;  in get_alloc_profile_by_root()
2546 	else if (root == fs_info->chunk_root)  in get_alloc_profile_by_root()
2560 	spin_lock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2561 	bytenr = fs_info->first_logical_byte;  in first_logical_byte()
2562 	spin_unlock(&fs_info->block_group_cache_lock);  in first_logical_byte()
2564 	if (bytenr < (u64)-1)  in first_logical_byte()
2571 	bytenr = cache->start;  in first_logical_byte()
2581 	struct btrfs_fs_info *fs_info = cache->fs_info;  in pin_down_extent()
2583 	spin_lock(&cache->space_info->lock);  in pin_down_extent()
2584 	spin_lock(&cache->lock);  in pin_down_extent()
2585 	cache->pinned += num_bytes;  in pin_down_extent()
2586 	btrfs_space_info_update_bytes_pinned(fs_info, cache->space_info,  in pin_down_extent()
2589 		cache->reserved -= num_bytes;  in pin_down_extent()
2590 		cache->space_info->bytes_reserved -= num_bytes;  in pin_down_extent()
2592 	spin_unlock(&cache->lock);  in pin_down_extent()
2593 	spin_unlock(&cache->space_info->lock);  in pin_down_extent()
2595 	percpu_counter_add_batch(&cache->space_info->total_bytes_pinned,  in pin_down_extent()
2597 	set_extent_dirty(&trans->transaction->pinned_extents, bytenr,  in pin_down_extent()
2598 			 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);  in pin_down_extent()
2607 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent()
2625 	btrfs_add_excluded_extent(trans->fs_info, bytenr, num_bytes);  in btrfs_pin_extent_for_log_replay()
2627 	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);  in btrfs_pin_extent_for_log_replay()
2629 		return -EINVAL;  in btrfs_pin_extent_for_log_replay()
2656 		return -EINVAL;  in __exclude_logged_extent()
2666 		mutex_lock(&caching_ctl->mutex);  in __exclude_logged_extent()
2668 		if (start >= caching_ctl->progress) {  in __exclude_logged_extent()
2671 		} else if (start + num_bytes <= caching_ctl->progress) {  in __exclude_logged_extent()
2675 			num_bytes = caching_ctl->progress - start;  in __exclude_logged_extent()
2681 			num_bytes = (start + num_bytes) -  in __exclude_logged_extent()
2682 				caching_ctl->progress;  in __exclude_logged_extent()
2683 			start = caching_ctl->progress;  in __exclude_logged_extent()
2688 		mutex_unlock(&caching_ctl->mutex);  in __exclude_logged_extent()
2697 	struct btrfs_fs_info *fs_info = eb->fs_info;  in btrfs_exclude_logged_extents()
2730 	atomic_inc(&bg->reservations);  in btrfs_inc_block_group_reservations()
2739 	down_write(&fs_info->commit_root_sem);  in btrfs_prepare_extent_commit()
2742 				 &fs_info->caching_block_groups, list) {  in btrfs_prepare_extent_commit()
2743 		cache = caching_ctl->block_group;  in btrfs_prepare_extent_commit()
2745 			cache->last_byte_to_unpin = (u64)-1;  in btrfs_prepare_extent_commit()
2746 			list_del_init(&caching_ctl->list);  in btrfs_prepare_extent_commit()
2749 			cache->last_byte_to_unpin = caching_ctl->progress;  in btrfs_prepare_extent_commit()
2753 	up_write(&fs_info->commit_root_sem);  in btrfs_prepare_extent_commit()
2772 	if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {  in fetch_cluster_info()
2773 		ret = &fs_info->meta_alloc_cluster;  in fetch_cluster_info()
2778 	} else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) &&  in fetch_cluster_info()
2781 		ret = &fs_info->data_alloc_cluster;  in fetch_cluster_info()
2793 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in unpin_extent_range()
2803 		    start >= cache->start + cache->length) {  in unpin_extent_range()
2811 						     cache->space_info,  in unpin_extent_range()
2816 		len = cache->start + cache->length - start;  in unpin_extent_range()
2817 		len = min(len, end + 1 - start);  in unpin_extent_range()
2819 		if (start < cache->last_byte_to_unpin) {  in unpin_extent_range()
2820 			len = min(len, cache->last_byte_to_unpin - start);  in unpin_extent_range()
2827 		space_info = cache->space_info;  in unpin_extent_range()
2835 		if (cluster && cluster->fragmented &&  in unpin_extent_range()
2837 			spin_lock(&cluster->lock);  in unpin_extent_range()
2838 			cluster->fragmented = 0;  in unpin_extent_range()
2839 			spin_unlock(&cluster->lock);  in unpin_extent_range()
2842 		spin_lock(&space_info->lock);  in unpin_extent_range()
2843 		spin_lock(&cache->lock);  in unpin_extent_range()
2844 		cache->pinned -= len;  in unpin_extent_range()
2845 		btrfs_space_info_update_bytes_pinned(fs_info, space_info, -len);  in unpin_extent_range()
2846 		space_info->max_extent_size = 0;  in unpin_extent_range()
2847 		percpu_counter_add_batch(&space_info->total_bytes_pinned,  in unpin_extent_range()
2848 			    -len, BTRFS_TOTAL_BYTES_PINNED_BATCH);  in unpin_extent_range()
2849 		if (cache->ro) {  in unpin_extent_range()
2850 			space_info->bytes_readonly += len;  in unpin_extent_range()
2853 		spin_unlock(&cache->lock);  in unpin_extent_range()
2855 		    global_rsv->space_info == space_info) {  in unpin_extent_range()
2858 			spin_lock(&global_rsv->lock);  in unpin_extent_range()
2859 			if (!global_rsv->full) {  in unpin_extent_range()
2860 				to_add = min(len, global_rsv->size -  in unpin_extent_range()
2861 					     global_rsv->reserved);  in unpin_extent_range()
2862 				global_rsv->reserved += to_add;  in unpin_extent_range()
2865 				if (global_rsv->reserved >= global_rsv->size)  in unpin_extent_range()
2866 					global_rsv->full = 1;  in unpin_extent_range()
2867 				len -= to_add;  in unpin_extent_range()
2869 			spin_unlock(&global_rsv->lock);  in unpin_extent_range()
2874 		spin_unlock(&space_info->lock);  in unpin_extent_range()
2884 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_finish_extent_commit()
2892 	unpin = &trans->transaction->pinned_extents;  in btrfs_finish_extent_commit()
2897 		mutex_lock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2901 			mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2904 		if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))  in btrfs_finish_extent_commit()
2905 			clear_extent_bits(&fs_info->excluded_extents, start,  in btrfs_finish_extent_commit()
2910 						   end + 1 - start, NULL);  in btrfs_finish_extent_commit()
2914 		mutex_unlock(&fs_info->unused_bg_unpin_mutex);  in btrfs_finish_extent_commit()
2920 		btrfs_discard_calc_delay(&fs_info->discard_ctl);  in btrfs_finish_extent_commit()
2921 		btrfs_discard_schedule_work(&fs_info->discard_ctl, true);  in btrfs_finish_extent_commit()
2929 	deleted_bgs = &trans->transaction->deleted_bgs;  in btrfs_finish_extent_commit()
2933 		ret = -EROFS;  in btrfs_finish_extent_commit()
2936 						   block_group->start,  in btrfs_finish_extent_commit()
2937 						   block_group->length,  in btrfs_finish_extent_commit()
2940 		list_del_init(&block_group->bg_list);  in btrfs_finish_extent_commit()
2975  *    node->bytenr = 13631488
2976  *    node->num_bytes = 1048576
3000  *    node->bytenr = 13631488
3001  *    node->num_bytes = 1048576
3020 	struct btrfs_fs_info *info = trans->fs_info;  in __btrfs_free_extent()
3023 	struct btrfs_root *extent_root = info->extent_root;  in __btrfs_free_extent()
3034 	u64 bytenr = node->bytenr;  in __btrfs_free_extent()
3035 	u64 num_bytes = node->num_bytes;  in __btrfs_free_extent()
3041 		return -ENOMEM;  in __btrfs_free_extent()
3043 	path->leave_spinning = 1;  in __btrfs_free_extent()
3050 			   node->bytenr, refs_to_drop);  in __btrfs_free_extent()
3051 		ret = -EINVAL;  in __btrfs_free_extent()
3070 		extent_slot = path->slots[0];  in __btrfs_free_extent()
3072 			btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3088 			if (path->slots[0] - extent_slot > 5)  in __btrfs_free_extent()
3090 			extent_slot--;  in __btrfs_free_extent()
3096 "invalid iref, no EXTENT/METADATA_ITEM found but has inline extent ref");  in __btrfs_free_extent()
3097 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3109 			path->leave_spinning = 1;  in __btrfs_free_extent()
3122 						&key, path, -1, 1);  in __btrfs_free_extent()
3123 			if (ret > 0 && skinny_metadata && path->slots[0]) {  in __btrfs_free_extent()
3128 				path->slots[0]--;  in __btrfs_free_extent()
3129 				btrfs_item_key_to_cpu(path->nodes[0], &key,  in __btrfs_free_extent()
3130 						      path->slots[0]);  in __btrfs_free_extent()
3144 							&key, path, -1, 1);  in __btrfs_free_extent()
3152 					btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3158 			extent_slot = path->slots[0];  in __btrfs_free_extent()
3160 	} else if (WARN_ON(ret == -ENOENT)) {  in __btrfs_free_extent()
3161 		btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3173 	leaf = path->nodes[0];  in __btrfs_free_extent()
3176 		ret = -EINVAL;  in __btrfs_free_extent()
3192 			btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3204 		btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3207 	refs -= refs_to_drop;  in __btrfs_free_extent()
3219 "invalid iref, got inlined extent ref but no EXTENT/METADATA_ITEM found");  in __btrfs_free_extent()
3220 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3245 				btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3249 				if (path->slots[0] != extent_slot) {  in __btrfs_free_extent()
3254 					btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3259 				 * No inline ref, we must be at SHARED_* item,  in __btrfs_free_extent()
3264 				if (path->slots[0] != extent_slot + 1) {  in __btrfs_free_extent()
3267 					btrfs_abort_transaction(trans, -EUCLEAN);  in __btrfs_free_extent()
3270 				path->slots[0] = extent_slot;  in __btrfs_free_extent()
3276 		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],  in __btrfs_free_extent()
3285 			ret = btrfs_del_csums(trans, info->csum_root, bytenr,  in __btrfs_free_extent()
3316 		btrfs_crit(info, "path->slots[0]=%d extent_slot=%d",  in __btrfs_free_extent()
3317 			   path->slots[0], extent_slot);  in __btrfs_free_extent()
3318 		btrfs_print_leaf(path->nodes[0]);  in __btrfs_free_extent()
3322 	return -EUCLEAN;  in __btrfs_free_extent()
3328  * a given extent, and if there are no other delayed refs to be processed, it
3338 	delayed_refs = &trans->transaction->delayed_refs;  in check_ref_cleanup()
3339 	spin_lock(&delayed_refs->lock);  in check_ref_cleanup()
3344 	spin_lock(&head->lock);  in check_ref_cleanup()
3345 	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root))  in check_ref_cleanup()
3355 	if (!mutex_trylock(&head->mutex))  in check_ref_cleanup()
3359 	head->processing = 0;  in check_ref_cleanup()
3361 	spin_unlock(&head->lock);  in check_ref_cleanup()
3362 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3364 	BUG_ON(head->extent_op);  in check_ref_cleanup()
3365 	if (head->must_insert_reserved)  in check_ref_cleanup()
3368 	btrfs_cleanup_ref_head_accounting(trans->fs_info, delayed_refs, head);  in check_ref_cleanup()
3369 	mutex_unlock(&head->mutex);  in check_ref_cleanup()
3373 	spin_unlock(&head->lock);  in check_ref_cleanup()
3376 	spin_unlock(&delayed_refs->lock);  in check_ref_cleanup()
3385 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_free_tree_block()
3391 			       buf->start, buf->len, parent);  in btrfs_free_tree_block()
3393 			    root->root_key.objectid);  in btrfs_free_tree_block()
3395 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_tree_block()
3401 		BUG_ON(ret); /* -ENOMEM */  in btrfs_free_tree_block()
3405 	if (last_ref && btrfs_header_generation(buf) == trans->transid) {  in btrfs_free_tree_block()
3408 		if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_free_tree_block()
3409 			ret = check_ref_cleanup(trans, buf->start);  in btrfs_free_tree_block()
3415 		cache = btrfs_lookup_block_group(fs_info, buf->start);  in btrfs_free_tree_block()
3418 			pin_down_extent(trans, cache, buf->start, buf->len, 1);  in btrfs_free_tree_block()
3423 		WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));  in btrfs_free_tree_block()
3425 		btrfs_add_free_space(cache, buf->start, buf->len);  in btrfs_free_tree_block()
3426 		btrfs_free_reserved_bytes(cache, buf->len, 0);  in btrfs_free_tree_block()
3428 		trace_btrfs_reserved_extent_free(fs_info, buf->start, buf->len);  in btrfs_free_tree_block()
3439 		clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);  in btrfs_free_tree_block()
3443 /* Can return -ENOMEM */
3446 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_free_extent()
3457 	if ((ref->type == BTRFS_REF_METADATA &&  in btrfs_free_extent()
3458 	     ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID) ||  in btrfs_free_extent()
3459 	    (ref->type == BTRFS_REF_DATA &&  in btrfs_free_extent()
3460 	     ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)) {  in btrfs_free_extent()
3462 		btrfs_pin_extent(trans, ref->bytenr, ref->len, 1);  in btrfs_free_extent()
3465 	} else if (ref->type == BTRFS_REF_METADATA) {  in btrfs_free_extent()
3473 	if (!((ref->type == BTRFS_REF_METADATA &&  in btrfs_free_extent()
3474 	       ref->tree_ref.root == BTRFS_TREE_LOG_OBJECTID) ||  in btrfs_free_extent()
3475 	      (ref->type == BTRFS_REF_DATA &&  in btrfs_free_extent()
3476 	       ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)))  in btrfs_free_extent()
3497 		down_read(&cache->data_rwsem);  in btrfs_lock_block_group()
3505 		down_read(&cache->data_rwsem);  in btrfs_grab_block_group()
3512 	__acquires(&cluster->refill_lock)  in btrfs_lock_cluster()
3516 	spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3518 		used_bg = cluster->block_group;  in btrfs_lock_cluster()
3530 		if (down_read_trylock(&used_bg->data_rwsem))  in btrfs_lock_cluster()
3533 		spin_unlock(&cluster->refill_lock);  in btrfs_lock_cluster()
3535 		/* We should only have one-level nested. */  in btrfs_lock_cluster()
3536 		down_read_nested(&used_bg->data_rwsem, SINGLE_DEPTH_NESTING);  in btrfs_lock_cluster()
3538 		spin_lock(&cluster->refill_lock);  in btrfs_lock_cluster()
3539 		if (used_bg == cluster->block_group)  in btrfs_lock_cluster()
3542 		up_read(&used_bg->data_rwsem);  in btrfs_lock_cluster()
3552 		up_read(&cache->data_rwsem);  in btrfs_release_block_group()
3591 	 * Whether we're refilling a cluster, if true we need to re-search
3597 	 * Whether we're updating free space cache, if true we need to re-search
3625  * Return -ENOENT to inform caller that we need fallback to unclustered mode.
3626  * Return -EAGAIN to inform caller that we need to re-search this block group
3628  * Return 0 means we have found a location and set ffe_ctl->found_offset.
3635 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_clustered()
3640 	cluster_bg = btrfs_lock_cluster(bg, last_ptr, ffe_ctl->delalloc);  in find_free_extent_clustered()
3643 	if (cluster_bg != bg && (cluster_bg->ro ||  in find_free_extent_clustered()
3644 	    !block_group_bits(cluster_bg, ffe_ctl->flags)))  in find_free_extent_clustered()
3648 			ffe_ctl->num_bytes, cluster_bg->start,  in find_free_extent_clustered()
3649 			&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3652 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3654 				ffe_ctl->search_start, ffe_ctl->num_bytes);  in find_free_extent_clustered()
3656 		ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3659 	WARN_ON(last_ptr->block_group != cluster_bg);  in find_free_extent_clustered()
3673 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE && cluster_bg != bg) {  in find_free_extent_clustered()
3674 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3675 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3676 		return -ENOENT;  in find_free_extent_clustered()
3683 		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);  in find_free_extent_clustered()
3686 	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE) {  in find_free_extent_clustered()
3687 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3688 		return -ENOENT;  in find_free_extent_clustered()
3692 			ffe_ctl->empty_cluster + ffe_ctl->empty_size,  in find_free_extent_clustered()
3693 			bg->full_stripe_len);  in find_free_extent_clustered()
3694 	ret = btrfs_find_space_cluster(bg, last_ptr, ffe_ctl->search_start,  in find_free_extent_clustered()
3695 			ffe_ctl->num_bytes, aligned_cluster);  in find_free_extent_clustered()
3699 				ffe_ctl->num_bytes, ffe_ctl->search_start,  in find_free_extent_clustered()
3700 				&ffe_ctl->max_extent_size);  in find_free_extent_clustered()
3703 			spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3705 					ffe_ctl->search_start,  in find_free_extent_clustered()
3706 					ffe_ctl->num_bytes);  in find_free_extent_clustered()
3707 			ffe_ctl->found_offset = offset;  in find_free_extent_clustered()
3710 	} else if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&  in find_free_extent_clustered()
3711 		   !ffe_ctl->retry_clustered) {  in find_free_extent_clustered()
3712 		spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3714 		ffe_ctl->retry_clustered = true;  in find_free_extent_clustered()
3715 		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +  in find_free_extent_clustered()
3716 				ffe_ctl->empty_cluster + ffe_ctl->empty_size);  in find_free_extent_clustered()
3717 		return -EAGAIN;  in find_free_extent_clustered()
3725 	spin_unlock(&last_ptr->refill_lock);  in find_free_extent_clustered()
3731  * Return 0 when we found an free extent and set ffe_ctrl->found_offset
3732  * Return -EAGAIN to inform caller that we need to re-search this block group
3737 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in find_free_extent_unclustered()
3746 		spin_lock(&last_ptr->lock);  in find_free_extent_unclustered()
3747 		last_ptr->fragmented = 1;  in find_free_extent_unclustered()
3748 		spin_unlock(&last_ptr->lock);  in find_free_extent_unclustered()
3750 	if (ffe_ctl->cached) {  in find_free_extent_unclustered()
3753 		free_space_ctl = bg->free_space_ctl;  in find_free_extent_unclustered()
3754 		spin_lock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3755 		if (free_space_ctl->free_space <  in find_free_extent_unclustered()
3756 		    ffe_ctl->num_bytes + ffe_ctl->empty_cluster +  in find_free_extent_unclustered()
3757 		    ffe_ctl->empty_size) {  in find_free_extent_unclustered()
3758 			ffe_ctl->total_free_space = max_t(u64,  in find_free_extent_unclustered()
3759 					ffe_ctl->total_free_space,  in find_free_extent_unclustered()
3760 					free_space_ctl->free_space);  in find_free_extent_unclustered()
3761 			spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3764 		spin_unlock(&free_space_ctl->tree_lock);  in find_free_extent_unclustered()
3767 	offset = btrfs_find_space_for_alloc(bg, ffe_ctl->search_start,  in find_free_extent_unclustered()
3768 			ffe_ctl->num_bytes, ffe_ctl->empty_size,  in find_free_extent_unclustered()
3769 			&ffe_ctl->max_extent_size);  in find_free_extent_unclustered()
3780 	if (!offset && !ffe_ctl->retry_unclustered && !ffe_ctl->cached &&  in find_free_extent_unclustered()
3781 	    ffe_ctl->loop > LOOP_CACHING_NOWAIT) {  in find_free_extent_unclustered()
3782 		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +  in find_free_extent_unclustered()
3783 						      ffe_ctl->empty_size);  in find_free_extent_unclustered()
3784 		ffe_ctl->retry_unclustered = true;  in find_free_extent_unclustered()
3785 		return -EAGAIN;  in find_free_extent_unclustered()
3789 	ffe_ctl->found_offset = offset;  in find_free_extent_unclustered()
3800 	if (ffe_ctl->last_ptr && ffe_ctl->use_cluster) {  in do_allocation_clustered()
3802 		if (ret >= 0 || ret == -EAGAIN)  in do_allocation_clustered()
3804 		/* ret == -ENOENT case falls through */  in do_allocation_clustered()
3814 	switch (ffe_ctl->policy) {  in do_allocation()
3826 	switch (ffe_ctl->policy) {  in release_block_group()
3828 		ffe_ctl->retry_clustered = false;  in release_block_group()
3829 		ffe_ctl->retry_unclustered = false;  in release_block_group()
3835 	BUG_ON(btrfs_bg_flags_to_raid_index(block_group->flags) !=  in release_block_group()
3836 	       ffe_ctl->index);  in release_block_group()
3843 	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in found_extent_clustered()
3845 	if (!ffe_ctl->use_cluster && last_ptr) {  in found_extent_clustered()
3846 		spin_lock(&last_ptr->lock);  in found_extent_clustered()
3847 		last_ptr->window_start = ins->objectid;  in found_extent_clustered()
3848 		spin_unlock(&last_ptr->lock);  in found_extent_clustered()
3855 	switch (ffe_ctl->policy) {  in found_extent()
3866 	switch (ffe_ctl->policy) {  in chunk_allocation_failed()
3872 		ffe_ctl->loop = LOOP_NO_EMPTY_SIZE;  in chunk_allocation_failed()
3880  * Return >0 means caller needs to re-search for free extent
3889 	struct btrfs_root *root = fs_info->extent_root;  in find_free_extent_update_loop()
3892 	if ((ffe_ctl->loop == LOOP_CACHING_NOWAIT) &&  in find_free_extent_update_loop()
3893 	    ffe_ctl->have_caching_bg && !ffe_ctl->orig_have_caching_bg)  in find_free_extent_update_loop()
3894 		ffe_ctl->orig_have_caching_bg = true;  in find_free_extent_update_loop()
3896 	if (!ins->objectid && ffe_ctl->loop >= LOOP_CACHING_WAIT &&  in find_free_extent_update_loop()
3897 	    ffe_ctl->have_caching_bg)  in find_free_extent_update_loop()
3900 	if (!ins->objectid && ++(ffe_ctl->index) < BTRFS_NR_RAID_TYPES)  in find_free_extent_update_loop()
3903 	if (ins->objectid) {  in find_free_extent_update_loop()
3916 	if (ffe_ctl->loop < LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
3917 		ffe_ctl->index = 0;  in find_free_extent_update_loop()
3918 		if (ffe_ctl->loop == LOOP_CACHING_NOWAIT) {  in find_free_extent_update_loop()
3924 			if (ffe_ctl->orig_have_caching_bg || !full_search)  in find_free_extent_update_loop()
3925 				ffe_ctl->loop = LOOP_CACHING_WAIT;  in find_free_extent_update_loop()
3927 				ffe_ctl->loop = LOOP_ALLOC_CHUNK;  in find_free_extent_update_loop()
3929 			ffe_ctl->loop++;  in find_free_extent_update_loop()
3932 		if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {  in find_free_extent_update_loop()
3936 			trans = current->journal_info;  in find_free_extent_update_loop()
3947 			ret = btrfs_chunk_alloc(trans, ffe_ctl->flags,  in find_free_extent_update_loop()
3951 			if (ret == -ENOSPC)  in find_free_extent_update_loop()
3963 		if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {  in find_free_extent_update_loop()
3964 			if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)  in find_free_extent_update_loop()
3965 				return -ENOSPC;  in find_free_extent_update_loop()
3968 			 * Don't loop again if we already have no empty_size and  in find_free_extent_update_loop()
3969 			 * no empty_cluster.  in find_free_extent_update_loop()
3971 			if (ffe_ctl->empty_size == 0 &&  in find_free_extent_update_loop()
3972 			    ffe_ctl->empty_cluster == 0)  in find_free_extent_update_loop()
3973 				return -ENOSPC;  in find_free_extent_update_loop()
3974 			ffe_ctl->empty_size = 0;  in find_free_extent_update_loop()
3975 			ffe_ctl->empty_cluster = 0;  in find_free_extent_update_loop()
3979 	return -ENOSPC;  in find_free_extent_update_loop()
3997 	if (space_info->max_extent_size) {  in prepare_allocation_clustered()
3998 		spin_lock(&space_info->lock);  in prepare_allocation_clustered()
3999 		if (space_info->max_extent_size &&  in prepare_allocation_clustered()
4000 		    ffe_ctl->num_bytes > space_info->max_extent_size) {  in prepare_allocation_clustered()
4001 			ins->offset = space_info->max_extent_size;  in prepare_allocation_clustered()
4002 			spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
4003 			return -ENOSPC;  in prepare_allocation_clustered()
4004 		} else if (space_info->max_extent_size) {  in prepare_allocation_clustered()
4005 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
4007 		spin_unlock(&space_info->lock);  in prepare_allocation_clustered()
4010 	ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,  in prepare_allocation_clustered()
4011 					       &ffe_ctl->empty_cluster);  in prepare_allocation_clustered()
4012 	if (ffe_ctl->last_ptr) {  in prepare_allocation_clustered()
4013 		struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;  in prepare_allocation_clustered()
4015 		spin_lock(&last_ptr->lock);  in prepare_allocation_clustered()
4016 		if (last_ptr->block_group)  in prepare_allocation_clustered()
4017 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
4018 		if (last_ptr->fragmented) {  in prepare_allocation_clustered()
4024 			ffe_ctl->hint_byte = last_ptr->window_start;  in prepare_allocation_clustered()
4025 			ffe_ctl->use_cluster = false;  in prepare_allocation_clustered()
4027 		spin_unlock(&last_ptr->lock);  in prepare_allocation_clustered()
4038 	switch (ffe_ctl->policy) {  in prepare_allocation()
4050  * ins->objectid == start position
4051  * ins->flags = BTRFS_EXTENT_ITEM_KEY
4052  * ins->offset == the size of the hole.
4055  * If there is no suitable free space, we will record the max size of
4061  * |- Iterate through all block groups
4062  * |  |- Get a valid block group
4063  * |  |- Try to do clustered allocation in that block group
4064  * |  |- Try to do unclustered allocation in that block group
4065  * |  |- Check if the result is valid
4066  * |  |  |- If valid, then exit
4067  * |  |- Jump to next block group
4069  * |- Push harder to find free extents
4070  *    |- If not found, re-iterate all block groups
4077 	struct btrfs_fs_info *fs_info = root->fs_info;  in find_free_extent()
4085 	WARN_ON(num_bytes < fs_info->sectorsize);  in find_free_extent()
4105 	ins->type = BTRFS_EXTENT_ITEM_KEY;  in find_free_extent()
4106 	ins->objectid = 0;  in find_free_extent()
4107 	ins->offset = 0;  in find_free_extent()
4113 		btrfs_err(fs_info, "No space info for %llu", flags);  in find_free_extent()
4114 		return -ENOSPC;  in find_free_extent()
4131 		 * However if we are re-searching with an ideal block group  in find_free_extent()
4135 		    block_group->cached != BTRFS_CACHE_NO) {  in find_free_extent()
4136 			down_read(&space_info->groups_sem);  in find_free_extent()
4137 			if (list_empty(&block_group->list) ||  in find_free_extent()
4138 			    block_group->ro) {  in find_free_extent()
4146 				up_read(&space_info->groups_sem);  in find_free_extent()
4149 						block_group->flags);  in find_free_extent()
4162 	down_read(&space_info->groups_sem);  in find_free_extent()
4164 			    &space_info->block_groups[ffe_ctl.index], list) {  in find_free_extent()
4167 		/* If the block group is read-only, we can skip it entirely. */  in find_free_extent()
4168 		if (unlikely(block_group->ro))  in find_free_extent()
4172 		ffe_ctl.search_start = block_group->start;  in find_free_extent()
4190 			if ((flags & extra) && !(block_group->flags & extra))  in find_free_extent()
4195 			 * It's possible that we have MIXED_GROUP flag but no  in find_free_extent()
4224 		if (unlikely(block_group->cached == BTRFS_CACHE_ERROR))  in find_free_extent()
4234 		} else if (ret == -EAGAIN) {  in find_free_extent()
4242 					     fs_info->stripesize);  in find_free_extent()
4246 		    block_group->start + block_group->length) {  in find_free_extent()
4254 				ffe_ctl.search_start - ffe_ctl.found_offset);  in find_free_extent()
4258 		if (ret == -EAGAIN) {  in find_free_extent()
4266 		ins->objectid = ffe_ctl.search_start;  in find_free_extent()
4267 		ins->offset = num_bytes;  in find_free_extent()
4277 	up_read(&space_info->groups_sem);  in find_free_extent()
4283 	if (ret == -ENOSPC && !cache_block_group_error) {  in find_free_extent()
4285 		 * Use ffe_ctl->total_free_space as fallback if we can't find  in find_free_extent()
4290 		spin_lock(&space_info->lock);  in find_free_extent()
4291 		space_info->max_extent_size = ffe_ctl.max_extent_size;  in find_free_extent()
4292 		spin_unlock(&space_info->lock);  in find_free_extent()
4293 		ins->offset = ffe_ctl.max_extent_size;  in find_free_extent()
4294 	} else if (ret == -ENOSPC) {  in find_free_extent()
4301  * btrfs_reserve_extent - entry point to the extent allocator. Tries to find a
4304  * @root           -	The root that will contain this extent
4306  * @ram_bytes      -	The amount of space in ram that @num_bytes take. This
4310  * @num_bytes      -	Number of bytes to allocate on-disk.
4312  * @min_alloc_size -	Indicates the minimum amount of space that the
4319  * @empty_size     -	A hint that you plan on doing more COW. This is the
4324  * @hint_byte      -	Hint to the allocator to start searching above the byte
4327  * @ins            -	This key is modified to record the found hole. It will
4329  *			ins->objectid == start position
4330  *			ins->flags = BTRFS_EXTENT_ITEM_KEY
4331  *			ins->offset == the size of the hole.
4333  * @is_data        -	Boolean flag indicating whether an extent is
4336  * @delalloc       -	Boolean flag indicating whether this allocation is for
4342  * case -ENOSPC is returned then @ins->offset will contain the size of the
4350 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_reserve_extent()
4357 	WARN_ON(num_bytes < fs_info->sectorsize);  in btrfs_reserve_extent()
4361 		btrfs_dec_block_group_reservations(fs_info, ins->objectid);  in btrfs_reserve_extent()
4362 	} else if (ret == -ENOSPC) {  in btrfs_reserve_extent()
4363 		if (!final_tried && ins->offset) {  in btrfs_reserve_extent()
4364 			num_bytes = min(num_bytes >> 1, ins->offset);  in btrfs_reserve_extent()
4366 					       fs_info->sectorsize);  in btrfs_reserve_extent()
4397 		return -ENOSPC;  in btrfs_free_reserved_extent()
4414 	cache = btrfs_lookup_block_group(trans->fs_info, start);  in btrfs_pin_reserved_extent()
4416 		btrfs_err(trans->fs_info, "unable to find block group for %llu",  in btrfs_pin_reserved_extent()
4418 		return -ENOSPC;  in btrfs_pin_reserved_extent()
4431 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_file_extent()
4449 		return -ENOMEM;  in alloc_reserved_file_extent()
4451 	path->leave_spinning = 1;  in alloc_reserved_file_extent()
4452 	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,  in alloc_reserved_file_extent()
4459 	leaf = path->nodes[0];  in alloc_reserved_file_extent()
4460 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_file_extent()
4463 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_file_extent()
4476 		ref = (struct btrfs_extent_data_ref *)(&iref->offset);  in alloc_reserved_file_extent()
4483 	btrfs_mark_buffer_dirty(path->nodes[0]);  in alloc_reserved_file_extent()
4486 	ret = remove_from_free_space_tree(trans, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4490 	ret = btrfs_update_block_group(trans, ins->objectid, ins->offset, 1);  in alloc_reserved_file_extent()
4491 	if (ret) { /* -ENOENT, logic error */  in alloc_reserved_file_extent()
4493 			ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4496 	trace_btrfs_reserved_extent_alloc(fs_info, ins->objectid, ins->offset);  in alloc_reserved_file_extent()
4504 	struct btrfs_fs_info *fs_info = trans->fs_info;  in alloc_reserved_tree_block()
4515 	u64 flags = extent_op->flags_to_set;  in alloc_reserved_tree_block()
4520 	extent_key.objectid = node->bytenr;  in alloc_reserved_tree_block()
4522 		extent_key.offset = ref->level;  in alloc_reserved_tree_block()
4524 		num_bytes = fs_info->nodesize;  in alloc_reserved_tree_block()
4526 		extent_key.offset = node->num_bytes;  in alloc_reserved_tree_block()
4529 		num_bytes = node->num_bytes;  in alloc_reserved_tree_block()
4534 		return -ENOMEM;  in alloc_reserved_tree_block()
4536 	path->leave_spinning = 1;  in alloc_reserved_tree_block()
4537 	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,  in alloc_reserved_tree_block()
4544 	leaf = path->nodes[0];  in alloc_reserved_tree_block()
4545 	extent_item = btrfs_item_ptr(leaf, path->slots[0],  in alloc_reserved_tree_block()
4548 	btrfs_set_extent_generation(leaf, extent_item, trans->transid);  in alloc_reserved_tree_block()
4556 		btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);  in alloc_reserved_tree_block()
4557 		btrfs_set_tree_block_level(leaf, block_info, ref->level);  in alloc_reserved_tree_block()
4561 	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY) {  in alloc_reserved_tree_block()
4565 		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->parent);  in alloc_reserved_tree_block()
4569 		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->root);  in alloc_reserved_tree_block()
4581 				       fs_info->nodesize, 1);  in alloc_reserved_tree_block()
4582 	if (ret) { /* -ENOENT, logic error */  in alloc_reserved_tree_block()
4589 					  fs_info->nodesize);  in alloc_reserved_tree_block()
4601 	BUG_ON(root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);  in btrfs_alloc_reserved_file_extent()
4604 			       ins->objectid, ins->offset, 0);  in btrfs_alloc_reserved_file_extent()
4605 	btrfs_init_data_ref(&generic_ref, root->root_key.objectid, owner, offset);  in btrfs_alloc_reserved_file_extent()
4606 	btrfs_ref_tree_mod(root->fs_info, &generic_ref);  in btrfs_alloc_reserved_file_extent()
4621 	struct btrfs_fs_info *fs_info = trans->fs_info;  in btrfs_alloc_logged_file_extent()
4631 		ret = __exclude_logged_extent(fs_info, ins->objectid,  in btrfs_alloc_logged_file_extent()
4632 					      ins->offset);  in btrfs_alloc_logged_file_extent()
4637 	block_group = btrfs_lookup_block_group(fs_info, ins->objectid);  in btrfs_alloc_logged_file_extent()
4639 		return -EINVAL;  in btrfs_alloc_logged_file_extent()
4641 	space_info = block_group->space_info;  in btrfs_alloc_logged_file_extent()
4642 	spin_lock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
4643 	spin_lock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
4644 	space_info->bytes_reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
4645 	block_group->reserved += ins->offset;  in btrfs_alloc_logged_file_extent()
4646 	spin_unlock(&block_group->lock);  in btrfs_alloc_logged_file_extent()
4647 	spin_unlock(&space_info->lock);  in btrfs_alloc_logged_file_extent()
4652 		btrfs_pin_extent(trans, ins->objectid, ins->offset, 1);  in btrfs_alloc_logged_file_extent()
4662 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_init_new_buffer()
4674 	if (buf->lock_owner == current->pid) {  in btrfs_init_new_buffer()
4677 			buf->start, btrfs_header_owner(buf), current->pid);  in btrfs_init_new_buffer()
4679 		return ERR_PTR(-EUCLEAN);  in btrfs_init_new_buffer()
4685 	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);  in btrfs_init_new_buffer()
4692 	btrfs_set_header_bytenr(buf, buf->start);  in btrfs_init_new_buffer()
4693 	btrfs_set_header_generation(buf, trans->transid);  in btrfs_init_new_buffer()
4696 	write_extent_buffer_fsid(buf, fs_info->fs_devices->metadata_uuid);  in btrfs_init_new_buffer()
4697 	write_extent_buffer_chunk_tree_uuid(buf, fs_info->chunk_tree_uuid);  in btrfs_init_new_buffer()
4698 	if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {  in btrfs_init_new_buffer()
4699 		buf->log_index = root->log_transid % 2;  in btrfs_init_new_buffer()
4704 		if (buf->log_index == 0)  in btrfs_init_new_buffer()
4705 			set_extent_dirty(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
4706 					buf->start + buf->len - 1, GFP_NOFS);  in btrfs_init_new_buffer()
4708 			set_extent_new(&root->dirty_log_pages, buf->start,  in btrfs_init_new_buffer()
4709 					buf->start + buf->len - 1);  in btrfs_init_new_buffer()
4711 		buf->log_index = -1;  in btrfs_init_new_buffer()
4712 		set_extent_dirty(&trans->transaction->dirty_pages, buf->start,  in btrfs_init_new_buffer()
4713 			 buf->start + buf->len - 1, GFP_NOFS);  in btrfs_init_new_buffer()
4715 	trans->dirty = true;  in btrfs_init_new_buffer()
4732 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_alloc_tree_block()
4740 	u32 blocksize = fs_info->nodesize;  in btrfs_alloc_tree_block()
4745 		buf = btrfs_init_new_buffer(trans, root, root->alloc_bytenr,  in btrfs_alloc_tree_block()
4748 			root->alloc_bytenr += blocksize;  in btrfs_alloc_tree_block()
4779 			ret = -ENOMEM;  in btrfs_alloc_tree_block()
4783 			memcpy(&extent_op->key, key, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
4785 			memset(&extent_op->key, 0, sizeof(extent_op->key));  in btrfs_alloc_tree_block()
4786 		extent_op->flags_to_set = flags;  in btrfs_alloc_tree_block()
4787 		extent_op->update_key = skinny_metadata ? false : true;  in btrfs_alloc_tree_block()
4788 		extent_op->update_flags = true;  in btrfs_alloc_tree_block()
4789 		extent_op->is_data = false;  in btrfs_alloc_tree_block()
4790 		extent_op->level = level;  in btrfs_alloc_tree_block()
4794 		generic_ref.real_root = root->root_key.objectid;  in btrfs_alloc_tree_block()
4836 				     struct walk_control *wc,  in reada_walk_down()  argument
4839 	struct btrfs_fs_info *fs_info = root->fs_info;  in reada_walk_down()
4851 	if (path->slots[wc->level] < wc->reada_slot) {  in reada_walk_down()
4852 		wc->reada_count = wc->reada_count * 2 / 3;  in reada_walk_down()
4853 		wc->reada_count = max(wc->reada_count, 2);  in reada_walk_down()
4855 		wc->reada_count = wc->reada_count * 3 / 2;  in reada_walk_down()
4856 		wc->reada_count = min_t(int, wc->reada_count,  in reada_walk_down()
4860 	eb = path->nodes[wc->level];  in reada_walk_down()
4863 	for (slot = path->slots[wc->level]; slot < nritems; slot++) {  in reada_walk_down()
4864 		if (nread >= wc->reada_count)  in reada_walk_down()
4871 		if (slot == path->slots[wc->level])  in reada_walk_down()
4874 		if (wc->stage == UPDATE_BACKREF &&  in reada_walk_down()
4875 		    generation <= root->root_key.offset)  in reada_walk_down()
4880 					       wc->level - 1, 1, &refs,  in reada_walk_down()
4887 		if (wc->stage == DROP_REFERENCE) {  in reada_walk_down()
4891 			if (wc->level == 1 &&  in reada_walk_down()
4894 			if (!wc->update_ref ||  in reada_walk_down()
4895 			    generation <= root->root_key.offset)  in reada_walk_down()
4899 						  &wc->update_progress);  in reada_walk_down()
4903 			if (wc->level == 1 &&  in reada_walk_down()
4911 	wc->reada_slot = slot;  in reada_walk_down()
4917  * when wc->stage == UPDATE_BACKREF, this function updates
4925 				   struct walk_control *wc, int lookup_info)  in walk_down_proc()  argument
4927 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_down_proc()
4928 	int level = wc->level;  in walk_down_proc()
4929 	struct extent_buffer *eb = path->nodes[level];  in walk_down_proc()
4933 	if (wc->stage == UPDATE_BACKREF &&  in walk_down_proc()
4934 	    btrfs_header_owner(eb) != root->root_key.objectid)  in walk_down_proc()
4942 	    ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||  in walk_down_proc()
4943 	     (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {  in walk_down_proc()
4944 		BUG_ON(!path->locks[level]);  in walk_down_proc()
4946 					       eb->start, level, 1,  in walk_down_proc()
4947 					       &wc->refs[level],  in walk_down_proc()
4948 					       &wc->flags[level]);  in walk_down_proc()
4949 		BUG_ON(ret == -ENOMEM);  in walk_down_proc()
4952 		BUG_ON(wc->refs[level] == 0);  in walk_down_proc()
4955 	if (wc->stage == DROP_REFERENCE) {  in walk_down_proc()
4956 		if (wc->refs[level] > 1)  in walk_down_proc()
4959 		if (path->locks[level] && !wc->keep_locks) {  in walk_down_proc()
4960 			btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
4961 			path->locks[level] = 0;  in walk_down_proc()
4966 	/* wc->stage == UPDATE_BACKREF */  in walk_down_proc()
4967 	if (!(wc->flags[level] & flag)) {  in walk_down_proc()
4968 		BUG_ON(!path->locks[level]);  in walk_down_proc()
4970 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4972 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4975 		BUG_ON(ret); /* -ENOMEM */  in walk_down_proc()
4976 		wc->flags[level] |= flag;  in walk_down_proc()
4983 	if (path->locks[level] && level > 0) {  in walk_down_proc()
4984 		btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_down_proc()
4985 		path->locks[level] = 0;  in walk_down_proc()
5004 		return -ENOMEM;  in check_ref_exists()
5007 				    root->fs_info->nodesize, parent,  in check_ref_exists()
5008 				    root->root_key.objectid, level, 0);  in check_ref_exists()
5010 	if (ret == -ENOENT)  in check_ref_exists()
5020  * when wc->stage == DROP_REFERENCE, this function checks
5023  * rooted at the block, this function changes wc->stage to
5024  * UPDATE_BACKREF. if the block is shared and there is no
5033 				 struct walk_control *wc, int *lookup_info)  in do_walk_down()  argument
5035 	struct btrfs_fs_info *fs_info = root->fs_info;  in do_walk_down()
5043 	int level = wc->level;  in do_walk_down()
5048 	generation = btrfs_node_ptr_generation(path->nodes[level],  in do_walk_down()
5049 					       path->slots[level]);  in do_walk_down()
5052 	 * was created, we know there is no need to update back refs  in do_walk_down()
5055 	if (wc->stage == UPDATE_BACKREF &&  in do_walk_down()
5056 	    generation <= root->root_key.offset) {  in do_walk_down()
5061 	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);  in do_walk_down()
5062 	btrfs_node_key_to_cpu(path->nodes[level], &first_key,  in do_walk_down()
5063 			      path->slots[level]);  in do_walk_down()
5071 		btrfs_set_buffer_lockdep_class(root->root_key.objectid, next,  in do_walk_down()
5072 					       level - 1);  in do_walk_down()
5078 	ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,  in do_walk_down()
5079 				       &wc->refs[level - 1],  in do_walk_down()
5080 				       &wc->flags[level - 1]);  in do_walk_down()
5084 	if (unlikely(wc->refs[level - 1] == 0)) {  in do_walk_down()
5086 		ret = -EIO;  in do_walk_down()
5091 	if (wc->stage == DROP_REFERENCE) {  in do_walk_down()
5092 		if (wc->refs[level - 1] > 1) {  in do_walk_down()
5095 			    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))  in do_walk_down()
5098 			if (!wc->update_ref ||  in do_walk_down()
5099 			    generation <= root->root_key.offset)  in do_walk_down()
5102 			btrfs_node_key_to_cpu(path->nodes[level], &key,  in do_walk_down()
5103 					      path->slots[level]);  in do_walk_down()
5104 			ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);  in do_walk_down()
5108 			wc->stage = UPDATE_BACKREF;  in do_walk_down()
5109 			wc->shared_level = level - 1;  in do_walk_down()
5113 		    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))  in do_walk_down()
5126 			reada_walk_down(trans, root, wc, path);  in do_walk_down()
5127 		next = read_tree_block(fs_info, bytenr, generation, level - 1,  in do_walk_down()
5133 			return -EIO;  in do_walk_down()
5139 	level--;  in do_walk_down()
5142 		btrfs_err(root->fs_info, "mismatched level");  in do_walk_down()
5143 		ret = -EIO;  in do_walk_down()
5146 	path->nodes[level] = next;  in do_walk_down()
5147 	path->slots[level] = 0;  in do_walk_down()
5148 	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in do_walk_down()
5149 	wc->level = level;  in do_walk_down()
5150 	if (wc->level == 1)  in do_walk_down()
5151 		wc->reada_slot = 0;  in do_walk_down()
5154 	wc->refs[level - 1] = 0;  in do_walk_down()
5155 	wc->flags[level - 1] = 0;  in do_walk_down()
5156 	if (wc->stage == DROP_REFERENCE) {  in do_walk_down()
5157 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {  in do_walk_down()
5158 			parent = path->nodes[level]->start;  in do_walk_down()
5160 			ASSERT(root->root_key.objectid ==  in do_walk_down()
5161 			       btrfs_header_owner(path->nodes[level]));  in do_walk_down()
5162 			if (root->root_key.objectid !=  in do_walk_down()
5163 			    btrfs_header_owner(path->nodes[level])) {  in do_walk_down()
5164 				btrfs_err(root->fs_info,  in do_walk_down()
5166 				ret = -EIO;  in do_walk_down()
5176 		 * ->restarted flag.  in do_walk_down()
5178 		if (wc->restarted) {  in do_walk_down()
5180 					       level - 1);  in do_walk_down()
5186 			wc->restarted = 0;  in do_walk_down()
5194 		if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&  in do_walk_down()
5197 							 generation, level - 1);  in do_walk_down()
5211 		wc->drop_level = level;  in do_walk_down()
5212 		find_next_key(path, level, &wc->drop_progress);  in do_walk_down()
5215 				       fs_info->nodesize, parent);  in do_walk_down()
5216 		btrfs_init_tree_ref(&ref, level - 1, root->root_key.objectid);  in do_walk_down()
5235  * when wc->stage == DROP_REFERENCE, this function drops
5238  * when wc->stage == UPDATE_BACKREF, this function changes
5239  * wc->stage back to DROP_REFERENCE if we changed wc->stage
5247 				 struct walk_control *wc)  in walk_up_proc()  argument
5249 	struct btrfs_fs_info *fs_info = root->fs_info;  in walk_up_proc()
5251 	int level = wc->level;  in walk_up_proc()
5252 	struct extent_buffer *eb = path->nodes[level];  in walk_up_proc()
5255 	if (wc->stage == UPDATE_BACKREF) {  in walk_up_proc()
5256 		BUG_ON(wc->shared_level < level);  in walk_up_proc()
5257 		if (level < wc->shared_level)  in walk_up_proc()
5260 		ret = find_next_key(path, level + 1, &wc->update_progress);  in walk_up_proc()
5262 			wc->update_ref = 0;  in walk_up_proc()
5264 		wc->stage = DROP_REFERENCE;  in walk_up_proc()
5265 		wc->shared_level = -1;  in walk_up_proc()
5266 		path->slots[level] = 0;  in walk_up_proc()
5273 		if (!path->locks[level]) {  in walk_up_proc()
5277 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in walk_up_proc()
5280 						       eb->start, level, 1,  in walk_up_proc()
5281 						       &wc->refs[level],  in walk_up_proc()
5282 						       &wc->flags[level]);  in walk_up_proc()
5284 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5285 				path->locks[level] = 0;  in walk_up_proc()
5288 			BUG_ON(wc->refs[level] == 0);  in walk_up_proc()
5289 			if (wc->refs[level] == 1) {  in walk_up_proc()
5290 				btrfs_tree_unlock_rw(eb, path->locks[level]);  in walk_up_proc()
5291 				path->locks[level] = 0;  in walk_up_proc()
5297 	/* wc->stage == DROP_REFERENCE */  in walk_up_proc()
5298 	BUG_ON(wc->refs[level] > 1 && !path->locks[level]);  in walk_up_proc()
5300 	if (wc->refs[level] == 1) {  in walk_up_proc()
5302 			if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5306 			BUG_ON(ret); /* -ENOMEM */  in walk_up_proc()
5307 			if (is_fstree(root->root_key.objectid)) {  in walk_up_proc()
5317 		if (!path->locks[level] &&  in walk_up_proc()
5318 		    btrfs_header_generation(eb) == trans->transid) {  in walk_up_proc()
5321 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in walk_up_proc()
5326 	if (eb == root->node) {  in walk_up_proc()
5327 		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5328 			parent = eb->start;  in walk_up_proc()
5329 		else if (root->root_key.objectid != btrfs_header_owner(eb))  in walk_up_proc()
5332 		if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)  in walk_up_proc()
5333 			parent = path->nodes[level + 1]->start;  in walk_up_proc()
5334 		else if (root->root_key.objectid !=  in walk_up_proc()
5335 			 btrfs_header_owner(path->nodes[level + 1]))  in walk_up_proc()
5339 	btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);  in walk_up_proc()
5341 	wc->refs[level] = 0;  in walk_up_proc()
5342 	wc->flags[level] = 0;  in walk_up_proc()
5347 		     btrfs_header_owner(eb), root->root_key.objectid);  in walk_up_proc()
5348 	return -EUCLEAN;  in walk_up_proc()
5354 				   struct walk_control *wc)  in walk_down_tree()  argument
5356 	int level = wc->level;  in walk_down_tree()
5361 		ret = walk_down_proc(trans, root, path, wc, lookup_info);  in walk_down_tree()
5368 		if (path->slots[level] >=  in walk_down_tree()
5369 		    btrfs_header_nritems(path->nodes[level]))  in walk_down_tree()
5372 		ret = do_walk_down(trans, root, path, wc, &lookup_info);  in walk_down_tree()
5374 			path->slots[level]++;  in walk_down_tree()
5378 		level = wc->level;  in walk_down_tree()
5386 				 struct walk_control *wc, int max_level)  in walk_up_tree()  argument
5388 	int level = wc->level;  in walk_up_tree()
5391 	path->slots[level] = btrfs_header_nritems(path->nodes[level]);  in walk_up_tree()
5392 	while (level < max_level && path->nodes[level]) {  in walk_up_tree()
5393 		wc->level = level;  in walk_up_tree()
5394 		if (path->slots[level] + 1 <  in walk_up_tree()
5395 		    btrfs_header_nritems(path->nodes[level])) {  in walk_up_tree()
5396 			path->slots[level]++;  in walk_up_tree()
5399 			ret = walk_up_proc(trans, root, path, wc);  in walk_up_tree()
5405 			if (path->locks[level]) {  in walk_up_tree()
5406 				btrfs_tree_unlock_rw(path->nodes[level],  in walk_up_tree()
5407 						     path->locks[level]);  in walk_up_tree()
5408 				path->locks[level] = 0;  in walk_up_tree()
5410 			free_extent_buffer(path->nodes[level]);  in walk_up_tree()
5411 			path->nodes[level] = NULL;  in walk_up_tree()
5429  * If called with for_reloc == 0, may exit early with -EAGAIN
5433 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_snapshot()
5436 	struct btrfs_root *tree_root = fs_info->tree_root;  in btrfs_drop_snapshot()
5437 	struct btrfs_root_item *root_item = &root->root_item;  in btrfs_drop_snapshot()
5438 	struct walk_control *wc;  in btrfs_drop_snapshot()  local
5445 	btrfs_debug(fs_info, "Drop subvolume %llu", root->root_key.objectid);  in btrfs_drop_snapshot()
5449 		err = -ENOMEM;  in btrfs_drop_snapshot()
5453 	wc = kzalloc(sizeof(*wc), GFP_NOFS);  in btrfs_drop_snapshot()
5454 	if (!wc) {  in btrfs_drop_snapshot()
5456 		err = -ENOMEM;  in btrfs_drop_snapshot()
5485 	set_bit(BTRFS_ROOT_DELETING, &root->state);  in btrfs_drop_snapshot()
5486 	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {  in btrfs_drop_snapshot()
5487 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
5488 		path->nodes[level] = btrfs_lock_root_node(root);  in btrfs_drop_snapshot()
5489 		btrfs_set_lock_blocking_write(path->nodes[level]);  in btrfs_drop_snapshot()
5490 		path->slots[level] = 0;  in btrfs_drop_snapshot()
5491 		path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_snapshot()
5492 		memset(&wc->update_progress, 0,  in btrfs_drop_snapshot()
5493 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
5495 		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);  in btrfs_drop_snapshot()
5496 		memcpy(&wc->update_progress, &key,  in btrfs_drop_snapshot()
5497 		       sizeof(wc->update_progress));  in btrfs_drop_snapshot()
5499 		level = root_item->drop_level;  in btrfs_drop_snapshot()
5501 		path->lowest_level = level;  in btrfs_drop_snapshot()
5503 		path->lowest_level = 0;  in btrfs_drop_snapshot()
5516 		level = btrfs_header_level(root->node);  in btrfs_drop_snapshot()
5518 			btrfs_tree_lock(path->nodes[level]);  in btrfs_drop_snapshot()
5519 			btrfs_set_lock_blocking_write(path->nodes[level]);  in btrfs_drop_snapshot()
5520 			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_snapshot()
5523 						path->nodes[level]->start,  in btrfs_drop_snapshot()
5524 						level, 1, &wc->refs[level],  in btrfs_drop_snapshot()
5525 						&wc->flags[level]);  in btrfs_drop_snapshot()
5530 			BUG_ON(wc->refs[level] == 0);  in btrfs_drop_snapshot()
5532 			if (level == root_item->drop_level)  in btrfs_drop_snapshot()
5535 			btrfs_tree_unlock(path->nodes[level]);  in btrfs_drop_snapshot()
5536 			path->locks[level] = 0;  in btrfs_drop_snapshot()
5537 			WARN_ON(wc->refs[level] != 1);  in btrfs_drop_snapshot()
5538 			level--;  in btrfs_drop_snapshot()
5542 	wc->restarted = test_bit(BTRFS_ROOT_DEAD_TREE, &root->state);  in btrfs_drop_snapshot()
5543 	wc->level = level;  in btrfs_drop_snapshot()
5544 	wc->shared_level = -1;  in btrfs_drop_snapshot()
5545 	wc->stage = DROP_REFERENCE;  in btrfs_drop_snapshot()
5546 	wc->update_ref = update_ref;  in btrfs_drop_snapshot()
5547 	wc->keep_locks = 0;  in btrfs_drop_snapshot()
5548 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_snapshot()
5552 		ret = walk_down_tree(trans, root, path, wc);  in btrfs_drop_snapshot()
5558 		ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);  in btrfs_drop_snapshot()
5565 			BUG_ON(wc->stage != DROP_REFERENCE);  in btrfs_drop_snapshot()
5569 		if (wc->stage == DROP_REFERENCE) {  in btrfs_drop_snapshot()
5570 			wc->drop_level = wc->level;  in btrfs_drop_snapshot()
5571 			btrfs_node_key_to_cpu(path->nodes[wc->drop_level],  in btrfs_drop_snapshot()
5572 					      &wc->drop_progress,  in btrfs_drop_snapshot()
5573 					      path->slots[wc->drop_level]);  in btrfs_drop_snapshot()
5575 		btrfs_cpu_key_to_disk(&root_item->drop_progress,  in btrfs_drop_snapshot()
5576 				      &wc->drop_progress);  in btrfs_drop_snapshot()
5577 		root_item->drop_level = wc->drop_level;  in btrfs_drop_snapshot()
5579 		BUG_ON(wc->level == 0);  in btrfs_drop_snapshot()
5583 						&root->root_key,  in btrfs_drop_snapshot()
5595 				err = -EAGAIN;  in btrfs_drop_snapshot()
5610 	ret = btrfs_del_root(trans, &root->root_key);  in btrfs_drop_snapshot()
5617 	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {  in btrfs_drop_snapshot()
5618 		ret = btrfs_find_root(tree_root, &root->root_key, path,  in btrfs_drop_snapshot()
5628 			 * The most common failure here is just -ENOENT.  in btrfs_drop_snapshot()
5631 					      root->root_key.objectid);  in btrfs_drop_snapshot()
5643 	if (test_bit(BTRFS_ROOT_IN_RADIX, &root->state))  in btrfs_drop_snapshot()
5651 	kfree(wc);  in btrfs_drop_snapshot()
5659 	 * or unmount) so we don't leak memory.  in btrfs_drop_snapshot()
5677 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_drop_subtree()
5679 	struct walk_control *wc;  in btrfs_drop_subtree()  local
5685 	BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);  in btrfs_drop_subtree()
5689 		return -ENOMEM;  in btrfs_drop_subtree()
5691 	wc = kzalloc(sizeof(*wc), GFP_NOFS);  in btrfs_drop_subtree()
5692 	if (!wc) {  in btrfs_drop_subtree()
5694 		return -ENOMEM;  in btrfs_drop_subtree()
5699 	atomic_inc(&parent->refs);  in btrfs_drop_subtree()
5700 	path->nodes[parent_level] = parent;  in btrfs_drop_subtree()
5701 	path->slots[parent_level] = btrfs_header_nritems(parent);  in btrfs_drop_subtree()
5705 	path->nodes[level] = node;  in btrfs_drop_subtree()
5706 	path->slots[level] = 0;  in btrfs_drop_subtree()
5707 	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;  in btrfs_drop_subtree()
5709 	wc->refs[parent_level] = 1;  in btrfs_drop_subtree()
5710 	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;  in btrfs_drop_subtree()
5711 	wc->level = level;  in btrfs_drop_subtree()
5712 	wc->shared_level = -1;  in btrfs_drop_subtree()
5713 	wc->stage = DROP_REFERENCE;  in btrfs_drop_subtree()
5714 	wc->update_ref = 0;  in btrfs_drop_subtree()
5715 	wc->keep_locks = 1;  in btrfs_drop_subtree()
5716 	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);  in btrfs_drop_subtree()
5719 		wret = walk_down_tree(trans, root, path, wc);  in btrfs_drop_subtree()
5725 		wret = walk_up_tree(trans, root, path, wc, parent_level);  in btrfs_drop_subtree()
5732 	kfree(wc);  in btrfs_drop_subtree()
5748 	if (list_empty(&sinfo->ro_bgs))  in btrfs_account_ro_block_groups_free_space()
5751 	spin_lock(&sinfo->lock);  in btrfs_account_ro_block_groups_free_space()
5752 	list_for_each_entry(block_group, &sinfo->ro_bgs, ro_list) {  in btrfs_account_ro_block_groups_free_space()
5753 		spin_lock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5755 		if (!block_group->ro) {  in btrfs_account_ro_block_groups_free_space()
5756 			spin_unlock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5760 		factor = btrfs_bg_type_to_factor(block_group->flags);  in btrfs_account_ro_block_groups_free_space()
5761 		free_bytes += (block_group->length -  in btrfs_account_ro_block_groups_free_space()
5762 			       block_group->used) * factor;  in btrfs_account_ro_block_groups_free_space()
5764 		spin_unlock(&block_group->lock);  in btrfs_account_ro_block_groups_free_space()
5766 	spin_unlock(&sinfo->lock);  in btrfs_account_ro_block_groups_free_space()
5791  * from committing and releasing the memory that the pending chunks
5805 	if (!blk_queue_discard(bdev_get_queue(device->bdev)))  in btrfs_trim_free_extents()
5809 	if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state))  in btrfs_trim_free_extents()
5812 	/* No free space = nothing to do. */  in btrfs_trim_free_extents()
5813 	if (device->total_bytes <= device->bytes_used)  in btrfs_trim_free_extents()
5819 		struct btrfs_fs_info *fs_info = device->fs_info;  in btrfs_trim_free_extents()
5822 		ret = mutex_lock_interruptible(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5826 		find_first_clear_extent_bit(&device->alloc_state, start,  in btrfs_trim_free_extents()
5831 		if (start > device->total_bytes) {  in btrfs_trim_free_extents()
5835 					  start, end - start + 1,  in btrfs_trim_free_extents()
5836 					  rcu_str_deref(device->name),  in btrfs_trim_free_extents()
5837 					  device->total_bytes);  in btrfs_trim_free_extents()
5838 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5848 		 * end of the device it will set end to -1, in this case it's up  in btrfs_trim_free_extents()
5851 		end = min(end, device->total_bytes - 1);  in btrfs_trim_free_extents()
5853 		len = end - start + 1;  in btrfs_trim_free_extents()
5857 			mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5862 		ret = btrfs_issue_discard(device->bdev, start, len,  in btrfs_trim_free_extents()
5865 			set_extent_bits(&device->alloc_state, start,  in btrfs_trim_free_extents()
5866 					start + bytes - 1,  in btrfs_trim_free_extents()
5868 		mutex_unlock(&fs_info->chunk_mutex);  in btrfs_trim_free_extents()
5877 			ret = -ERESTARTSYS;  in btrfs_trim_free_extents()
5913 	 * Check range overflow if range->len is set.  in btrfs_trim_fs()
5914 	 * The default range->len is U64_MAX.  in btrfs_trim_fs()
5916 	if (range->len != U64_MAX &&  in btrfs_trim_fs()
5917 	    check_add_overflow(range->start, range->len, &range_end))  in btrfs_trim_fs()
5918 		return -EINVAL;  in btrfs_trim_fs()
5920 	cache = btrfs_lookup_first_block_group(fs_info, range->start);  in btrfs_trim_fs()
5922 		if (cache->start >= range_end) {  in btrfs_trim_fs()
5927 		start = max(range->start, cache->start);  in btrfs_trim_fs()
5928 		end = min(range_end, cache->start + cache->length);  in btrfs_trim_fs()
5930 		if (end - start >= range->minlen) {  in btrfs_trim_fs()
5949 						     range->minlen);  in btrfs_trim_fs()
5964 	mutex_lock(&fs_info->fs_devices->device_list_mutex);  in btrfs_trim_fs()
5965 	devices = &fs_info->fs_devices->devices;  in btrfs_trim_fs()
5976 	mutex_unlock(&fs_info->fs_devices->device_list_mutex);  in btrfs_trim_fs()
5982 	range->len = trimmed;  in btrfs_trim_fs()