Linux Audio

Check our new training course

Loading...
v6.8
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) 2007 Oracle.  All rights reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   4 */
   5
   6#include <linux/sched.h>
   7#include <linux/sched/signal.h>
   8#include <linux/pagemap.h>
   9#include <linux/writeback.h>
  10#include <linux/blkdev.h>
  11#include <linux/sort.h>
  12#include <linux/rcupdate.h>
  13#include <linux/kthread.h>
  14#include <linux/slab.h>
  15#include <linux/ratelimit.h>
  16#include <linux/percpu_counter.h>
  17#include <linux/lockdep.h>
  18#include <linux/crc32c.h>
  19#include "ctree.h"
  20#include "extent-tree.h"
  21#include "tree-log.h"
  22#include "disk-io.h"
  23#include "print-tree.h"
 
  24#include "volumes.h"
  25#include "raid56.h"
  26#include "locking.h"
  27#include "free-space-cache.h"
  28#include "free-space-tree.h"
  29#include "sysfs.h"
  30#include "qgroup.h"
  31#include "ref-verify.h"
  32#include "space-info.h"
  33#include "block-rsv.h"
  34#include "delalloc-space.h"
  35#include "discard.h"
  36#include "rcu-string.h"
  37#include "zoned.h"
  38#include "dev-replace.h"
  39#include "fs.h"
  40#include "accessors.h"
  41#include "root-tree.h"
  42#include "file-item.h"
  43#include "orphan.h"
  44#include "tree-checker.h"
  45#include "raid-stripe-tree.h"
  46
  47#undef SCRAMBLE_DELAYED_REFS
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  48
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  49
 
 
 
  50static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
  51			       struct btrfs_delayed_ref_head *href,
  52			       struct btrfs_delayed_ref_node *node, u64 parent,
  53			       u64 root_objectid, u64 owner_objectid,
  54			       u64 owner_offset,
  55			       struct btrfs_delayed_extent_op *extra_op);
  56static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
  57				    struct extent_buffer *leaf,
  58				    struct btrfs_extent_item *ei);
  59static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
 
  60				      u64 parent, u64 root_objectid,
  61				      u64 flags, u64 owner, u64 offset,
  62				      struct btrfs_key *ins, int ref_mod, u64 oref_root);
  63static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
  64				     struct btrfs_delayed_ref_node *node,
  65				     struct btrfs_delayed_extent_op *extent_op);
 
 
 
 
 
  66static int find_next_key(struct btrfs_path *path, int level,
  67			 struct btrfs_key *key);
 
 
 
 
  68
  69static int block_group_bits(struct btrfs_block_group *cache, u64 bits)
 
 
 
 
 
 
 
  70{
  71	return (cache->flags & bits) == bits;
  72}
  73
  74/* simple helper to search for an existing data extent at a given offset */
  75int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  76{
  77	struct btrfs_root *root = btrfs_extent_root(fs_info, start);
  78	int ret;
  79	struct btrfs_key key;
  80	struct btrfs_path *path;
  81
  82	path = btrfs_alloc_path();
  83	if (!path)
  84		return -ENOMEM;
  85
  86	key.objectid = start;
  87	key.offset = len;
  88	key.type = BTRFS_EXTENT_ITEM_KEY;
  89	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 
  90	btrfs_free_path(path);
  91	return ret;
  92}
  93
  94/*
  95 * helper function to lookup reference count and flags of a tree block.
  96 *
  97 * the head node for delayed ref is used to store the sum of all the
  98 * reference count modifications queued up in the rbtree. the head
  99 * node may also store the extent flags to set. This way you can check
 100 * to see what the reference count and extent flags would be if all of
 101 * the delayed refs are not processed.
 102 */
 103int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
 104			     struct btrfs_fs_info *fs_info, u64 bytenr,
 105			     u64 offset, int metadata, u64 *refs, u64 *flags,
 106			     u64 *owning_root)
 107{
 108	struct btrfs_root *extent_root;
 109	struct btrfs_delayed_ref_head *head;
 110	struct btrfs_delayed_ref_root *delayed_refs;
 111	struct btrfs_path *path;
 112	struct btrfs_extent_item *ei;
 113	struct extent_buffer *leaf;
 114	struct btrfs_key key;
 115	u32 item_size;
 116	u64 num_refs;
 117	u64 extent_flags;
 118	u64 owner = 0;
 119	int ret;
 120
 121	/*
 122	 * If we don't have skinny metadata, don't bother doing anything
 123	 * different
 124	 */
 125	if (metadata && !btrfs_fs_incompat(fs_info, SKINNY_METADATA)) {
 126		offset = fs_info->nodesize;
 127		metadata = 0;
 128	}
 129
 130	path = btrfs_alloc_path();
 131	if (!path)
 132		return -ENOMEM;
 133
 
 
 
 134	if (!trans) {
 135		path->skip_locking = 1;
 136		path->search_commit_root = 1;
 137	}
 138
 139search_again:
 140	key.objectid = bytenr;
 141	key.offset = offset;
 142	if (metadata)
 143		key.type = BTRFS_METADATA_ITEM_KEY;
 144	else
 145		key.type = BTRFS_EXTENT_ITEM_KEY;
 146
 147	extent_root = btrfs_extent_root(fs_info, bytenr);
 148	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
 149	if (ret < 0)
 150		goto out_free;
 151
 152	if (ret > 0 && metadata && key.type == BTRFS_METADATA_ITEM_KEY) {
 153		if (path->slots[0]) {
 154			path->slots[0]--;
 155			btrfs_item_key_to_cpu(path->nodes[0], &key,
 156					      path->slots[0]);
 157			if (key.objectid == bytenr &&
 158			    key.type == BTRFS_EXTENT_ITEM_KEY &&
 159			    key.offset == fs_info->nodesize)
 160				ret = 0;
 161		}
 162	}
 163
 164	if (ret == 0) {
 165		leaf = path->nodes[0];
 166		item_size = btrfs_item_size(leaf, path->slots[0]);
 167		if (item_size >= sizeof(*ei)) {
 168			ei = btrfs_item_ptr(leaf, path->slots[0],
 169					    struct btrfs_extent_item);
 170			num_refs = btrfs_extent_refs(leaf, ei);
 171			extent_flags = btrfs_extent_flags(leaf, ei);
 172			owner = btrfs_get_extent_owner_root(fs_info, leaf,
 173							    path->slots[0]);
 174		} else {
 175			ret = -EUCLEAN;
 176			btrfs_err(fs_info,
 177			"unexpected extent item size, has %u expect >= %zu",
 178				  item_size, sizeof(*ei));
 179			if (trans)
 180				btrfs_abort_transaction(trans, ret);
 181			else
 182				btrfs_handle_fs_error(fs_info, ret, NULL);
 183
 184			goto out_free;
 
 185		}
 186
 187		BUG_ON(num_refs == 0);
 188	} else {
 189		num_refs = 0;
 190		extent_flags = 0;
 191		ret = 0;
 192	}
 193
 194	if (!trans)
 195		goto out;
 196
 197	delayed_refs = &trans->transaction->delayed_refs;
 198	spin_lock(&delayed_refs->lock);
 199	head = btrfs_find_delayed_ref_head(delayed_refs, bytenr);
 200	if (head) {
 201		if (!mutex_trylock(&head->mutex)) {
 202			refcount_inc(&head->refs);
 203			spin_unlock(&delayed_refs->lock);
 204
 205			btrfs_release_path(path);
 206
 207			/*
 208			 * Mutex was contended, block until it's released and try
 209			 * again
 210			 */
 211			mutex_lock(&head->mutex);
 212			mutex_unlock(&head->mutex);
 213			btrfs_put_delayed_ref_head(head);
 214			goto search_again;
 215		}
 216		spin_lock(&head->lock);
 217		if (head->extent_op && head->extent_op->update_flags)
 218			extent_flags |= head->extent_op->flags_to_set;
 219		else
 220			BUG_ON(num_refs == 0);
 221
 222		num_refs += head->ref_mod;
 223		spin_unlock(&head->lock);
 224		mutex_unlock(&head->mutex);
 225	}
 226	spin_unlock(&delayed_refs->lock);
 227out:
 228	WARN_ON(num_refs == 0);
 229	if (refs)
 230		*refs = num_refs;
 231	if (flags)
 232		*flags = extent_flags;
 233	if (owning_root)
 234		*owning_root = owner;
 235out_free:
 236	btrfs_free_path(path);
 237	return ret;
 238}
 239
 240/*
 241 * Back reference rules.  Back refs have three main goals:
 242 *
 243 * 1) differentiate between all holders of references to an extent so that
 244 *    when a reference is dropped we can make sure it was a valid reference
 245 *    before freeing the extent.
 246 *
 247 * 2) Provide enough information to quickly find the holders of an extent
 248 *    if we notice a given block is corrupted or bad.
 249 *
 250 * 3) Make it easy to migrate blocks for FS shrinking or storage pool
 251 *    maintenance.  This is actually the same as #2, but with a slightly
 252 *    different use case.
 253 *
 254 * There are two kinds of back refs. The implicit back refs is optimized
 255 * for pointers in non-shared tree blocks. For a given pointer in a block,
 256 * back refs of this kind provide information about the block's owner tree
 257 * and the pointer's key. These information allow us to find the block by
 258 * b-tree searching. The full back refs is for pointers in tree blocks not
 259 * referenced by their owner trees. The location of tree block is recorded
 260 * in the back refs. Actually the full back refs is generic, and can be
 261 * used in all cases the implicit back refs is used. The major shortcoming
 262 * of the full back refs is its overhead. Every time a tree block gets
 263 * COWed, we have to update back refs entry for all pointers in it.
 264 *
 265 * For a newly allocated tree block, we use implicit back refs for
 266 * pointers in it. This means most tree related operations only involve
 267 * implicit back refs. For a tree block created in old transaction, the
 268 * only way to drop a reference to it is COW it. So we can detect the
 269 * event that tree block loses its owner tree's reference and do the
 270 * back refs conversion.
 271 *
 272 * When a tree block is COWed through a tree, there are four cases:
 273 *
 274 * The reference count of the block is one and the tree is the block's
 275 * owner tree. Nothing to do in this case.
 276 *
 277 * The reference count of the block is one and the tree is not the
 278 * block's owner tree. In this case, full back refs is used for pointers
 279 * in the block. Remove these full back refs, add implicit back refs for
 280 * every pointers in the new block.
 281 *
 282 * The reference count of the block is greater than one and the tree is
 283 * the block's owner tree. In this case, implicit back refs is used for
 284 * pointers in the block. Add full back refs for every pointers in the
 285 * block, increase lower level extents' reference counts. The original
 286 * implicit back refs are entailed to the new block.
 287 *
 288 * The reference count of the block is greater than one and the tree is
 289 * not the block's owner tree. Add implicit back refs for every pointer in
 290 * the new block, increase lower level extents' reference count.
 291 *
 292 * Back Reference Key composing:
 293 *
 294 * The key objectid corresponds to the first byte in the extent,
 295 * The key type is used to differentiate between types of back refs.
 296 * There are different meanings of the key offset for different types
 297 * of back refs.
 298 *
 299 * File extents can be referenced by:
 300 *
 301 * - multiple snapshots, subvolumes, or different generations in one subvol
 302 * - different files inside a single subvolume
 303 * - different offsets inside a file (bookend extents in file.c)
 304 *
 305 * The extent ref structure for the implicit back refs has fields for:
 306 *
 307 * - Objectid of the subvolume root
 308 * - objectid of the file holding the reference
 309 * - original offset in the file
 310 * - how many bookend extents
 311 *
 312 * The key offset for the implicit back refs is hash of the first
 313 * three fields.
 314 *
 315 * The extent ref structure for the full back refs has field for:
 316 *
 317 * - number of pointers in the tree leaf
 318 *
 319 * The key offset for the implicit back refs is the first byte of
 320 * the tree leaf
 321 *
 322 * When a file extent is allocated, The implicit back refs is used.
 323 * the fields are filled in:
 324 *
 325 *     (root_key.objectid, inode objectid, offset in file, 1)
 326 *
 327 * When a file extent is removed file truncation, we find the
 328 * corresponding implicit back refs and check the following fields:
 329 *
 330 *     (btrfs_header_owner(leaf), inode objectid, offset in file)
 331 *
 332 * Btree extents can be referenced by:
 333 *
 334 * - Different subvolumes
 335 *
 336 * Both the implicit back refs and the full back refs for tree blocks
 337 * only consist of key. The key offset for the implicit back refs is
 338 * objectid of block's owner tree. The key offset for the full back refs
 339 * is the first byte of parent block.
 340 *
 341 * When implicit back refs is used, information about the lowest key and
 342 * level of the tree block are required. These information are stored in
 343 * tree block info structure.
 344 */
 345
 346/*
 347 * is_data == BTRFS_REF_TYPE_BLOCK, tree block type is required,
 348 * is_data == BTRFS_REF_TYPE_DATA, data type is requiried,
 349 * is_data == BTRFS_REF_TYPE_ANY, either type is OK.
 350 */
 351int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
 352				     struct btrfs_extent_inline_ref *iref,
 353				     enum btrfs_inline_ref_type is_data)
 354{
 355	struct btrfs_fs_info *fs_info = eb->fs_info;
 356	int type = btrfs_extent_inline_ref_type(eb, iref);
 357	u64 offset = btrfs_extent_inline_ref_offset(eb, iref);
 358
 359	if (type == BTRFS_EXTENT_OWNER_REF_KEY) {
 360		ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));
 361		return type;
 362	}
 363
 364	if (type == BTRFS_TREE_BLOCK_REF_KEY ||
 365	    type == BTRFS_SHARED_BLOCK_REF_KEY ||
 366	    type == BTRFS_SHARED_DATA_REF_KEY ||
 367	    type == BTRFS_EXTENT_DATA_REF_KEY) {
 368		if (is_data == BTRFS_REF_TYPE_BLOCK) {
 369			if (type == BTRFS_TREE_BLOCK_REF_KEY)
 370				return type;
 371			if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
 372				ASSERT(fs_info);
 373				/*
 374				 * Every shared one has parent tree block,
 375				 * which must be aligned to sector size.
 376				 */
 377				if (offset && IS_ALIGNED(offset, fs_info->sectorsize))
 378					return type;
 379			}
 380		} else if (is_data == BTRFS_REF_TYPE_DATA) {
 381			if (type == BTRFS_EXTENT_DATA_REF_KEY)
 382				return type;
 383			if (type == BTRFS_SHARED_DATA_REF_KEY) {
 384				ASSERT(fs_info);
 385				/*
 386				 * Every shared one has parent tree block,
 387				 * which must be aligned to sector size.
 388				 */
 389				if (offset &&
 390				    IS_ALIGNED(offset, fs_info->sectorsize))
 391					return type;
 392			}
 393		} else {
 394			ASSERT(is_data == BTRFS_REF_TYPE_ANY);
 395			return type;
 
 396		}
 397	}
 
 398
 399	WARN_ON(1);
 400	btrfs_print_leaf(eb);
 401	btrfs_err(fs_info,
 402		  "eb %llu iref 0x%lx invalid extent inline ref type %d",
 403		  eb->start, (unsigned long)iref, type);
 
 
 
 
 
 
 404
 405	return BTRFS_REF_TYPE_INVALID;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 406}
 
 407
 408u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
 409{
 410	u32 high_crc = ~(u32)0;
 411	u32 low_crc = ~(u32)0;
 412	__le64 lenum;
 413
 414	lenum = cpu_to_le64(root_objectid);
 415	high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
 416	lenum = cpu_to_le64(owner);
 417	low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
 418	lenum = cpu_to_le64(offset);
 419	low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
 420
 421	return ((u64)high_crc << 31) ^ (u64)low_crc;
 422}
 423
 424static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
 425				     struct btrfs_extent_data_ref *ref)
 426{
 427	return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
 428				    btrfs_extent_data_ref_objectid(leaf, ref),
 429				    btrfs_extent_data_ref_offset(leaf, ref));
 430}
 431
 432static int match_extent_data_ref(struct extent_buffer *leaf,
 433				 struct btrfs_extent_data_ref *ref,
 434				 u64 root_objectid, u64 owner, u64 offset)
 435{
 436	if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
 437	    btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
 438	    btrfs_extent_data_ref_offset(leaf, ref) != offset)
 439		return 0;
 440	return 1;
 441}
 442
 443static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
 
 444					   struct btrfs_path *path,
 445					   u64 bytenr, u64 parent,
 446					   u64 root_objectid,
 447					   u64 owner, u64 offset)
 448{
 449	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);
 450	struct btrfs_key key;
 451	struct btrfs_extent_data_ref *ref;
 452	struct extent_buffer *leaf;
 453	u32 nritems;
 454	int ret;
 455	int recow;
 456	int err = -ENOENT;
 457
 458	key.objectid = bytenr;
 459	if (parent) {
 460		key.type = BTRFS_SHARED_DATA_REF_KEY;
 461		key.offset = parent;
 462	} else {
 463		key.type = BTRFS_EXTENT_DATA_REF_KEY;
 464		key.offset = hash_extent_data_ref(root_objectid,
 465						  owner, offset);
 466	}
 467again:
 468	recow = 0;
 469	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 470	if (ret < 0) {
 471		err = ret;
 472		goto fail;
 473	}
 474
 475	if (parent) {
 476		if (!ret)
 477			return 0;
 
 
 
 
 
 
 
 
 
 
 
 478		goto fail;
 479	}
 480
 481	leaf = path->nodes[0];
 482	nritems = btrfs_header_nritems(leaf);
 483	while (1) {
 484		if (path->slots[0] >= nritems) {
 485			ret = btrfs_next_leaf(root, path);
 486			if (ret < 0)
 487				err = ret;
 488			if (ret)
 489				goto fail;
 490
 491			leaf = path->nodes[0];
 492			nritems = btrfs_header_nritems(leaf);
 493			recow = 1;
 494		}
 495
 496		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 497		if (key.objectid != bytenr ||
 498		    key.type != BTRFS_EXTENT_DATA_REF_KEY)
 499			goto fail;
 500
 501		ref = btrfs_item_ptr(leaf, path->slots[0],
 502				     struct btrfs_extent_data_ref);
 503
 504		if (match_extent_data_ref(leaf, ref, root_objectid,
 505					  owner, offset)) {
 506			if (recow) {
 507				btrfs_release_path(path);
 508				goto again;
 509			}
 510			err = 0;
 511			break;
 512		}
 513		path->slots[0]++;
 514	}
 515fail:
 516	return err;
 517}
 518
 519static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
 
 520					   struct btrfs_path *path,
 521					   u64 bytenr, u64 parent,
 522					   u64 root_objectid, u64 owner,
 523					   u64 offset, int refs_to_add)
 524{
 525	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);
 526	struct btrfs_key key;
 527	struct extent_buffer *leaf;
 528	u32 size;
 529	u32 num_refs;
 530	int ret;
 531
 532	key.objectid = bytenr;
 533	if (parent) {
 534		key.type = BTRFS_SHARED_DATA_REF_KEY;
 535		key.offset = parent;
 536		size = sizeof(struct btrfs_shared_data_ref);
 537	} else {
 538		key.type = BTRFS_EXTENT_DATA_REF_KEY;
 539		key.offset = hash_extent_data_ref(root_objectid,
 540						  owner, offset);
 541		size = sizeof(struct btrfs_extent_data_ref);
 542	}
 543
 544	ret = btrfs_insert_empty_item(trans, root, path, &key, size);
 545	if (ret && ret != -EEXIST)
 546		goto fail;
 547
 548	leaf = path->nodes[0];
 549	if (parent) {
 550		struct btrfs_shared_data_ref *ref;
 551		ref = btrfs_item_ptr(leaf, path->slots[0],
 552				     struct btrfs_shared_data_ref);
 553		if (ret == 0) {
 554			btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
 555		} else {
 556			num_refs = btrfs_shared_data_ref_count(leaf, ref);
 557			num_refs += refs_to_add;
 558			btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
 559		}
 560	} else {
 561		struct btrfs_extent_data_ref *ref;
 562		while (ret == -EEXIST) {
 563			ref = btrfs_item_ptr(leaf, path->slots[0],
 564					     struct btrfs_extent_data_ref);
 565			if (match_extent_data_ref(leaf, ref, root_objectid,
 566						  owner, offset))
 567				break;
 568			btrfs_release_path(path);
 569			key.offset++;
 570			ret = btrfs_insert_empty_item(trans, root, path, &key,
 571						      size);
 572			if (ret && ret != -EEXIST)
 573				goto fail;
 574
 575			leaf = path->nodes[0];
 576		}
 577		ref = btrfs_item_ptr(leaf, path->slots[0],
 578				     struct btrfs_extent_data_ref);
 579		if (ret == 0) {
 580			btrfs_set_extent_data_ref_root(leaf, ref,
 581						       root_objectid);
 582			btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
 583			btrfs_set_extent_data_ref_offset(leaf, ref, offset);
 584			btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
 585		} else {
 586			num_refs = btrfs_extent_data_ref_count(leaf, ref);
 587			num_refs += refs_to_add;
 588			btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
 589		}
 590	}
 591	btrfs_mark_buffer_dirty(trans, leaf);
 592	ret = 0;
 593fail:
 594	btrfs_release_path(path);
 595	return ret;
 596}
 597
 598static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
 599					   struct btrfs_root *root,
 600					   struct btrfs_path *path,
 601					   int refs_to_drop)
 602{
 603	struct btrfs_key key;
 604	struct btrfs_extent_data_ref *ref1 = NULL;
 605	struct btrfs_shared_data_ref *ref2 = NULL;
 606	struct extent_buffer *leaf;
 607	u32 num_refs = 0;
 608	int ret = 0;
 609
 610	leaf = path->nodes[0];
 611	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 612
 613	if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
 614		ref1 = btrfs_item_ptr(leaf, path->slots[0],
 615				      struct btrfs_extent_data_ref);
 616		num_refs = btrfs_extent_data_ref_count(leaf, ref1);
 617	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
 618		ref2 = btrfs_item_ptr(leaf, path->slots[0],
 619				      struct btrfs_shared_data_ref);
 620		num_refs = btrfs_shared_data_ref_count(leaf, ref2);
 
 
 
 
 
 
 
 621	} else {
 622		btrfs_err(trans->fs_info,
 623			  "unrecognized backref key (%llu %u %llu)",
 624			  key.objectid, key.type, key.offset);
 625		btrfs_abort_transaction(trans, -EUCLEAN);
 626		return -EUCLEAN;
 627	}
 628
 629	BUG_ON(num_refs < refs_to_drop);
 630	num_refs -= refs_to_drop;
 631
 632	if (num_refs == 0) {
 633		ret = btrfs_del_item(trans, root, path);
 634	} else {
 635		if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
 636			btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
 637		else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
 638			btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
 639		btrfs_mark_buffer_dirty(trans, leaf);
 
 
 
 
 
 
 
 
 640	}
 641	return ret;
 642}
 643
 644static noinline u32 extent_data_ref_count(struct btrfs_path *path,
 
 645					  struct btrfs_extent_inline_ref *iref)
 646{
 647	struct btrfs_key key;
 648	struct extent_buffer *leaf;
 649	struct btrfs_extent_data_ref *ref1;
 650	struct btrfs_shared_data_ref *ref2;
 651	u32 num_refs = 0;
 652	int type;
 653
 654	leaf = path->nodes[0];
 655	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 656
 657	if (iref) {
 658		/*
 659		 * If type is invalid, we should have bailed out earlier than
 660		 * this call.
 661		 */
 662		type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_DATA);
 663		ASSERT(type != BTRFS_REF_TYPE_INVALID);
 664		if (type == BTRFS_EXTENT_DATA_REF_KEY) {
 665			ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
 666			num_refs = btrfs_extent_data_ref_count(leaf, ref1);
 667		} else {
 668			ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
 669			num_refs = btrfs_shared_data_ref_count(leaf, ref2);
 670		}
 671	} else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
 672		ref1 = btrfs_item_ptr(leaf, path->slots[0],
 673				      struct btrfs_extent_data_ref);
 674		num_refs = btrfs_extent_data_ref_count(leaf, ref1);
 675	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
 676		ref2 = btrfs_item_ptr(leaf, path->slots[0],
 677				      struct btrfs_shared_data_ref);
 678		num_refs = btrfs_shared_data_ref_count(leaf, ref2);
 
 
 
 
 
 
 
 679	} else {
 680		WARN_ON(1);
 681	}
 682	return num_refs;
 683}
 684
 685static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
 
 686					  struct btrfs_path *path,
 687					  u64 bytenr, u64 parent,
 688					  u64 root_objectid)
 689{
 690	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);
 691	struct btrfs_key key;
 692	int ret;
 693
 694	key.objectid = bytenr;
 695	if (parent) {
 696		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
 697		key.offset = parent;
 698	} else {
 699		key.type = BTRFS_TREE_BLOCK_REF_KEY;
 700		key.offset = root_objectid;
 701	}
 702
 703	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 704	if (ret > 0)
 705		ret = -ENOENT;
 
 
 
 
 
 
 
 
 
 706	return ret;
 707}
 708
 709static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
 
 710					  struct btrfs_path *path,
 711					  u64 bytenr, u64 parent,
 712					  u64 root_objectid)
 713{
 714	struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr);
 715	struct btrfs_key key;
 716	int ret;
 717
 718	key.objectid = bytenr;
 719	if (parent) {
 720		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
 721		key.offset = parent;
 722	} else {
 723		key.type = BTRFS_TREE_BLOCK_REF_KEY;
 724		key.offset = root_objectid;
 725	}
 726
 727	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
 728	btrfs_release_path(path);
 729	return ret;
 730}
 731
 732static inline int extent_ref_type(u64 parent, u64 owner)
 733{
 734	int type;
 735	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
 736		if (parent > 0)
 737			type = BTRFS_SHARED_BLOCK_REF_KEY;
 738		else
 739			type = BTRFS_TREE_BLOCK_REF_KEY;
 740	} else {
 741		if (parent > 0)
 742			type = BTRFS_SHARED_DATA_REF_KEY;
 743		else
 744			type = BTRFS_EXTENT_DATA_REF_KEY;
 745	}
 746	return type;
 747}
 748
 749static int find_next_key(struct btrfs_path *path, int level,
 750			 struct btrfs_key *key)
 751
 752{
 753	for (; level < BTRFS_MAX_LEVEL; level++) {
 754		if (!path->nodes[level])
 755			break;
 756		if (path->slots[level] + 1 >=
 757		    btrfs_header_nritems(path->nodes[level]))
 758			continue;
 759		if (level == 0)
 760			btrfs_item_key_to_cpu(path->nodes[level], key,
 761					      path->slots[level] + 1);
 762		else
 763			btrfs_node_key_to_cpu(path->nodes[level], key,
 764					      path->slots[level] + 1);
 765		return 0;
 766	}
 767	return 1;
 768}
 769
 770/*
 771 * look for inline back ref. if back ref is found, *ref_ret is set
 772 * to the address of inline back ref, and 0 is returned.
 773 *
 774 * if back ref isn't found, *ref_ret is set to the address where it
 775 * should be inserted, and -ENOENT is returned.
 776 *
 777 * if insert is true and there are too many inline back refs, the path
 778 * points to the extent item, and -EAGAIN is returned.
 779 *
 780 * NOTE: inline back refs are ordered in the same way that back ref
 781 *	 items in the tree are ordered.
 782 */
 783static noinline_for_stack
 784int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
 
 785				 struct btrfs_path *path,
 786				 struct btrfs_extent_inline_ref **ref_ret,
 787				 u64 bytenr, u64 num_bytes,
 788				 u64 parent, u64 root_objectid,
 789				 u64 owner, u64 offset, int insert)
 790{
 791	struct btrfs_fs_info *fs_info = trans->fs_info;
 792	struct btrfs_root *root = btrfs_extent_root(fs_info, bytenr);
 793	struct btrfs_key key;
 794	struct extent_buffer *leaf;
 795	struct btrfs_extent_item *ei;
 796	struct btrfs_extent_inline_ref *iref;
 797	u64 flags;
 798	u64 item_size;
 799	unsigned long ptr;
 800	unsigned long end;
 801	int extra_size;
 802	int type;
 803	int want;
 804	int ret;
 805	bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);
 806	int needed;
 807
 808	key.objectid = bytenr;
 809	key.type = BTRFS_EXTENT_ITEM_KEY;
 810	key.offset = num_bytes;
 811
 812	want = extent_ref_type(parent, owner);
 813	if (insert) {
 814		extra_size = btrfs_extent_inline_ref_size(want);
 815		path->search_for_extension = 1;
 816		path->keep_locks = 1;
 817	} else
 818		extra_size = -1;
 819
 820	/*
 821	 * Owner is our level, so we can just add one to get the level for the
 822	 * block we are interested in.
 823	 */
 824	if (skinny_metadata && owner < BTRFS_FIRST_FREE_OBJECTID) {
 825		key.type = BTRFS_METADATA_ITEM_KEY;
 826		key.offset = owner;
 827	}
 828
 829again:
 830	ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
 831	if (ret < 0)
 
 832		goto out;
 833
 834	/*
 835	 * We may be a newly converted file system which still has the old fat
 836	 * extent entries for metadata, so try and see if we have one of those.
 837	 */
 838	if (ret > 0 && skinny_metadata) {
 839		skinny_metadata = false;
 840		if (path->slots[0]) {
 841			path->slots[0]--;
 842			btrfs_item_key_to_cpu(path->nodes[0], &key,
 843					      path->slots[0]);
 844			if (key.objectid == bytenr &&
 845			    key.type == BTRFS_EXTENT_ITEM_KEY &&
 846			    key.offset == num_bytes)
 847				ret = 0;
 848		}
 849		if (ret) {
 850			key.objectid = bytenr;
 851			key.type = BTRFS_EXTENT_ITEM_KEY;
 852			key.offset = num_bytes;
 853			btrfs_release_path(path);
 854			goto again;
 855		}
 856	}
 857
 858	if (ret && !insert) {
 859		ret = -ENOENT;
 860		goto out;
 861	} else if (WARN_ON(ret)) {
 862		btrfs_print_leaf(path->nodes[0]);
 863		btrfs_err(fs_info,
 864"extent item not found for insert, bytenr %llu num_bytes %llu parent %llu root_objectid %llu owner %llu offset %llu",
 865			  bytenr, num_bytes, parent, root_objectid, owner,
 866			  offset);
 867		ret = -EUCLEAN;
 868		goto out;
 869	}
 
 870
 871	leaf = path->nodes[0];
 872	item_size = btrfs_item_size(leaf, path->slots[0]);
 873	if (unlikely(item_size < sizeof(*ei))) {
 874		ret = -EUCLEAN;
 875		btrfs_err(fs_info,
 876			  "unexpected extent item size, has %llu expect >= %zu",
 877			  item_size, sizeof(*ei));
 878		btrfs_abort_transaction(trans, ret);
 879		goto out;
 
 
 
 
 
 
 
 880	}
 
 
 881
 882	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
 883	flags = btrfs_extent_flags(leaf, ei);
 884
 885	ptr = (unsigned long)(ei + 1);
 886	end = (unsigned long)ei + item_size;
 887
 888	if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK && !skinny_metadata) {
 889		ptr += sizeof(struct btrfs_tree_block_info);
 890		BUG_ON(ptr > end);
 
 
 891	}
 892
 893	if (owner >= BTRFS_FIRST_FREE_OBJECTID)
 894		needed = BTRFS_REF_TYPE_DATA;
 895	else
 896		needed = BTRFS_REF_TYPE_BLOCK;
 897
 898	ret = -ENOENT;
 899	while (ptr < end) {
 900		iref = (struct btrfs_extent_inline_ref *)ptr;
 901		type = btrfs_get_extent_inline_ref_type(leaf, iref, needed);
 902		if (type == BTRFS_EXTENT_OWNER_REF_KEY) {
 903			ASSERT(btrfs_fs_incompat(fs_info, SIMPLE_QUOTA));
 904			ptr += btrfs_extent_inline_ref_size(type);
 905			continue;
 906		}
 907		if (type == BTRFS_REF_TYPE_INVALID) {
 908			ret = -EUCLEAN;
 909			goto out;
 910		}
 911
 
 912		if (want < type)
 913			break;
 914		if (want > type) {
 915			ptr += btrfs_extent_inline_ref_size(type);
 916			continue;
 917		}
 918
 919		if (type == BTRFS_EXTENT_DATA_REF_KEY) {
 920			struct btrfs_extent_data_ref *dref;
 921			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
 922			if (match_extent_data_ref(leaf, dref, root_objectid,
 923						  owner, offset)) {
 924				ret = 0;
 925				break;
 926			}
 927			if (hash_extent_data_ref_item(leaf, dref) <
 928			    hash_extent_data_ref(root_objectid, owner, offset))
 929				break;
 930		} else {
 931			u64 ref_offset;
 932			ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
 933			if (parent > 0) {
 934				if (parent == ref_offset) {
 935					ret = 0;
 936					break;
 937				}
 938				if (ref_offset < parent)
 939					break;
 940			} else {
 941				if (root_objectid == ref_offset) {
 942					ret = 0;
 943					break;
 944				}
 945				if (ref_offset < root_objectid)
 946					break;
 947			}
 948		}
 949		ptr += btrfs_extent_inline_ref_size(type);
 950	}
 951
 952	if (unlikely(ptr > end)) {
 953		ret = -EUCLEAN;
 954		btrfs_print_leaf(path->nodes[0]);
 955		btrfs_crit(fs_info,
 956"overrun extent record at slot %d while looking for inline extent for root %llu owner %llu offset %llu parent %llu",
 957			   path->slots[0], root_objectid, owner, offset, parent);
 958		goto out;
 959	}
 960
 961	if (ret == -ENOENT && insert) {
 962		if (item_size + extra_size >=
 963		    BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
 964			ret = -EAGAIN;
 965			goto out;
 966		}
 967		/*
 968		 * To add new inline back ref, we have to make sure
 969		 * there is no corresponding back ref item.
 970		 * For simplicity, we just do not add new inline back
 971		 * ref if there is any kind of item for this block
 972		 */
 973		if (find_next_key(path, 0, &key) == 0 &&
 974		    key.objectid == bytenr &&
 975		    key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
 976			ret = -EAGAIN;
 977			goto out;
 978		}
 979	}
 980	*ref_ret = (struct btrfs_extent_inline_ref *)ptr;
 981out:
 982	if (insert) {
 983		path->keep_locks = 0;
 984		path->search_for_extension = 0;
 985		btrfs_unlock_up_safe(path, 1);
 986	}
 987	return ret;
 988}
 989
 990/*
 991 * helper to add new inline back ref
 992 */
 993static noinline_for_stack
 994void setup_inline_extent_backref(struct btrfs_trans_handle *trans,
 
 995				 struct btrfs_path *path,
 996				 struct btrfs_extent_inline_ref *iref,
 997				 u64 parent, u64 root_objectid,
 998				 u64 owner, u64 offset, int refs_to_add,
 999				 struct btrfs_delayed_extent_op *extent_op)
1000{
1001	struct extent_buffer *leaf;
1002	struct btrfs_extent_item *ei;
1003	unsigned long ptr;
1004	unsigned long end;
1005	unsigned long item_offset;
1006	u64 refs;
1007	int size;
1008	int type;
1009
1010	leaf = path->nodes[0];
1011	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1012	item_offset = (unsigned long)iref - (unsigned long)ei;
1013
1014	type = extent_ref_type(parent, owner);
1015	size = btrfs_extent_inline_ref_size(type);
1016
1017	btrfs_extend_item(trans, path, size);
1018
1019	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1020	refs = btrfs_extent_refs(leaf, ei);
1021	refs += refs_to_add;
1022	btrfs_set_extent_refs(leaf, ei, refs);
1023	if (extent_op)
1024		__run_delayed_extent_op(extent_op, leaf, ei);
1025
1026	ptr = (unsigned long)ei + item_offset;
1027	end = (unsigned long)ei + btrfs_item_size(leaf, path->slots[0]);
1028	if (ptr < end - size)
1029		memmove_extent_buffer(leaf, ptr + size, ptr,
1030				      end - size - ptr);
1031
1032	iref = (struct btrfs_extent_inline_ref *)ptr;
1033	btrfs_set_extent_inline_ref_type(leaf, iref, type);
1034	if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1035		struct btrfs_extent_data_ref *dref;
1036		dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1037		btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
1038		btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
1039		btrfs_set_extent_data_ref_offset(leaf, dref, offset);
1040		btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
1041	} else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1042		struct btrfs_shared_data_ref *sref;
1043		sref = (struct btrfs_shared_data_ref *)(iref + 1);
1044		btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
1045		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1046	} else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
1047		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1048	} else {
1049		btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
1050	}
1051	btrfs_mark_buffer_dirty(trans, leaf);
1052}
1053
1054static int lookup_extent_backref(struct btrfs_trans_handle *trans,
 
1055				 struct btrfs_path *path,
1056				 struct btrfs_extent_inline_ref **ref_ret,
1057				 u64 bytenr, u64 num_bytes, u64 parent,
1058				 u64 root_objectid, u64 owner, u64 offset)
1059{
1060	int ret;
1061
1062	ret = lookup_inline_extent_backref(trans, path, ref_ret, bytenr,
1063					   num_bytes, parent, root_objectid,
1064					   owner, offset, 0);
1065	if (ret != -ENOENT)
1066		return ret;
1067
1068	btrfs_release_path(path);
1069	*ref_ret = NULL;
1070
1071	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1072		ret = lookup_tree_block_ref(trans, path, bytenr, parent,
1073					    root_objectid);
1074	} else {
1075		ret = lookup_extent_data_ref(trans, path, bytenr, parent,
1076					     root_objectid, owner, offset);
1077	}
1078	return ret;
1079}
1080
1081/*
1082 * helper to update/remove inline back ref
1083 */
1084static noinline_for_stack int update_inline_extent_backref(
1085				  struct btrfs_trans_handle *trans,
 
1086				  struct btrfs_path *path,
1087				  struct btrfs_extent_inline_ref *iref,
1088				  int refs_to_mod,
1089				  struct btrfs_delayed_extent_op *extent_op)
1090{
1091	struct extent_buffer *leaf = path->nodes[0];
1092	struct btrfs_fs_info *fs_info = leaf->fs_info;
1093	struct btrfs_extent_item *ei;
1094	struct btrfs_extent_data_ref *dref = NULL;
1095	struct btrfs_shared_data_ref *sref = NULL;
1096	unsigned long ptr;
1097	unsigned long end;
1098	u32 item_size;
1099	int size;
1100	int type;
1101	u64 refs;
1102
 
1103	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1104	refs = btrfs_extent_refs(leaf, ei);
1105	if (unlikely(refs_to_mod < 0 && refs + refs_to_mod <= 0)) {
1106		struct btrfs_key key;
1107		u32 extent_size;
1108
1109		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1110		if (key.type == BTRFS_METADATA_ITEM_KEY)
1111			extent_size = fs_info->nodesize;
1112		else
1113			extent_size = key.offset;
1114		btrfs_print_leaf(leaf);
1115		btrfs_err(fs_info,
1116	"invalid refs_to_mod for extent %llu num_bytes %u, has %d expect >= -%llu",
1117			  key.objectid, extent_size, refs_to_mod, refs);
1118		return -EUCLEAN;
1119	}
1120	refs += refs_to_mod;
1121	btrfs_set_extent_refs(leaf, ei, refs);
1122	if (extent_op)
1123		__run_delayed_extent_op(extent_op, leaf, ei);
1124
1125	type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_ANY);
1126	/*
1127	 * Function btrfs_get_extent_inline_ref_type() has already printed
1128	 * error messages.
1129	 */
1130	if (unlikely(type == BTRFS_REF_TYPE_INVALID))
1131		return -EUCLEAN;
1132
1133	if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1134		dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1135		refs = btrfs_extent_data_ref_count(leaf, dref);
1136	} else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1137		sref = (struct btrfs_shared_data_ref *)(iref + 1);
1138		refs = btrfs_shared_data_ref_count(leaf, sref);
1139	} else {
1140		refs = 1;
1141		/*
1142		 * For tree blocks we can only drop one ref for it, and tree
1143		 * blocks should not have refs > 1.
1144		 *
1145		 * Furthermore if we're inserting a new inline backref, we
1146		 * won't reach this path either. That would be
1147		 * setup_inline_extent_backref().
1148		 */
1149		if (unlikely(refs_to_mod != -1)) {
1150			struct btrfs_key key;
1151
1152			btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1153
1154			btrfs_print_leaf(leaf);
1155			btrfs_err(fs_info,
1156			"invalid refs_to_mod for tree block %llu, has %d expect -1",
1157				  key.objectid, refs_to_mod);
1158			return -EUCLEAN;
1159		}
1160	}
1161
1162	if (unlikely(refs_to_mod < 0 && refs < -refs_to_mod)) {
1163		struct btrfs_key key;
1164		u32 extent_size;
1165
1166		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1167		if (key.type == BTRFS_METADATA_ITEM_KEY)
1168			extent_size = fs_info->nodesize;
1169		else
1170			extent_size = key.offset;
1171		btrfs_print_leaf(leaf);
1172		btrfs_err(fs_info,
1173"invalid refs_to_mod for backref entry, iref %lu extent %llu num_bytes %u, has %d expect >= -%llu",
1174			  (unsigned long)iref, key.objectid, extent_size,
1175			  refs_to_mod, refs);
1176		return -EUCLEAN;
1177	}
1178	refs += refs_to_mod;
1179
1180	if (refs > 0) {
1181		if (type == BTRFS_EXTENT_DATA_REF_KEY)
1182			btrfs_set_extent_data_ref_count(leaf, dref, refs);
1183		else
1184			btrfs_set_shared_data_ref_count(leaf, sref, refs);
1185	} else {
1186		size =  btrfs_extent_inline_ref_size(type);
1187		item_size = btrfs_item_size(leaf, path->slots[0]);
1188		ptr = (unsigned long)iref;
1189		end = (unsigned long)ei + item_size;
1190		if (ptr + size < end)
1191			memmove_extent_buffer(leaf, ptr, ptr + size,
1192					      end - ptr - size);
1193		item_size -= size;
1194		btrfs_truncate_item(trans, path, item_size, 1);
1195	}
1196	btrfs_mark_buffer_dirty(trans, leaf);
1197	return 0;
1198}
1199
1200static noinline_for_stack
1201int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
 
1202				 struct btrfs_path *path,
1203				 u64 bytenr, u64 num_bytes, u64 parent,
1204				 u64 root_objectid, u64 owner,
1205				 u64 offset, int refs_to_add,
1206				 struct btrfs_delayed_extent_op *extent_op)
1207{
1208	struct btrfs_extent_inline_ref *iref;
1209	int ret;
1210
1211	ret = lookup_inline_extent_backref(trans, path, &iref, bytenr,
1212					   num_bytes, parent, root_objectid,
1213					   owner, offset, 1);
1214	if (ret == 0) {
1215		/*
1216		 * We're adding refs to a tree block we already own, this
1217		 * should not happen at all.
1218		 */
1219		if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1220			btrfs_print_leaf(path->nodes[0]);
1221			btrfs_crit(trans->fs_info,
1222"adding refs to an existing tree ref, bytenr %llu num_bytes %llu root_objectid %llu slot %u",
1223				   bytenr, num_bytes, root_objectid, path->slots[0]);
1224			return -EUCLEAN;
1225		}
1226		ret = update_inline_extent_backref(trans, path, iref,
1227						   refs_to_add, extent_op);
1228	} else if (ret == -ENOENT) {
1229		setup_inline_extent_backref(trans, path, iref, parent,
1230					    root_objectid, owner, offset,
1231					    refs_to_add, extent_op);
1232		ret = 0;
1233	}
1234	return ret;
1235}
1236
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1237static int remove_extent_backref(struct btrfs_trans_handle *trans,
1238				 struct btrfs_root *root,
1239				 struct btrfs_path *path,
1240				 struct btrfs_extent_inline_ref *iref,
1241				 int refs_to_drop, int is_data)
1242{
1243	int ret = 0;
1244
1245	BUG_ON(!is_data && refs_to_drop != 1);
1246	if (iref)
1247		ret = update_inline_extent_backref(trans, path, iref,
1248						   -refs_to_drop, NULL);
1249	else if (is_data)
1250		ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
1251	else
1252		ret = btrfs_del_item(trans, root, path);
1253	return ret;
1254}
1255
1256static int btrfs_issue_discard(struct block_device *bdev, u64 start, u64 len,
1257			       u64 *discarded_bytes)
1258{
1259	int j, ret = 0;
1260	u64 bytes_left, end;
1261	u64 aligned_start = ALIGN(start, 1 << SECTOR_SHIFT);
1262
1263	/* Adjust the range to be aligned to 512B sectors if necessary. */
1264	if (start != aligned_start) {
1265		len -= aligned_start - start;
1266		len = round_down(len, 1 << SECTOR_SHIFT);
1267		start = aligned_start;
1268	}
1269
1270	*discarded_bytes = 0;
1271
1272	if (!len)
1273		return 0;
1274
1275	end = start + len;
1276	bytes_left = len;
1277
1278	/* Skip any superblocks on this device. */
1279	for (j = 0; j < BTRFS_SUPER_MIRROR_MAX; j++) {
1280		u64 sb_start = btrfs_sb_offset(j);
1281		u64 sb_end = sb_start + BTRFS_SUPER_INFO_SIZE;
1282		u64 size = sb_start - start;
1283
1284		if (!in_range(sb_start, start, bytes_left) &&
1285		    !in_range(sb_end, start, bytes_left) &&
1286		    !in_range(start, sb_start, BTRFS_SUPER_INFO_SIZE))
1287			continue;
1288
1289		/*
1290		 * Superblock spans beginning of range.  Adjust start and
1291		 * try again.
1292		 */
1293		if (sb_start <= start) {
1294			start += sb_end - start;
1295			if (start > end) {
1296				bytes_left = 0;
1297				break;
1298			}
1299			bytes_left = end - start;
1300			continue;
1301		}
1302
1303		if (size) {
1304			ret = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,
1305						   size >> SECTOR_SHIFT,
1306						   GFP_NOFS);
1307			if (!ret)
1308				*discarded_bytes += size;
1309			else if (ret != -EOPNOTSUPP)
1310				return ret;
1311		}
1312
1313		start = sb_end;
1314		if (start > end) {
1315			bytes_left = 0;
1316			break;
1317		}
1318		bytes_left = end - start;
1319	}
1320
1321	if (bytes_left) {
1322		ret = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,
1323					   bytes_left >> SECTOR_SHIFT,
1324					   GFP_NOFS);
1325		if (!ret)
1326			*discarded_bytes += bytes_left;
1327	}
1328	return ret;
1329}
1330
1331static int do_discard_extent(struct btrfs_discard_stripe *stripe, u64 *bytes)
 
1332{
1333	struct btrfs_device *dev = stripe->dev;
1334	struct btrfs_fs_info *fs_info = dev->fs_info;
1335	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
1336	u64 phys = stripe->physical;
1337	u64 len = stripe->length;
1338	u64 discarded = 0;
1339	int ret = 0;
1340
1341	/* Zone reset on a zoned filesystem */
1342	if (btrfs_can_zone_reset(dev, phys, len)) {
1343		u64 src_disc;
1344
1345		ret = btrfs_reset_device_zone(dev, phys, len, &discarded);
1346		if (ret)
1347			goto out;
1348
1349		if (!btrfs_dev_replace_is_ongoing(dev_replace) ||
1350		    dev != dev_replace->srcdev)
1351			goto out;
1352
1353		src_disc = discarded;
1354
1355		/* Send to replace target as well */
1356		ret = btrfs_reset_device_zone(dev_replace->tgtdev, phys, len,
1357					      &discarded);
1358		discarded += src_disc;
1359	} else if (bdev_max_discard_sectors(stripe->dev->bdev)) {
1360		ret = btrfs_issue_discard(dev->bdev, phys, len, &discarded);
1361	} else {
1362		ret = 0;
1363		*bytes = 0;
1364	}
1365
1366out:
1367	*bytes = discarded;
1368	return ret;
1369}
1370
1371int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
1372			 u64 num_bytes, u64 *actual_bytes)
1373{
1374	int ret = 0;
1375	u64 discarded_bytes = 0;
1376	u64 end = bytenr + num_bytes;
1377	u64 cur = bytenr;
1378
1379	/*
1380	 * Avoid races with device replace and make sure the devices in the
1381	 * stripes don't go away while we are discarding.
1382	 */
1383	btrfs_bio_counter_inc_blocked(fs_info);
1384	while (cur < end) {
1385		struct btrfs_discard_stripe *stripes;
1386		unsigned int num_stripes;
1387		int i;
1388
1389		num_bytes = end - cur;
1390		stripes = btrfs_map_discard(fs_info, cur, &num_bytes, &num_stripes);
1391		if (IS_ERR(stripes)) {
1392			ret = PTR_ERR(stripes);
1393			if (ret == -EOPNOTSUPP)
1394				ret = 0;
1395			break;
1396		}
1397
1398		for (i = 0; i < num_stripes; i++) {
1399			struct btrfs_discard_stripe *stripe = stripes + i;
1400			u64 bytes;
1401
1402			if (!stripe->dev->bdev) {
1403				ASSERT(btrfs_test_opt(fs_info, DEGRADED));
1404				continue;
1405			}
1406
1407			if (!test_bit(BTRFS_DEV_STATE_WRITEABLE,
1408					&stripe->dev->dev_state))
1409				continue;
 
 
 
 
1410
1411			ret = do_discard_extent(stripe, &bytes);
1412			if (ret) {
1413				/*
1414				 * Keep going if discard is not supported by the
1415				 * device.
1416				 */
1417				if (ret != -EOPNOTSUPP)
1418					break;
1419				ret = 0;
1420			} else {
1421				discarded_bytes += bytes;
1422			}
1423		}
1424		kfree(stripes);
1425		if (ret)
1426			break;
1427		cur += num_bytes;
1428	}
1429	btrfs_bio_counter_dec(fs_info);
1430	if (actual_bytes)
1431		*actual_bytes = discarded_bytes;
 
 
1432	return ret;
1433}
1434
1435/* Can return -ENOMEM */
1436int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1437			 struct btrfs_ref *generic_ref)
 
 
1438{
1439	struct btrfs_fs_info *fs_info = trans->fs_info;
1440	int ret;
 
1441
1442	ASSERT(generic_ref->type != BTRFS_REF_NOT_SET &&
1443	       generic_ref->action);
1444	BUG_ON(generic_ref->type == BTRFS_REF_METADATA &&
1445	       generic_ref->tree_ref.ref_root == BTRFS_TREE_LOG_OBJECTID);
1446
1447	if (generic_ref->type == BTRFS_REF_METADATA)
1448		ret = btrfs_add_delayed_tree_ref(trans, generic_ref, NULL);
1449	else
1450		ret = btrfs_add_delayed_data_ref(trans, generic_ref, 0);
1451
1452	btrfs_ref_tree_mod(fs_info, generic_ref);
1453
 
 
 
 
 
 
 
 
 
 
 
1454	return ret;
1455}
1456
1457/*
1458 * Insert backreference for a given extent.
1459 *
1460 * The counterpart is in __btrfs_free_extent(), with examples and more details
1461 * how it works.
1462 *
1463 * @trans:	    Handle of transaction
1464 *
1465 * @node:	    The delayed ref node used to get the bytenr/length for
1466 *		    extent whose references are incremented.
1467 *
1468 * @parent:	    If this is a shared extent (BTRFS_SHARED_DATA_REF_KEY/
1469 *		    BTRFS_SHARED_BLOCK_REF_KEY) then it holds the logical
1470 *		    bytenr of the parent block. Since new extents are always
1471 *		    created with indirect references, this will only be the case
1472 *		    when relocating a shared extent. In that case, root_objectid
1473 *		    will be BTRFS_TREE_RELOC_OBJECTID. Otherwise, parent must
1474 *		    be 0
1475 *
1476 * @root_objectid:  The id of the root where this modification has originated,
1477 *		    this can be either one of the well-known metadata trees or
1478 *		    the subvolume id which references this extent.
1479 *
1480 * @owner:	    For data extents it is the inode number of the owning file.
1481 *		    For metadata extents this parameter holds the level in the
1482 *		    tree of the extent.
1483 *
1484 * @offset:	    For metadata extents the offset is ignored and is currently
1485 *		    always passed as 0. For data extents it is the fileoffset
1486 *		    this extent belongs to.
1487 *
1488 * @extent_op       Pointer to a structure, holding information necessary when
1489 *                  updating a tree block's flags
1490 *
1491 */
1492static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1493				  struct btrfs_delayed_ref_node *node,
 
1494				  u64 parent, u64 root_objectid,
1495				  u64 owner, u64 offset,
1496				  struct btrfs_delayed_extent_op *extent_op)
1497{
1498	struct btrfs_path *path;
1499	struct extent_buffer *leaf;
1500	struct btrfs_extent_item *item;
1501	struct btrfs_key key;
1502	u64 bytenr = node->bytenr;
1503	u64 num_bytes = node->num_bytes;
1504	u64 refs;
1505	int refs_to_add = node->ref_mod;
1506	int ret;
 
1507
1508	path = btrfs_alloc_path();
1509	if (!path)
1510		return -ENOMEM;
1511
 
 
1512	/* this will setup the path even if it fails to insert the back ref */
1513	ret = insert_inline_extent_backref(trans, path, bytenr, num_bytes,
1514					   parent, root_objectid, owner,
1515					   offset, refs_to_add, extent_op);
1516	if ((ret < 0 && ret != -EAGAIN) || !ret)
 
1517		goto out;
1518
1519	/*
1520	 * Ok we had -EAGAIN which means we didn't have space to insert and
1521	 * inline extent ref, so just update the reference count and add a
1522	 * normal backref.
1523	 */
1524	leaf = path->nodes[0];
1525	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1526	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1527	refs = btrfs_extent_refs(leaf, item);
1528	btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
1529	if (extent_op)
1530		__run_delayed_extent_op(extent_op, leaf, item);
1531
1532	btrfs_mark_buffer_dirty(trans, leaf);
1533	btrfs_release_path(path);
1534
1535	/* now insert the actual backref */
1536	if (owner < BTRFS_FIRST_FREE_OBJECTID)
1537		ret = insert_tree_block_ref(trans, path, bytenr, parent,
1538					    root_objectid);
1539	else
1540		ret = insert_extent_data_ref(trans, path, bytenr, parent,
1541					     root_objectid, owner, offset,
1542					     refs_to_add);
1543
 
 
 
 
1544	if (ret)
1545		btrfs_abort_transaction(trans, ret);
1546out:
1547	btrfs_free_path(path);
1548	return ret;
1549}
1550
1551static void free_head_ref_squota_rsv(struct btrfs_fs_info *fs_info,
1552				     struct btrfs_delayed_ref_head *href)
1553{
1554	u64 root = href->owning_root;
1555
1556	/*
1557	 * Don't check must_insert_reserved, as this is called from contexts
1558	 * where it has already been unset.
1559	 */
1560	if (btrfs_qgroup_mode(fs_info) != BTRFS_QGROUP_MODE_SIMPLE ||
1561	    !href->is_data || !is_fstree(root))
1562		return;
1563
1564	btrfs_qgroup_free_refroot(fs_info, root, href->reserved_bytes,
1565				  BTRFS_QGROUP_RSV_DATA);
1566}
1567
1568static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
1569				struct btrfs_delayed_ref_head *href,
1570				struct btrfs_delayed_ref_node *node,
1571				struct btrfs_delayed_extent_op *extent_op,
1572				bool insert_reserved)
1573{
1574	int ret = 0;
1575	struct btrfs_delayed_data_ref *ref;
 
1576	u64 parent = 0;
 
1577	u64 flags = 0;
1578
1579	ref = btrfs_delayed_node_to_data_ref(node);
1580	trace_run_delayed_data_ref(trans->fs_info, node, ref, node->action);
 
1581
 
1582	if (node->type == BTRFS_SHARED_DATA_REF_KEY)
1583		parent = ref->parent;
 
 
1584
1585	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1586		struct btrfs_key key;
1587		struct btrfs_squota_delta delta = {
1588			.root = href->owning_root,
1589			.num_bytes = node->num_bytes,
1590			.is_data = true,
1591			.is_inc	= true,
1592			.generation = trans->transid,
1593		};
1594
1595		if (extent_op)
1596			flags |= extent_op->flags_to_set;
1597
1598		key.objectid = node->bytenr;
1599		key.type = BTRFS_EXTENT_ITEM_KEY;
1600		key.offset = node->num_bytes;
1601
1602		ret = alloc_reserved_file_extent(trans, parent, ref->root,
1603						 flags, ref->objectid,
1604						 ref->offset, &key,
1605						 node->ref_mod, href->owning_root);
1606		free_head_ref_squota_rsv(trans->fs_info, href);
1607		if (!ret)
1608			ret = btrfs_record_squota_delta(trans->fs_info, &delta);
1609	} else if (node->action == BTRFS_ADD_DELAYED_REF) {
1610		ret = __btrfs_inc_extent_ref(trans, node, parent, ref->root,
1611					     ref->objectid, ref->offset,
 
 
1612					     extent_op);
1613	} else if (node->action == BTRFS_DROP_DELAYED_REF) {
1614		ret = __btrfs_free_extent(trans, href, node, parent,
1615					  ref->root, ref->objectid,
1616					  ref->offset, extent_op);
 
 
1617	} else {
1618		BUG();
1619	}
1620	return ret;
1621}
1622
1623static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
1624				    struct extent_buffer *leaf,
1625				    struct btrfs_extent_item *ei)
1626{
1627	u64 flags = btrfs_extent_flags(leaf, ei);
1628	if (extent_op->update_flags) {
1629		flags |= extent_op->flags_to_set;
1630		btrfs_set_extent_flags(leaf, ei, flags);
1631	}
1632
1633	if (extent_op->update_key) {
1634		struct btrfs_tree_block_info *bi;
1635		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
1636		bi = (struct btrfs_tree_block_info *)(ei + 1);
1637		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
1638	}
1639}
1640
1641static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
1642				 struct btrfs_delayed_ref_head *head,
 
1643				 struct btrfs_delayed_extent_op *extent_op)
1644{
1645	struct btrfs_fs_info *fs_info = trans->fs_info;
1646	struct btrfs_root *root;
1647	struct btrfs_key key;
1648	struct btrfs_path *path;
1649	struct btrfs_extent_item *ei;
1650	struct extent_buffer *leaf;
1651	u32 item_size;
1652	int ret;
1653	int metadata = 1;
1654
1655	if (TRANS_ABORTED(trans))
1656		return 0;
1657
1658	if (!btrfs_fs_incompat(fs_info, SKINNY_METADATA))
1659		metadata = 0;
1660
1661	path = btrfs_alloc_path();
1662	if (!path)
1663		return -ENOMEM;
1664
1665	key.objectid = head->bytenr;
1666
1667	if (metadata) {
1668		key.type = BTRFS_METADATA_ITEM_KEY;
1669		key.offset = extent_op->level;
1670	} else {
1671		key.type = BTRFS_EXTENT_ITEM_KEY;
1672		key.offset = head->num_bytes;
1673	}
1674
1675	root = btrfs_extent_root(fs_info, key.objectid);
1676again:
1677	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
 
1678	if (ret < 0) {
 
1679		goto out;
1680	} else if (ret > 0) {
1681		if (metadata) {
1682			if (path->slots[0] > 0) {
1683				path->slots[0]--;
1684				btrfs_item_key_to_cpu(path->nodes[0], &key,
1685						      path->slots[0]);
1686				if (key.objectid == head->bytenr &&
1687				    key.type == BTRFS_EXTENT_ITEM_KEY &&
1688				    key.offset == head->num_bytes)
1689					ret = 0;
1690			}
1691			if (ret > 0) {
1692				btrfs_release_path(path);
1693				metadata = 0;
1694
1695				key.objectid = head->bytenr;
1696				key.offset = head->num_bytes;
1697				key.type = BTRFS_EXTENT_ITEM_KEY;
1698				goto again;
1699			}
1700		} else {
1701			ret = -EUCLEAN;
1702			btrfs_err(fs_info,
1703		  "missing extent item for extent %llu num_bytes %llu level %d",
1704				  head->bytenr, head->num_bytes, extent_op->level);
1705			goto out;
1706		}
1707	}
1708
1709	leaf = path->nodes[0];
1710	item_size = btrfs_item_size(leaf, path->slots[0]);
1711
1712	if (unlikely(item_size < sizeof(*ei))) {
1713		ret = -EUCLEAN;
1714		btrfs_err(fs_info,
1715			  "unexpected extent item size, has %u expect >= %zu",
1716			  item_size, sizeof(*ei));
1717		btrfs_abort_transaction(trans, ret);
1718		goto out;
1719	}
1720
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1721	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1722	__run_delayed_extent_op(extent_op, leaf, ei);
1723
1724	btrfs_mark_buffer_dirty(trans, leaf);
1725out:
1726	btrfs_free_path(path);
1727	return ret;
1728}
1729
1730static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
1731				struct btrfs_delayed_ref_head *href,
1732				struct btrfs_delayed_ref_node *node,
1733				struct btrfs_delayed_extent_op *extent_op,
1734				bool insert_reserved)
1735{
1736	int ret = 0;
1737	struct btrfs_fs_info *fs_info = trans->fs_info;
1738	struct btrfs_delayed_tree_ref *ref;
 
1739	u64 parent = 0;
1740	u64 ref_root = 0;
1741
1742	ref = btrfs_delayed_node_to_tree_ref(node);
1743	trace_run_delayed_tree_ref(trans->fs_info, node, ref, node->action);
 
1744
 
1745	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
1746		parent = ref->parent;
1747	ref_root = ref->root;
 
1748
1749	if (unlikely(node->ref_mod != 1)) {
1750		btrfs_err(trans->fs_info,
1751	"btree block %llu has %d references rather than 1: action %d ref_root %llu parent %llu",
1752			  node->bytenr, node->ref_mod, node->action, ref_root,
1753			  parent);
1754		return -EUCLEAN;
1755	}
1756	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1757		struct btrfs_squota_delta delta = {
1758			.root = href->owning_root,
1759			.num_bytes = fs_info->nodesize,
1760			.is_data = false,
1761			.is_inc = true,
1762			.generation = trans->transid,
1763		};
1764
1765		BUG_ON(!extent_op || !extent_op->update_flags);
1766		ret = alloc_reserved_tree_block(trans, node, extent_op);
1767		if (!ret)
1768			btrfs_record_squota_delta(fs_info, &delta);
1769	} else if (node->action == BTRFS_ADD_DELAYED_REF) {
1770		ret = __btrfs_inc_extent_ref(trans, node, parent, ref_root,
1771					     ref->level, 0, extent_op);
 
1772	} else if (node->action == BTRFS_DROP_DELAYED_REF) {
1773		ret = __btrfs_free_extent(trans, href, node, parent, ref_root,
1774					  ref->level, 0, extent_op);
 
1775	} else {
1776		BUG();
1777	}
1778	return ret;
1779}
1780
1781/* helper function to actually process a single delayed ref entry */
1782static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
1783			       struct btrfs_delayed_ref_head *href,
1784			       struct btrfs_delayed_ref_node *node,
1785			       struct btrfs_delayed_extent_op *extent_op,
1786			       bool insert_reserved)
1787{
1788	int ret = 0;
1789
1790	if (TRANS_ABORTED(trans)) {
 
 
 
 
 
 
 
 
 
 
 
 
1791		if (insert_reserved) {
1792			btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);
1793			free_head_ref_squota_rsv(trans->fs_info, href);
 
 
 
 
 
1794		}
1795		return 0;
 
1796	}
1797
1798	if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
1799	    node->type == BTRFS_SHARED_BLOCK_REF_KEY)
1800		ret = run_delayed_tree_ref(trans, href, node, extent_op,
1801					   insert_reserved);
1802	else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
1803		 node->type == BTRFS_SHARED_DATA_REF_KEY)
1804		ret = run_delayed_data_ref(trans, href, node, extent_op,
1805					   insert_reserved);
1806	else if (node->type == BTRFS_EXTENT_OWNER_REF_KEY)
1807		ret = 0;
1808	else
1809		BUG();
1810	if (ret && insert_reserved)
1811		btrfs_pin_extent(trans, node->bytenr, node->num_bytes, 1);
1812	if (ret < 0)
1813		btrfs_err(trans->fs_info,
1814"failed to run delayed ref for logical %llu num_bytes %llu type %u action %u ref_mod %d: %d",
1815			  node->bytenr, node->num_bytes, node->type,
1816			  node->action, node->ref_mod, ret);
1817	return ret;
1818}
1819
1820static inline struct btrfs_delayed_ref_node *
1821select_delayed_ref(struct btrfs_delayed_ref_head *head)
1822{
 
1823	struct btrfs_delayed_ref_node *ref;
1824
1825	if (RB_EMPTY_ROOT(&head->ref_tree.rb_root))
1826		return NULL;
1827
1828	/*
1829	 * Select a delayed ref of type BTRFS_ADD_DELAYED_REF first.
1830	 * This is to prevent a ref count from going down to zero, which deletes
1831	 * the extent item from the extent tree, when there still are references
1832	 * to add, which would fail because they would not find the extent item.
1833	 */
1834	if (!list_empty(&head->ref_add_list))
1835		return list_first_entry(&head->ref_add_list,
1836				struct btrfs_delayed_ref_node, add_list);
1837
1838	ref = rb_entry(rb_first_cached(&head->ref_tree),
1839		       struct btrfs_delayed_ref_node, ref_node);
1840	ASSERT(list_empty(&ref->add_list));
1841	return ref;
1842}
1843
1844static void unselect_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs,
1845				      struct btrfs_delayed_ref_head *head)
1846{
1847	spin_lock(&delayed_refs->lock);
1848	head->processing = false;
1849	delayed_refs->num_heads_ready++;
1850	spin_unlock(&delayed_refs->lock);
1851	btrfs_delayed_ref_unlock(head);
1852}
1853
1854static struct btrfs_delayed_extent_op *cleanup_extent_op(
1855				struct btrfs_delayed_ref_head *head)
1856{
1857	struct btrfs_delayed_extent_op *extent_op = head->extent_op;
1858
1859	if (!extent_op)
1860		return NULL;
1861
1862	if (head->must_insert_reserved) {
1863		head->extent_op = NULL;
1864		btrfs_free_delayed_extent_op(extent_op);
1865		return NULL;
1866	}
1867	return extent_op;
1868}
1869
1870static int run_and_cleanup_extent_op(struct btrfs_trans_handle *trans,
1871				     struct btrfs_delayed_ref_head *head)
1872{
1873	struct btrfs_delayed_extent_op *extent_op;
1874	int ret;
1875
1876	extent_op = cleanup_extent_op(head);
1877	if (!extent_op)
1878		return 0;
1879	head->extent_op = NULL;
1880	spin_unlock(&head->lock);
1881	ret = run_delayed_extent_op(trans, head, extent_op);
1882	btrfs_free_delayed_extent_op(extent_op);
1883	return ret ? ret : 1;
1884}
1885
1886u64 btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,
1887				  struct btrfs_delayed_ref_root *delayed_refs,
1888				  struct btrfs_delayed_ref_head *head)
1889{
1890	u64 ret = 0;
1891
1892	/*
1893	 * We had csum deletions accounted for in our delayed refs rsv, we need
1894	 * to drop the csum leaves for this update from our delayed_refs_rsv.
 
1895	 */
1896	if (head->total_ref_mod < 0 && head->is_data) {
1897		int nr_csums;
1898
1899		spin_lock(&delayed_refs->lock);
1900		delayed_refs->pending_csums -= head->num_bytes;
1901		spin_unlock(&delayed_refs->lock);
1902		nr_csums = btrfs_csum_bytes_to_leaves(fs_info, head->num_bytes);
1903
1904		btrfs_delayed_refs_rsv_release(fs_info, 0, nr_csums);
1905
1906		ret = btrfs_calc_delayed_ref_csum_bytes(fs_info, nr_csums);
1907	}
1908	/* must_insert_reserved can be set only if we didn't run the head ref. */
1909	if (head->must_insert_reserved)
1910		free_head_ref_squota_rsv(fs_info, head);
1911
1912	return ret;
1913}
1914
1915static int cleanup_ref_head(struct btrfs_trans_handle *trans,
1916			    struct btrfs_delayed_ref_head *head,
1917			    u64 *bytes_released)
 
 
 
 
1918{
1919
1920	struct btrfs_fs_info *fs_info = trans->fs_info;
1921	struct btrfs_delayed_ref_root *delayed_refs;
 
 
 
1922	int ret;
 
 
1923
1924	delayed_refs = &trans->transaction->delayed_refs;
 
 
 
 
 
1925
1926	ret = run_and_cleanup_extent_op(trans, head);
1927	if (ret < 0) {
1928		unselect_delayed_ref_head(delayed_refs, head);
1929		btrfs_debug(fs_info, "run_delayed_extent_op returned %d", ret);
1930		return ret;
1931	} else if (ret) {
1932		return ret;
1933	}
1934
1935	/*
1936	 * Need to drop our head ref lock and re-acquire the delayed ref lock
1937	 * and then re-check to make sure nobody got added.
1938	 */
1939	spin_unlock(&head->lock);
1940	spin_lock(&delayed_refs->lock);
1941	spin_lock(&head->lock);
1942	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root) || head->extent_op) {
1943		spin_unlock(&head->lock);
1944		spin_unlock(&delayed_refs->lock);
1945		return 1;
1946	}
1947	btrfs_delete_ref_head(delayed_refs, head);
1948	spin_unlock(&head->lock);
1949	spin_unlock(&delayed_refs->lock);
1950
1951	if (head->must_insert_reserved) {
1952		btrfs_pin_extent(trans, head->bytenr, head->num_bytes, 1);
1953		if (head->is_data) {
1954			struct btrfs_root *csum_root;
1955
1956			csum_root = btrfs_csum_root(fs_info, head->bytenr);
1957			ret = btrfs_del_csums(trans, csum_root, head->bytenr,
1958					      head->num_bytes);
 
 
 
 
 
 
 
 
1959		}
1960	}
1961
1962	*bytes_released += btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);
1963
1964	trace_run_delayed_ref_head(fs_info, head, 0);
1965	btrfs_delayed_ref_unlock(head);
1966	btrfs_put_delayed_ref_head(head);
1967	return ret;
1968}
1969
1970static struct btrfs_delayed_ref_head *btrfs_obtain_ref_head(
1971					struct btrfs_trans_handle *trans)
1972{
1973	struct btrfs_delayed_ref_root *delayed_refs =
1974		&trans->transaction->delayed_refs;
1975	struct btrfs_delayed_ref_head *head = NULL;
1976	int ret;
 
 
 
 
 
 
 
 
1977
1978	spin_lock(&delayed_refs->lock);
1979	head = btrfs_select_ref_head(delayed_refs);
1980	if (!head) {
1981		spin_unlock(&delayed_refs->lock);
1982		return head;
1983	}
1984
1985	/*
1986	 * Grab the lock that says we are going to process all the refs for
1987	 * this head
1988	 */
1989	ret = btrfs_delayed_ref_lock(delayed_refs, head);
1990	spin_unlock(&delayed_refs->lock);
1991
1992	/*
1993	 * We may have dropped the spin lock to get the head mutex lock, and
1994	 * that might have given someone else time to free the head.  If that's
1995	 * true, it has been removed from our list and we can move on.
1996	 */
1997	if (ret == -EAGAIN)
1998		head = ERR_PTR(-EAGAIN);
1999
2000	return head;
2001}
 
 
2002
2003static int btrfs_run_delayed_refs_for_head(struct btrfs_trans_handle *trans,
2004					   struct btrfs_delayed_ref_head *locked_ref,
2005					   u64 *bytes_released)
2006{
2007	struct btrfs_fs_info *fs_info = trans->fs_info;
2008	struct btrfs_delayed_ref_root *delayed_refs;
2009	struct btrfs_delayed_extent_op *extent_op;
2010	struct btrfs_delayed_ref_node *ref;
2011	bool must_insert_reserved;
2012	int ret;
2013
2014	delayed_refs = &trans->transaction->delayed_refs;
 
 
2015
2016	lockdep_assert_held(&locked_ref->mutex);
2017	lockdep_assert_held(&locked_ref->lock);
 
 
 
2018
2019	while ((ref = select_delayed_ref(locked_ref))) {
2020		if (ref->seq &&
2021		    btrfs_check_delayed_seq(fs_info, ref->seq)) {
2022			spin_unlock(&locked_ref->lock);
2023			unselect_delayed_ref_head(delayed_refs, locked_ref);
2024			return -EAGAIN;
2025		}
2026
2027		rb_erase_cached(&ref->ref_node, &locked_ref->ref_tree);
2028		RB_CLEAR_NODE(&ref->ref_node);
2029		if (!list_empty(&ref->add_list))
2030			list_del(&ref->add_list);
2031		/*
2032		 * When we play the delayed ref, also correct the ref_mod on
2033		 * head
2034		 */
2035		switch (ref->action) {
2036		case BTRFS_ADD_DELAYED_REF:
2037		case BTRFS_ADD_DELAYED_EXTENT:
2038			locked_ref->ref_mod -= ref->ref_mod;
2039			break;
2040		case BTRFS_DROP_DELAYED_REF:
2041			locked_ref->ref_mod += ref->ref_mod;
2042			break;
2043		default:
2044			WARN_ON(1);
2045		}
2046		atomic_dec(&delayed_refs->num_entries);
2047
 
 
 
2048		/*
2049		 * Record the must_insert_reserved flag before we drop the
2050		 * spin lock.
 
 
2051		 */
2052		must_insert_reserved = locked_ref->must_insert_reserved;
2053		/*
2054		 * Unsetting this on the head ref relinquishes ownership of
2055		 * the rsv_bytes, so it is critical that every possible code
2056		 * path from here forward frees all reserves including qgroup
2057		 * reserve.
2058		 */
2059		locked_ref->must_insert_reserved = false;
2060
2061		extent_op = locked_ref->extent_op;
2062		locked_ref->extent_op = NULL;
2063		spin_unlock(&locked_ref->lock);
2064
2065		ret = run_one_delayed_ref(trans, locked_ref, ref, extent_op,
2066					  must_insert_reserved);
2067		btrfs_delayed_refs_rsv_release(fs_info, 1, 0);
2068		*bytes_released += btrfs_calc_delayed_ref_bytes(fs_info, 1);
2069
2070		btrfs_free_delayed_extent_op(extent_op);
 
 
 
2071		if (ret) {
2072			unselect_delayed_ref_head(delayed_refs, locked_ref);
2073			btrfs_put_delayed_ref(ref);
2074			return ret;
2075		}
2076
2077		btrfs_put_delayed_ref(ref);
 
 
 
 
2078		cond_resched();
2079
2080		spin_lock(&locked_ref->lock);
2081		btrfs_merge_delayed_refs(fs_info, delayed_refs, locked_ref);
2082	}
 
 
2083
2084	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
2085}
2086
2087/*
2088 * Returns 0 on success or if called with an already aborted transaction.
2089 * Returns -ENOMEM or -EIO on failure and will abort the transaction.
 
 
 
 
 
 
2090 */
2091static noinline int __btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2092					     u64 min_bytes)
2093{
2094	struct btrfs_fs_info *fs_info = trans->fs_info;
2095	struct btrfs_delayed_ref_root *delayed_refs;
2096	struct btrfs_delayed_ref_head *locked_ref = NULL;
 
 
2097	int ret;
2098	unsigned long count = 0;
2099	unsigned long max_count = 0;
2100	u64 bytes_processed = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
2101
2102	delayed_refs = &trans->transaction->delayed_refs;
2103	if (min_bytes == 0) {
2104		max_count = delayed_refs->num_heads_ready;
2105		min_bytes = U64_MAX;
 
 
 
 
2106	}
 
 
 
 
2107
2108	do {
2109		if (!locked_ref) {
2110			locked_ref = btrfs_obtain_ref_head(trans);
2111			if (IS_ERR_OR_NULL(locked_ref)) {
2112				if (PTR_ERR(locked_ref) == -EAGAIN) {
2113					continue;
2114				} else {
2115					break;
2116				}
2117			}
2118			count++;
2119		}
2120		/*
2121		 * We need to try and merge add/drops of the same ref since we
2122		 * can run into issues with relocate dropping the implicit ref
2123		 * and then it being added back again before the drop can
2124		 * finish.  If we merged anything we need to re-loop so we can
2125		 * get a good ref.
2126		 * Or we can get node references of the same type that weren't
2127		 * merged when created due to bumps in the tree mod seq, and
2128		 * we need to merge them to prevent adding an inline extent
2129		 * backref before dropping it (triggering a BUG_ON at
2130		 * insert_inline_extent_backref()).
2131		 */
2132		spin_lock(&locked_ref->lock);
2133		btrfs_merge_delayed_refs(fs_info, delayed_refs, locked_ref);
 
 
 
2134
2135		ret = btrfs_run_delayed_refs_for_head(trans, locked_ref, &bytes_processed);
2136		if (ret < 0 && ret != -EAGAIN) {
2137			/*
2138			 * Error, btrfs_run_delayed_refs_for_head already
2139			 * unlocked everything so just bail out
2140			 */
2141			return ret;
2142		} else if (!ret) {
2143			/*
2144			 * Success, perform the usual cleanup of a processed
2145			 * head
2146			 */
2147			ret = cleanup_ref_head(trans, locked_ref, &bytes_processed);
2148			if (ret > 0 ) {
2149				/* We dropped our lock, we need to loop. */
2150				ret = 0;
2151				continue;
2152			} else if (ret) {
2153				return ret;
 
 
 
2154			}
2155		}
2156
2157		/*
2158		 * Either success case or btrfs_run_delayed_refs_for_head
2159		 * returned -EAGAIN, meaning we need to select another head
2160		 */
2161
2162		locked_ref = NULL;
2163		cond_resched();
2164	} while ((min_bytes != U64_MAX && bytes_processed < min_bytes) ||
2165		 (max_count > 0 && count < max_count) ||
2166		 locked_ref);
2167
2168	return 0;
2169}
2170
2171#ifdef SCRAMBLE_DELAYED_REFS
2172/*
2173 * Normally delayed refs get processed in ascending bytenr order. This
2174 * correlates in most cases to the order added. To expose dependencies on this
2175 * order, we start to process the tree in the middle instead of the beginning
2176 */
2177static u64 find_middle(struct rb_root *root)
2178{
2179	struct rb_node *n = root->rb_node;
2180	struct btrfs_delayed_ref_node *entry;
2181	int alt = 1;
2182	u64 middle;
2183	u64 first = 0, last = 0;
2184
2185	n = rb_first(root);
2186	if (n) {
2187		entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
2188		first = entry->bytenr;
2189	}
2190	n = rb_last(root);
2191	if (n) {
2192		entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
2193		last = entry->bytenr;
2194	}
2195	n = root->rb_node;
2196
2197	while (n) {
2198		entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);
2199		WARN_ON(!entry->in_tree);
2200
2201		middle = entry->bytenr;
2202
2203		if (alt)
2204			n = n->rb_left;
2205		else
2206			n = n->rb_right;
2207
2208		alt = 1 - alt;
 
 
 
2209	}
2210	return middle;
2211}
2212#endif
2213
2214/*
2215 * Start processing the delayed reference count updates and extent insertions
2216 * we have queued up so far.
2217 *
2218 * @trans:	Transaction handle.
2219 * @min_bytes:	How many bytes of delayed references to process. After this
2220 *		many bytes we stop processing delayed references if there are
2221 *		any more. If 0 it means to run all existing delayed references,
2222 *		but not new ones added after running all existing ones.
2223 *		Use (u64)-1 (U64_MAX) to run all existing delayed references
2224 *		plus any new ones that are added.
2225 *
2226 * Returns 0 on success or if called with an aborted transaction
2227 * Returns <0 on error and aborts the transaction
2228 */
2229int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, u64 min_bytes)
2230{
2231	struct btrfs_fs_info *fs_info = trans->fs_info;
2232	struct btrfs_delayed_ref_root *delayed_refs;
2233	int ret;
2234
2235	/* We'll clean this up in btrfs_cleanup_transaction */
2236	if (TRANS_ABORTED(trans))
2237		return 0;
 
 
2238
2239	if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags))
2240		return 0;
 
 
 
2241
2242	delayed_refs = &trans->transaction->delayed_refs;
2243again:
2244#ifdef SCRAMBLE_DELAYED_REFS
2245	delayed_refs->run_delayed_start = find_middle(&delayed_refs->root);
2246#endif
2247	ret = __btrfs_run_delayed_refs(trans, min_bytes);
2248	if (ret < 0) {
2249		btrfs_abort_transaction(trans, ret);
2250		return ret;
2251	}
2252
2253	if (min_bytes == U64_MAX) {
2254		btrfs_create_pending_block_groups(trans);
 
 
 
 
 
2255
2256		spin_lock(&delayed_refs->lock);
2257		if (RB_EMPTY_ROOT(&delayed_refs->href_root.rb_root)) {
2258			spin_unlock(&delayed_refs->lock);
2259			return 0;
 
2260		}
2261		spin_unlock(&delayed_refs->lock);
2262
2263		cond_resched();
2264		goto again;
2265	}
2266
 
2267	return 0;
2268}
2269
2270int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2271				struct extent_buffer *eb, u64 flags)
 
 
2272{
2273	struct btrfs_delayed_extent_op *extent_op;
2274	int level = btrfs_header_level(eb);
2275	int ret;
2276
2277	extent_op = btrfs_alloc_delayed_extent_op();
2278	if (!extent_op)
2279		return -ENOMEM;
2280
2281	extent_op->flags_to_set = flags;
2282	extent_op->update_flags = true;
2283	extent_op->update_key = false;
2284	extent_op->level = level;
2285
2286	ret = btrfs_add_delayed_extent_op(trans, eb->start, eb->len, extent_op);
 
2287	if (ret)
2288		btrfs_free_delayed_extent_op(extent_op);
2289	return ret;
2290}
2291
2292static noinline int check_delayed_ref(struct btrfs_root *root,
 
2293				      struct btrfs_path *path,
2294				      u64 objectid, u64 offset, u64 bytenr)
2295{
2296	struct btrfs_delayed_ref_head *head;
2297	struct btrfs_delayed_ref_node *ref;
2298	struct btrfs_delayed_data_ref *data_ref;
2299	struct btrfs_delayed_ref_root *delayed_refs;
2300	struct btrfs_transaction *cur_trans;
2301	struct rb_node *node;
2302	int ret = 0;
2303
2304	spin_lock(&root->fs_info->trans_lock);
2305	cur_trans = root->fs_info->running_transaction;
2306	if (cur_trans)
2307		refcount_inc(&cur_trans->use_count);
2308	spin_unlock(&root->fs_info->trans_lock);
2309	if (!cur_trans)
2310		return 0;
2311
2312	delayed_refs = &cur_trans->delayed_refs;
2313	spin_lock(&delayed_refs->lock);
2314	head = btrfs_find_delayed_ref_head(delayed_refs, bytenr);
2315	if (!head) {
2316		spin_unlock(&delayed_refs->lock);
2317		btrfs_put_transaction(cur_trans);
2318		return 0;
2319	}
2320
2321	if (!mutex_trylock(&head->mutex)) {
2322		if (path->nowait) {
2323			spin_unlock(&delayed_refs->lock);
2324			btrfs_put_transaction(cur_trans);
2325			return -EAGAIN;
2326		}
2327
2328		refcount_inc(&head->refs);
2329		spin_unlock(&delayed_refs->lock);
2330
2331		btrfs_release_path(path);
2332
2333		/*
2334		 * Mutex was contended, block until it's released and let
2335		 * caller try again
2336		 */
2337		mutex_lock(&head->mutex);
2338		mutex_unlock(&head->mutex);
2339		btrfs_put_delayed_ref_head(head);
2340		btrfs_put_transaction(cur_trans);
2341		return -EAGAIN;
2342	}
2343	spin_unlock(&delayed_refs->lock);
2344
2345	spin_lock(&head->lock);
2346	/*
2347	 * XXX: We should replace this with a proper search function in the
2348	 * future.
2349	 */
2350	for (node = rb_first_cached(&head->ref_tree); node;
2351	     node = rb_next(node)) {
2352		ref = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);
2353		/* If it's a shared ref we know a cross reference exists */
2354		if (ref->type != BTRFS_EXTENT_DATA_REF_KEY) {
2355			ret = 1;
2356			break;
2357		}
2358
2359		data_ref = btrfs_delayed_node_to_data_ref(ref);
2360
2361		/*
2362		 * If our ref doesn't match the one we're currently looking at
2363		 * then we have a cross reference.
2364		 */
2365		if (data_ref->root != root->root_key.objectid ||
2366		    data_ref->objectid != objectid ||
2367		    data_ref->offset != offset) {
2368			ret = 1;
2369			break;
2370		}
 
 
 
 
2371	}
2372	spin_unlock(&head->lock);
 
 
 
 
 
 
2373	mutex_unlock(&head->mutex);
2374	btrfs_put_transaction(cur_trans);
 
2375	return ret;
2376}
2377
2378static noinline int check_committed_ref(struct btrfs_root *root,
 
2379					struct btrfs_path *path,
2380					u64 objectid, u64 offset, u64 bytenr,
2381					bool strict)
2382{
2383	struct btrfs_fs_info *fs_info = root->fs_info;
2384	struct btrfs_root *extent_root = btrfs_extent_root(fs_info, bytenr);
2385	struct extent_buffer *leaf;
2386	struct btrfs_extent_data_ref *ref;
2387	struct btrfs_extent_inline_ref *iref;
2388	struct btrfs_extent_item *ei;
2389	struct btrfs_key key;
2390	u32 item_size;
2391	u32 expected_size;
2392	int type;
2393	int ret;
2394
2395	key.objectid = bytenr;
2396	key.offset = (u64)-1;
2397	key.type = BTRFS_EXTENT_ITEM_KEY;
2398
2399	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2400	if (ret < 0)
2401		goto out;
2402	BUG_ON(ret == 0); /* Corruption */
2403
2404	ret = -ENOENT;
2405	if (path->slots[0] == 0)
2406		goto out;
2407
2408	path->slots[0]--;
2409	leaf = path->nodes[0];
2410	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2411
2412	if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
2413		goto out;
2414
2415	ret = 1;
2416	item_size = btrfs_item_size(leaf, path->slots[0]);
2417	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2418	expected_size = sizeof(*ei) + btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY);
2419
2420	/* No inline refs; we need to bail before checking for owner ref. */
2421	if (item_size == sizeof(*ei))
2422		goto out;
2423
2424	/* Check for an owner ref; skip over it to the real inline refs. */
2425	iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2426	type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_DATA);
2427	if (btrfs_fs_incompat(fs_info, SIMPLE_QUOTA) && type == BTRFS_EXTENT_OWNER_REF_KEY) {
2428		expected_size += btrfs_extent_inline_ref_size(BTRFS_EXTENT_OWNER_REF_KEY);
2429		iref = (struct btrfs_extent_inline_ref *)(iref + 1);
2430	}
 
 
2431
2432	/* If extent item has more than 1 inline ref then it's shared */
2433	if (item_size != expected_size)
2434		goto out;
2435
2436	/*
2437	 * If extent created before last snapshot => it's shared unless the
2438	 * snapshot has been deleted. Use the heuristic if strict is false.
2439	 */
2440	if (!strict &&
2441	    (btrfs_extent_generation(leaf, ei) <=
2442	     btrfs_root_last_snapshot(&root->root_item)))
2443		goto out;
2444
2445	/* If this extent has SHARED_DATA_REF then it's shared */
2446	type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_DATA);
2447	if (type != BTRFS_EXTENT_DATA_REF_KEY)
2448		goto out;
2449
2450	ref = (struct btrfs_extent_data_ref *)(&iref->offset);
2451	if (btrfs_extent_refs(leaf, ei) !=
2452	    btrfs_extent_data_ref_count(leaf, ref) ||
2453	    btrfs_extent_data_ref_root(leaf, ref) !=
2454	    root->root_key.objectid ||
2455	    btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
2456	    btrfs_extent_data_ref_offset(leaf, ref) != offset)
2457		goto out;
2458
2459	ret = 0;
2460out:
2461	return ret;
2462}
2463
2464int btrfs_cross_ref_exist(struct btrfs_root *root, u64 objectid, u64 offset,
2465			  u64 bytenr, bool strict, struct btrfs_path *path)
 
2466{
 
2467	int ret;
 
 
 
 
 
2468
2469	do {
2470		ret = check_committed_ref(root, path, objectid,
2471					  offset, bytenr, strict);
2472		if (ret && ret != -ENOENT)
2473			goto out;
2474
2475		ret = check_delayed_ref(root, path, objectid, offset, bytenr);
2476	} while (ret == -EAGAIN);
 
2477
 
 
 
 
 
 
 
2478out:
2479	btrfs_release_path(path);
2480	if (btrfs_is_data_reloc_root(root))
2481		WARN_ON(ret > 0);
2482	return ret;
2483}
2484
2485static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
2486			   struct btrfs_root *root,
2487			   struct extent_buffer *buf,
2488			   int full_backref, int inc)
2489{
2490	struct btrfs_fs_info *fs_info = root->fs_info;
2491	u64 bytenr;
2492	u64 num_bytes;
2493	u64 parent;
2494	u64 ref_root;
2495	u32 nritems;
2496	struct btrfs_key key;
2497	struct btrfs_file_extent_item *fi;
2498	struct btrfs_ref generic_ref = { 0 };
2499	bool for_reloc = btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC);
2500	int i;
2501	int action;
2502	int level;
2503	int ret = 0;
2504
2505	if (btrfs_is_testing(fs_info))
2506		return 0;
2507
2508	ref_root = btrfs_header_owner(buf);
2509	nritems = btrfs_header_nritems(buf);
2510	level = btrfs_header_level(buf);
2511
2512	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && level == 0)
2513		return 0;
2514
 
 
 
 
 
2515	if (full_backref)
2516		parent = buf->start;
2517	else
2518		parent = 0;
2519	if (inc)
2520		action = BTRFS_ADD_DELAYED_REF;
2521	else
2522		action = BTRFS_DROP_DELAYED_REF;
2523
2524	for (i = 0; i < nritems; i++) {
2525		if (level == 0) {
2526			btrfs_item_key_to_cpu(buf, &key, i);
2527			if (key.type != BTRFS_EXTENT_DATA_KEY)
2528				continue;
2529			fi = btrfs_item_ptr(buf, i,
2530					    struct btrfs_file_extent_item);
2531			if (btrfs_file_extent_type(buf, fi) ==
2532			    BTRFS_FILE_EXTENT_INLINE)
2533				continue;
2534			bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2535			if (bytenr == 0)
2536				continue;
2537
2538			num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
2539			key.offset -= btrfs_file_extent_offset(buf, fi);
2540			btrfs_init_generic_ref(&generic_ref, action, bytenr,
2541					       num_bytes, parent, ref_root);
2542			btrfs_init_data_ref(&generic_ref, ref_root, key.objectid,
2543					    key.offset, root->root_key.objectid,
2544					    for_reloc);
2545			if (inc)
2546				ret = btrfs_inc_extent_ref(trans, &generic_ref);
2547			else
2548				ret = btrfs_free_extent(trans, &generic_ref);
2549			if (ret)
2550				goto fail;
2551		} else {
2552			bytenr = btrfs_node_blockptr(buf, i);
2553			num_bytes = fs_info->nodesize;
2554			/* We don't know the owning_root, use 0. */
2555			btrfs_init_generic_ref(&generic_ref, action, bytenr,
2556					       num_bytes, parent, 0);
2557			btrfs_init_tree_ref(&generic_ref, level - 1, ref_root,
2558					    root->root_key.objectid, for_reloc);
2559			if (inc)
2560				ret = btrfs_inc_extent_ref(trans, &generic_ref);
2561			else
2562				ret = btrfs_free_extent(trans, &generic_ref);
2563			if (ret)
2564				goto fail;
2565		}
2566	}
2567	return 0;
2568fail:
2569	return ret;
2570}
2571
2572int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2573		  struct extent_buffer *buf, int full_backref)
2574{
2575	return __btrfs_mod_ref(trans, root, buf, full_backref, 1);
2576}
2577
2578int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2579		  struct extent_buffer *buf, int full_backref)
2580{
2581	return __btrfs_mod_ref(trans, root, buf, full_backref, 0);
2582}
2583
2584static u64 get_alloc_profile_by_root(struct btrfs_root *root, int data)
 
 
 
2585{
2586	struct btrfs_fs_info *fs_info = root->fs_info;
2587	u64 flags;
2588	u64 ret;
 
2589
2590	if (data)
2591		flags = BTRFS_BLOCK_GROUP_DATA;
2592	else if (root == fs_info->chunk_root)
2593		flags = BTRFS_BLOCK_GROUP_SYSTEM;
2594	else
2595		flags = BTRFS_BLOCK_GROUP_METADATA;
 
 
 
 
 
 
 
 
 
 
2596
2597	ret = btrfs_get_alloc_profile(fs_info, flags);
2598	return ret;
2599}
2600
2601static u64 first_logical_byte(struct btrfs_fs_info *fs_info)
 
 
2602{
2603	struct rb_node *leftmost;
2604	u64 bytenr = 0;
 
 
 
 
 
 
 
 
 
 
 
2605
2606	read_lock(&fs_info->block_group_cache_lock);
2607	/* Get the block group with the lowest logical start address. */
2608	leftmost = rb_first_cached(&fs_info->block_group_cache_tree);
2609	if (leftmost) {
2610		struct btrfs_block_group *bg;
 
 
 
 
 
 
2611
2612		bg = rb_entry(leftmost, struct btrfs_block_group, cache_node);
2613		bytenr = bg->start;
 
 
 
 
 
 
 
2614	}
2615	read_unlock(&fs_info->block_group_cache_lock);
2616
2617	return bytenr;
2618}
2619
2620static int pin_down_extent(struct btrfs_trans_handle *trans,
2621			   struct btrfs_block_group *cache,
2622			   u64 bytenr, u64 num_bytes, int reserved)
2623{
2624	struct btrfs_fs_info *fs_info = cache->fs_info;
2625
2626	spin_lock(&cache->space_info->lock);
2627	spin_lock(&cache->lock);
2628	cache->pinned += num_bytes;
2629	btrfs_space_info_update_bytes_pinned(fs_info, cache->space_info,
2630					     num_bytes);
2631	if (reserved) {
2632		cache->reserved -= num_bytes;
2633		cache->space_info->bytes_reserved -= num_bytes;
2634	}
2635	spin_unlock(&cache->lock);
2636	spin_unlock(&cache->space_info->lock);
2637
2638	set_extent_bit(&trans->transaction->pinned_extents, bytenr,
2639		       bytenr + num_bytes - 1, EXTENT_DIRTY, NULL);
2640	return 0;
2641}
2642
2643int btrfs_pin_extent(struct btrfs_trans_handle *trans,
2644		     u64 bytenr, u64 num_bytes, int reserved)
2645{
2646	struct btrfs_block_group *cache;
2647
2648	cache = btrfs_lookup_block_group(trans->fs_info, bytenr);
2649	BUG_ON(!cache); /* Logic error */
 
 
 
2650
2651	pin_down_extent(trans, cache, bytenr, num_bytes, reserved);
 
 
 
 
 
2652
2653	btrfs_put_block_group(cache);
2654	return 0;
2655}
 
 
 
 
 
2656
2657int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2658				    const struct extent_buffer *eb)
2659{
2660	struct btrfs_block_group *cache;
2661	int ret;
 
2662
2663	cache = btrfs_lookup_block_group(trans->fs_info, eb->start);
2664	if (!cache)
2665		return -EINVAL;
 
 
 
 
 
 
 
 
 
2666
2667	/*
2668	 * Fully cache the free space first so that our pin removes the free space
2669	 * from the cache.
 
 
 
2670	 */
2671	ret = btrfs_cache_block_group(cache, true);
 
 
 
2672	if (ret)
2673		goto out;
2674
2675	pin_down_extent(trans, cache, eb->start, eb->len, 0);
 
 
 
 
 
2676
2677	/* remove us from the free space cache (if we're there at all) */
2678	ret = btrfs_remove_free_space(cache, eb->start, eb->len);
 
 
2679out:
2680	btrfs_put_block_group(cache);
 
 
 
 
 
2681	return ret;
2682}
2683
2684static int __exclude_logged_extent(struct btrfs_fs_info *fs_info,
2685				   u64 start, u64 num_bytes)
2686{
2687	int ret;
2688	struct btrfs_block_group *block_group;
 
 
2689
2690	block_group = btrfs_lookup_block_group(fs_info, start);
2691	if (!block_group)
2692		return -EINVAL;
2693
2694	ret = btrfs_cache_block_group(block_group, true);
2695	if (ret)
2696		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2697
2698	ret = btrfs_remove_free_space(block_group, start, num_bytes);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2699out:
2700	btrfs_put_block_group(block_group);
2701	return ret;
 
2702}
2703
2704int btrfs_exclude_logged_extents(struct extent_buffer *eb)
2705{
2706	struct btrfs_fs_info *fs_info = eb->fs_info;
2707	struct btrfs_file_extent_item *item;
2708	struct btrfs_key key;
2709	int found_type;
 
 
 
 
 
 
 
 
 
 
 
 
2710	int i;
2711	int ret = 0;
2712
2713	if (!btrfs_fs_incompat(fs_info, MIXED_GROUPS))
2714		return 0;
 
 
 
2715
2716	for (i = 0; i < btrfs_header_nritems(eb); i++) {
2717		btrfs_item_key_to_cpu(eb, &key, i);
2718		if (key.type != BTRFS_EXTENT_DATA_KEY)
2719			continue;
2720		item = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
2721		found_type = btrfs_file_extent_type(eb, item);
2722		if (found_type == BTRFS_FILE_EXTENT_INLINE)
2723			continue;
2724		if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
2725			continue;
2726		key.objectid = btrfs_file_extent_disk_bytenr(eb, item);
2727		key.offset = btrfs_file_extent_disk_num_bytes(eb, item);
2728		ret = __exclude_logged_extent(fs_info, key.objectid, key.offset);
2729		if (ret)
2730			break;
2731	}
 
 
 
2732
2733	return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2734}
2735
2736static void
2737btrfs_inc_block_group_reservations(struct btrfs_block_group *bg)
2738{
2739	atomic_inc(&bg->reservations);
 
 
 
 
 
 
 
 
2740}
2741
2742/*
2743 * Returns the free cluster for the given space info and sets empty_cluster to
2744 * what it should be based on the mount options.
 
 
2745 */
2746static struct btrfs_free_cluster *
2747fetch_cluster_info(struct btrfs_fs_info *fs_info,
2748		   struct btrfs_space_info *space_info, u64 *empty_cluster)
2749{
2750	struct btrfs_free_cluster *ret = NULL;
 
2751
2752	*empty_cluster = 0;
2753	if (btrfs_mixed_space_info(space_info))
2754		return ret;
2755
2756	if (space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {
2757		ret = &fs_info->meta_alloc_cluster;
2758		if (btrfs_test_opt(fs_info, SSD))
2759			*empty_cluster = SZ_2M;
2760		else
2761			*empty_cluster = SZ_64K;
2762	} else if ((space_info->flags & BTRFS_BLOCK_GROUP_DATA) &&
2763		   btrfs_test_opt(fs_info, SSD_SPREAD)) {
2764		*empty_cluster = SZ_2M;
2765		ret = &fs_info->data_alloc_cluster;
2766	}
2767
2768	return ret;
2769}
2770
2771static int unpin_extent_range(struct btrfs_fs_info *fs_info,
2772			      u64 start, u64 end,
2773			      const bool return_free_space)
 
 
 
 
 
2774{
2775	struct btrfs_block_group *cache = NULL;
2776	struct btrfs_space_info *space_info;
2777	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
2778	struct btrfs_free_cluster *cluster = NULL;
2779	u64 len;
2780	u64 total_unpinned = 0;
2781	u64 empty_cluster = 0;
2782	bool readonly;
2783
2784	while (start <= end) {
2785		readonly = false;
2786		if (!cache ||
2787		    start >= cache->start + cache->length) {
2788			if (cache)
2789				btrfs_put_block_group(cache);
2790			total_unpinned = 0;
2791			cache = btrfs_lookup_block_group(fs_info, start);
2792			BUG_ON(!cache); /* Logic error */
2793
2794			cluster = fetch_cluster_info(fs_info,
2795						     cache->space_info,
2796						     &empty_cluster);
2797			empty_cluster <<= 1;
 
 
 
 
 
 
 
2798		}
 
 
2799
2800		len = cache->start + cache->length - start;
2801		len = min(len, end + 1 - start);
 
 
2802
2803		if (return_free_space)
2804			btrfs_add_free_space(cache, start, len);
 
 
 
2805
2806		start += len;
2807		total_unpinned += len;
2808		space_info = cache->space_info;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2809
2810		/*
2811		 * If this space cluster has been marked as fragmented and we've
2812		 * unpinned enough in this block group to potentially allow a
2813		 * cluster to be created inside of it go ahead and clear the
2814		 * fragmented check.
2815		 */
2816		if (cluster && cluster->fragmented &&
2817		    total_unpinned > empty_cluster) {
2818			spin_lock(&cluster->lock);
2819			cluster->fragmented = 0;
2820			spin_unlock(&cluster->lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2821		}
2822
2823		spin_lock(&space_info->lock);
2824		spin_lock(&cache->lock);
2825		cache->pinned -= len;
2826		btrfs_space_info_update_bytes_pinned(fs_info, space_info, -len);
2827		space_info->max_extent_size = 0;
2828		if (cache->ro) {
2829			space_info->bytes_readonly += len;
2830			readonly = true;
2831		} else if (btrfs_is_zoned(fs_info)) {
2832			/* Need reset before reusing in a zoned block group */
2833			space_info->bytes_zone_unusable += len;
2834			readonly = true;
 
 
 
 
 
 
 
 
2835		}
2836		spin_unlock(&cache->lock);
2837		if (!readonly && return_free_space &&
2838		    global_rsv->space_info == space_info) {
2839			spin_lock(&global_rsv->lock);
2840			if (!global_rsv->full) {
2841				u64 to_add = min(len, global_rsv->size -
2842						      global_rsv->reserved);
2843
2844				global_rsv->reserved += to_add;
2845				btrfs_space_info_update_bytes_may_use(fs_info,
2846						space_info, to_add);
2847				if (global_rsv->reserved >= global_rsv->size)
2848					global_rsv->full = 1;
2849				len -= to_add;
2850			}
2851			spin_unlock(&global_rsv->lock);
2852		}
2853		/* Add to any tickets we may have */
2854		if (!readonly && return_free_space && len)
2855			btrfs_try_granting_tickets(fs_info, space_info);
2856		spin_unlock(&space_info->lock);
2857	}
 
 
 
 
2858
2859	if (cache)
2860		btrfs_put_block_group(cache);
2861	return 0;
2862}
2863
2864int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans)
 
 
 
2865{
2866	struct btrfs_fs_info *fs_info = trans->fs_info;
2867	struct btrfs_block_group *block_group, *tmp;
2868	struct list_head *deleted_bgs;
2869	struct extent_io_tree *unpin;
2870	u64 start;
2871	u64 end;
2872	int ret;
2873
2874	unpin = &trans->transaction->pinned_extents;
 
2875
2876	while (!TRANS_ABORTED(trans)) {
2877		struct extent_state *cached_state = NULL;
2878
2879		mutex_lock(&fs_info->unused_bg_unpin_mutex);
2880		if (!find_first_extent_bit(unpin, 0, &start, &end,
2881					   EXTENT_DIRTY, &cached_state)) {
2882			mutex_unlock(&fs_info->unused_bg_unpin_mutex);
2883			break;
2884		}
2885
2886		if (btrfs_test_opt(fs_info, DISCARD_SYNC))
2887			ret = btrfs_discard_extent(fs_info, start,
2888						   end + 1 - start, NULL);
 
2889
2890		clear_extent_dirty(unpin, start, end, &cached_state);
2891		unpin_extent_range(fs_info, start, end, true);
2892		mutex_unlock(&fs_info->unused_bg_unpin_mutex);
2893		free_extent_state(cached_state);
2894		cond_resched();
2895	}
 
 
2896
2897	if (btrfs_test_opt(fs_info, DISCARD_ASYNC)) {
2898		btrfs_discard_calc_delay(&fs_info->discard_ctl);
2899		btrfs_discard_schedule_work(&fs_info->discard_ctl, true);
2900	}
 
 
 
 
 
 
 
2901
2902	/*
2903	 * Transaction is finished.  We don't need the lock anymore.  We
2904	 * do need to clean up the block groups in case of a transaction
2905	 * abort.
2906	 */
2907	deleted_bgs = &trans->transaction->deleted_bgs;
2908	list_for_each_entry_safe(block_group, tmp, deleted_bgs, bg_list) {
2909		u64 trimmed = 0;
2910
2911		ret = -EROFS;
2912		if (!TRANS_ABORTED(trans))
2913			ret = btrfs_discard_extent(fs_info,
2914						   block_group->start,
2915						   block_group->length,
2916						   &trimmed);
2917
2918		list_del_init(&block_group->bg_list);
2919		btrfs_unfreeze_block_group(block_group);
2920		btrfs_put_block_group(block_group);
 
 
 
 
 
2921
2922		if (ret) {
2923			const char *errstr = btrfs_decode_error(ret);
2924			btrfs_warn(fs_info,
2925			   "discard failed while removing blockgroup: errno=%d %s",
2926				   ret, errstr);
2927		}
2928	}
 
2929
2930	return 0;
 
 
 
 
 
 
 
 
2931}
2932
2933/*
2934 * Parse an extent item's inline extents looking for a simple quotas owner ref.
2935 *
2936 * @fs_info:	the btrfs_fs_info for this mount
2937 * @leaf:	a leaf in the extent tree containing the extent item
2938 * @slot:	the slot in the leaf where the extent item is found
2939 *
2940 * Returns the objectid of the root that originally allocated the extent item
2941 * if the inline owner ref is expected and present, otherwise 0.
2942 *
2943 * If an extent item has an owner ref item, it will be the first inline ref
2944 * item. Therefore the logic is to check whether there are any inline ref
2945 * items, then check the type of the first one.
2946 */
2947u64 btrfs_get_extent_owner_root(struct btrfs_fs_info *fs_info,
2948				struct extent_buffer *leaf, int slot)
2949{
2950	struct btrfs_extent_item *ei;
2951	struct btrfs_extent_inline_ref *iref;
2952	struct btrfs_extent_owner_ref *oref;
2953	unsigned long ptr;
2954	unsigned long end;
2955	int type;
2956
2957	if (!btrfs_fs_incompat(fs_info, SIMPLE_QUOTA))
2958		return 0;
 
 
 
 
 
2959
2960	ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
2961	ptr = (unsigned long)(ei + 1);
2962	end = (unsigned long)ei + btrfs_item_size(leaf, slot);
2963
2964	/* No inline ref items of any kind, can't check type. */
2965	if (ptr == end)
2966		return 0;
 
 
 
2967
2968	iref = (struct btrfs_extent_inline_ref *)ptr;
2969	type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_ANY);
 
 
 
2970
2971	/* We found an owner ref, get the root out of it. */
2972	if (type == BTRFS_EXTENT_OWNER_REF_KEY) {
2973		oref = (struct btrfs_extent_owner_ref *)(&iref->offset);
2974		return btrfs_extent_owner_ref_root_id(leaf, oref);
 
2975	}
2976
2977	/* We have inline refs, but not an owner ref. */
2978	return 0;
 
 
 
 
2979}
2980
2981static int do_free_extent_accounting(struct btrfs_trans_handle *trans,
2982				     u64 bytenr, struct btrfs_squota_delta *delta)
 
2983{
2984	int ret;
2985	u64 num_bytes = delta->num_bytes;
 
 
2986
2987	if (delta->is_data) {
2988		struct btrfs_root *csum_root;
 
 
 
 
 
2989
2990		csum_root = btrfs_csum_root(trans->fs_info, bytenr);
2991		ret = btrfs_del_csums(trans, csum_root, bytenr, num_bytes);
2992		if (ret) {
2993			btrfs_abort_transaction(trans, ret);
2994			return ret;
2995		}
 
 
2996
2997		ret = btrfs_delete_raid_extent(trans, bytenr, num_bytes);
2998		if (ret) {
2999			btrfs_abort_transaction(trans, ret);
3000			return ret;
3001		}
 
 
3002	}
3003
3004	ret = btrfs_record_squota_delta(trans->fs_info, delta);
3005	if (ret) {
3006		btrfs_abort_transaction(trans, ret);
3007		return ret;
 
 
 
 
 
 
 
 
 
 
3008	}
3009
3010	ret = add_to_free_space_tree(trans, bytenr, num_bytes);
3011	if (ret) {
3012		btrfs_abort_transaction(trans, ret);
3013		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
3014	}
3015
3016	ret = btrfs_update_block_group(trans, bytenr, num_bytes, false);
 
 
 
 
 
 
 
 
 
 
3017	if (ret)
3018		btrfs_abort_transaction(trans, ret);
 
 
3019
 
 
 
 
 
3020	return ret;
3021}
3022
3023#define abort_and_dump(trans, path, fmt, args...)	\
3024({							\
3025	btrfs_abort_transaction(trans, -EUCLEAN);	\
3026	btrfs_print_leaf(path->nodes[0]);		\
3027	btrfs_crit(trans->fs_info, fmt, ##args);	\
3028})
3029
3030/*
3031 * Drop one or more refs of @node.
3032 *
3033 * 1. Locate the extent refs.
3034 *    It's either inline in EXTENT/METADATA_ITEM or in keyed SHARED_* item.
3035 *    Locate it, then reduce the refs number or remove the ref line completely.
3036 *
3037 * 2. Update the refs count in EXTENT/METADATA_ITEM
3038 *
3039 * Inline backref case:
3040 *
3041 * in extent tree we have:
3042 *
3043 * 	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 16201 itemsize 82
3044 *		refs 2 gen 6 flags DATA
3045 *		extent data backref root FS_TREE objectid 258 offset 0 count 1
3046 *		extent data backref root FS_TREE objectid 257 offset 0 count 1
3047 *
3048 * This function gets called with:
3049 *
3050 *    node->bytenr = 13631488
3051 *    node->num_bytes = 1048576
3052 *    root_objectid = FS_TREE
3053 *    owner_objectid = 257
3054 *    owner_offset = 0
3055 *    refs_to_drop = 1
3056 *
3057 * Then we should get some like:
3058 *
3059 * 	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 16201 itemsize 82
3060 *		refs 1 gen 6 flags DATA
3061 *		extent data backref root FS_TREE objectid 258 offset 0 count 1
3062 *
3063 * Keyed backref case:
3064 *
3065 * in extent tree we have:
3066 *
3067 *	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 3971 itemsize 24
3068 *		refs 754 gen 6 flags DATA
3069 *	[...]
3070 *	item 2 key (13631488 EXTENT_DATA_REF <HASH>) itemoff 3915 itemsize 28
3071 *		extent data backref root FS_TREE objectid 866 offset 0 count 1
3072 *
3073 * This function get called with:
3074 *
3075 *    node->bytenr = 13631488
3076 *    node->num_bytes = 1048576
3077 *    root_objectid = FS_TREE
3078 *    owner_objectid = 866
3079 *    owner_offset = 0
3080 *    refs_to_drop = 1
3081 *
3082 * Then we should get some like:
3083 *
3084 *	item 0 key (13631488 EXTENT_ITEM 1048576) itemoff 3971 itemsize 24
3085 *		refs 753 gen 6 flags DATA
3086 *
3087 * And that (13631488 EXTENT_DATA_REF <HASH>) gets removed.
3088 */
3089static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
3090			       struct btrfs_delayed_ref_head *href,
3091			       struct btrfs_delayed_ref_node *node, u64 parent,
3092			       u64 root_objectid, u64 owner_objectid,
3093			       u64 owner_offset,
3094			       struct btrfs_delayed_extent_op *extent_op)
3095{
3096	struct btrfs_fs_info *info = trans->fs_info;
3097	struct btrfs_key key;
3098	struct btrfs_path *path;
3099	struct btrfs_root *extent_root;
3100	struct extent_buffer *leaf;
3101	struct btrfs_extent_item *ei;
3102	struct btrfs_extent_inline_ref *iref;
3103	int ret;
3104	int is_data;
3105	int extent_slot = 0;
3106	int found_extent = 0;
3107	int num_to_del = 1;
3108	int refs_to_drop = node->ref_mod;
3109	u32 item_size;
3110	u64 refs;
3111	u64 bytenr = node->bytenr;
3112	u64 num_bytes = node->num_bytes;
3113	bool skinny_metadata = btrfs_fs_incompat(info, SKINNY_METADATA);
3114	u64 delayed_ref_root = href->owning_root;
3115
3116	extent_root = btrfs_extent_root(info, bytenr);
3117	ASSERT(extent_root);
3118
3119	path = btrfs_alloc_path();
3120	if (!path)
3121		return -ENOMEM;
 
 
 
 
3122
3123	is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
 
 
 
 
 
 
 
 
 
3124
3125	if (!is_data && refs_to_drop != 1) {
3126		btrfs_crit(info,
3127"invalid refs_to_drop, dropping more than 1 refs for tree block %llu refs_to_drop %u",
3128			   node->bytenr, refs_to_drop);
3129		ret = -EINVAL;
3130		btrfs_abort_transaction(trans, ret);
3131		goto out;
3132	}
3133
3134	if (is_data)
3135		skinny_metadata = false;
3136
3137	ret = lookup_extent_backref(trans, path, &iref, bytenr, num_bytes,
3138				    parent, root_objectid, owner_objectid,
3139				    owner_offset);
3140	if (ret == 0) {
3141		/*
3142		 * Either the inline backref or the SHARED_DATA_REF/
3143		 * SHARED_BLOCK_REF is found
3144		 *
3145		 * Here is a quick path to locate EXTENT/METADATA_ITEM.
3146		 * It's possible the EXTENT/METADATA_ITEM is near current slot.
3147		 */
3148		extent_slot = path->slots[0];
3149		while (extent_slot >= 0) {
3150			btrfs_item_key_to_cpu(path->nodes[0], &key,
3151					      extent_slot);
3152			if (key.objectid != bytenr)
3153				break;
3154			if (key.type == BTRFS_EXTENT_ITEM_KEY &&
3155			    key.offset == num_bytes) {
3156				found_extent = 1;
3157				break;
3158			}
3159			if (key.type == BTRFS_METADATA_ITEM_KEY &&
3160			    key.offset == owner_objectid) {
3161				found_extent = 1;
3162				break;
3163			}
3164
3165			/* Quick path didn't find the EXTEMT/METADATA_ITEM */
3166			if (path->slots[0] - extent_slot > 5)
 
 
 
 
 
 
 
3167				break;
3168			extent_slot--;
3169		}
3170
3171		if (!found_extent) {
3172			if (iref) {
3173				abort_and_dump(trans, path,
3174"invalid iref slot %u, no EXTENT/METADATA_ITEM found but has inline extent ref",
3175					   path->slots[0]);
3176				ret = -EUCLEAN;
3177				goto out;
3178			}
3179			/* Must be SHARED_* item, remove the backref first */
3180			ret = remove_extent_backref(trans, extent_root, path,
3181						    NULL, refs_to_drop, is_data);
3182			if (ret) {
3183				btrfs_abort_transaction(trans, ret);
3184				goto out;
3185			}
3186			btrfs_release_path(path);
3187
3188			/* Slow path to locate EXTENT/METADATA_ITEM */
3189			key.objectid = bytenr;
3190			key.type = BTRFS_EXTENT_ITEM_KEY;
3191			key.offset = num_bytes;
3192
3193			if (!is_data && skinny_metadata) {
3194				key.type = BTRFS_METADATA_ITEM_KEY;
3195				key.offset = owner_objectid;
3196			}
 
 
 
 
 
 
 
 
 
 
 
 
3197
3198			ret = btrfs_search_slot(trans, extent_root,
3199						&key, path, -1, 1);
3200			if (ret > 0 && skinny_metadata && path->slots[0]) {
3201				/*
3202				 * Couldn't find our skinny metadata item,
3203				 * see if we have ye olde extent item.
3204				 */
3205				path->slots[0]--;
3206				btrfs_item_key_to_cpu(path->nodes[0], &key,
3207						      path->slots[0]);
3208				if (key.objectid == bytenr &&
3209				    key.type == BTRFS_EXTENT_ITEM_KEY &&
3210				    key.offset == num_bytes)
3211					ret = 0;
3212			}
3213
3214			if (ret > 0 && skinny_metadata) {
3215				skinny_metadata = false;
3216				key.objectid = bytenr;
3217				key.type = BTRFS_EXTENT_ITEM_KEY;
3218				key.offset = num_bytes;
3219				btrfs_release_path(path);
3220				ret = btrfs_search_slot(trans, extent_root,
3221							&key, path, -1, 1);
3222			}
3223
3224			if (ret) {
3225				if (ret > 0)
3226					btrfs_print_leaf(path->nodes[0]);
3227				btrfs_err(info,
3228			"umm, got %d back from search, was looking for %llu, slot %d",
3229					  ret, bytenr, path->slots[0]);
3230			}
3231			if (ret < 0) {
3232				btrfs_abort_transaction(trans, ret);
3233				goto out;
3234			}
3235			extent_slot = path->slots[0];
3236		}
3237	} else if (WARN_ON(ret == -ENOENT)) {
3238		abort_and_dump(trans, path,
3239"unable to find ref byte nr %llu parent %llu root %llu owner %llu offset %llu slot %d",
3240			       bytenr, parent, root_objectid, owner_objectid,
3241			       owner_offset, path->slots[0]);
3242		goto out;
3243	} else {
3244		btrfs_abort_transaction(trans, ret);
3245		goto out;
3246	}
 
3247
3248	leaf = path->nodes[0];
3249	item_size = btrfs_item_size(leaf, extent_slot);
3250	if (unlikely(item_size < sizeof(*ei))) {
3251		ret = -EUCLEAN;
3252		btrfs_err(trans->fs_info,
3253			  "unexpected extent item size, has %u expect >= %zu",
3254			  item_size, sizeof(*ei));
3255		btrfs_abort_transaction(trans, ret);
3256		goto out;
3257	}
3258	ei = btrfs_item_ptr(leaf, extent_slot,
3259			    struct btrfs_extent_item);
3260	if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID &&
3261	    key.type == BTRFS_EXTENT_ITEM_KEY) {
3262		struct btrfs_tree_block_info *bi;
3263
3264		if (item_size < sizeof(*ei) + sizeof(*bi)) {
3265			abort_and_dump(trans, path,
3266"invalid extent item size for key (%llu, %u, %llu) slot %u owner %llu, has %u expect >= %zu",
3267				       key.objectid, key.type, key.offset,
3268				       path->slots[0], owner_objectid, item_size,
3269				       sizeof(*ei) + sizeof(*bi));
3270			ret = -EUCLEAN;
3271			goto out;
3272		}
3273		bi = (struct btrfs_tree_block_info *)(ei + 1);
3274		WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
3275	}
 
 
3276
3277	refs = btrfs_extent_refs(leaf, ei);
3278	if (refs < refs_to_drop) {
3279		abort_and_dump(trans, path,
3280		"trying to drop %d refs but we only have %llu for bytenr %llu slot %u",
3281			       refs_to_drop, refs, bytenr, path->slots[0]);
3282		ret = -EUCLEAN;
3283		goto out;
3284	}
3285	refs -= refs_to_drop;
3286
3287	if (refs > 0) {
3288		if (extent_op)
3289			__run_delayed_extent_op(extent_op, leaf, ei);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3290		/*
3291		 * In the case of inline back ref, reference count will
3292		 * be updated by remove_extent_backref
 
 
3293		 */
3294		if (iref) {
3295			if (!found_extent) {
3296				abort_and_dump(trans, path,
3297"invalid iref, got inlined extent ref but no EXTENT/METADATA_ITEM found, slot %u",
3298					       path->slots[0]);
3299				ret = -EUCLEAN;
3300				goto out;
3301			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3302		} else {
3303			btrfs_set_extent_refs(leaf, ei, refs);
3304			btrfs_mark_buffer_dirty(trans, leaf);
3305		}
3306		if (found_extent) {
3307			ret = remove_extent_backref(trans, extent_root, path,
3308						    iref, refs_to_drop, is_data);
3309			if (ret) {
3310				btrfs_abort_transaction(trans, ret);
3311				goto out;
3312			}
3313		}
3314	} else {
3315		struct btrfs_squota_delta delta = {
3316			.root = delayed_ref_root,
3317			.num_bytes = num_bytes,
3318			.is_data = is_data,
3319			.is_inc = false,
3320			.generation = btrfs_extent_generation(leaf, ei),
3321		};
 
 
3322
3323		/* In this branch refs == 1 */
3324		if (found_extent) {
3325			if (is_data && refs_to_drop !=
3326			    extent_data_ref_count(path, iref)) {
3327				abort_and_dump(trans, path,
3328		"invalid refs_to_drop, current refs %u refs_to_drop %u slot %u",
3329					       extent_data_ref_count(path, iref),
3330					       refs_to_drop, path->slots[0]);
3331				ret = -EUCLEAN;
 
 
 
 
 
 
 
 
3332				goto out;
3333			}
3334			if (iref) {
3335				if (path->slots[0] != extent_slot) {
3336					abort_and_dump(trans, path,
3337"invalid iref, extent item key (%llu %u %llu) slot %u doesn't have wanted iref",
3338						       key.objectid, key.type,
3339						       key.offset, path->slots[0]);
3340					ret = -EUCLEAN;
3341					goto out;
3342				}
3343			} else {
3344				/*
3345				 * No inline ref, we must be at SHARED_* item,
3346				 * And it's single ref, it must be:
3347				 * |	extent_slot	  ||extent_slot + 1|
3348				 * [ EXTENT/METADATA_ITEM ][ SHARED_* ITEM ]
3349				 */
3350				if (path->slots[0] != extent_slot + 1) {
3351					abort_and_dump(trans, path,
3352	"invalid SHARED_* item slot %u, previous item is not EXTENT/METADATA_ITEM",
3353						       path->slots[0]);
3354					ret = -EUCLEAN;
3355					goto out;
3356				}
3357				path->slots[0] = extent_slot;
3358				num_to_del = 2;
3359			}
3360		}
 
 
 
 
3361		/*
3362		 * We can't infer the data owner from the delayed ref, so we need
3363		 * to try to get it from the owning ref item.
3364		 *
3365		 * If it is not present, then that extent was not written under
3366		 * simple quotas mode, so we don't need to account for its deletion.
3367		 */
3368		if (is_data)
3369			delta.root = btrfs_get_extent_owner_root(trans->fs_info,
3370								 leaf, extent_slot);
 
3371
3372		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
3373				      num_to_del);
3374		if (ret) {
3375			btrfs_abort_transaction(trans, ret);
3376			goto out;
3377		}
3378		btrfs_release_path(path);
 
 
 
3379
3380		ret = do_free_extent_accounting(trans, bytenr, &delta);
 
 
 
 
 
 
 
3381	}
3382	btrfs_release_path(path);
3383
3384out:
3385	btrfs_free_path(path);
3386	return ret;
3387}
3388
3389/*
3390 * when we free an block, it is possible (and likely) that we free the last
3391 * delayed ref for that extent as well.  This searches the delayed ref tree for
3392 * a given extent, and if there are no other delayed refs to be processed, it
3393 * removes it from the tree.
3394 */
3395static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
3396				      u64 bytenr)
3397{
3398	struct btrfs_delayed_ref_head *head;
3399	struct btrfs_delayed_ref_root *delayed_refs;
3400	int ret = 0;
3401
3402	delayed_refs = &trans->transaction->delayed_refs;
3403	spin_lock(&delayed_refs->lock);
3404	head = btrfs_find_delayed_ref_head(delayed_refs, bytenr);
3405	if (!head)
3406		goto out_delayed_unlock;
3407
3408	spin_lock(&head->lock);
3409	if (!RB_EMPTY_ROOT(&head->ref_tree.rb_root))
3410		goto out;
3411
3412	if (cleanup_extent_op(head) != NULL)
3413		goto out;
3414
3415	/*
3416	 * waiting for the lock here would deadlock.  If someone else has it
3417	 * locked they are already in the process of dropping it anyway
3418	 */
3419	if (!mutex_trylock(&head->mutex))
 
3420		goto out;
3421
3422	btrfs_delete_ref_head(delayed_refs, head);
3423	head->processing = false;
3424
3425	spin_unlock(&head->lock);
3426	spin_unlock(&delayed_refs->lock);
 
 
 
 
 
 
 
 
3427
3428	BUG_ON(head->extent_op);
3429	if (head->must_insert_reserved)
3430		ret = 1;
3431
3432	btrfs_cleanup_ref_head_accounting(trans->fs_info, delayed_refs, head);
3433	mutex_unlock(&head->mutex);
3434	btrfs_put_delayed_ref_head(head);
3435	return ret;
3436out:
3437	spin_unlock(&head->lock);
3438
3439out_delayed_unlock:
3440	spin_unlock(&delayed_refs->lock);
3441	return 0;
 
 
 
 
 
3442}
3443
3444void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
3445			   u64 root_id,
3446			   struct extent_buffer *buf,
3447			   u64 parent, int last_ref)
3448{
3449	struct btrfs_fs_info *fs_info = trans->fs_info;
3450	struct btrfs_ref generic_ref = { 0 };
3451	struct btrfs_block_group *bg;
3452	int ret;
3453
3454	btrfs_init_generic_ref(&generic_ref, BTRFS_DROP_DELAYED_REF,
3455			       buf->start, buf->len, parent, btrfs_header_owner(buf));
3456	btrfs_init_tree_ref(&generic_ref, btrfs_header_level(buf),
3457			    root_id, 0, false);
3458
3459	if (root_id != BTRFS_TREE_LOG_OBJECTID) {
3460		btrfs_ref_tree_mod(fs_info, &generic_ref);
3461		ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, NULL);
3462		BUG_ON(ret); /* -ENOMEM */
3463	}
3464
3465	if (!last_ref)
3466		return;
3467
3468	if (btrfs_header_generation(buf) != trans->transid)
3469		goto out;
3470
3471	if (root_id != BTRFS_TREE_LOG_OBJECTID) {
3472		ret = check_ref_cleanup(trans, buf->start);
3473		if (!ret)
3474			goto out;
 
 
 
 
 
 
 
 
 
3475	}
 
 
 
3476
3477	bg = btrfs_lookup_block_group(fs_info, buf->start);
 
 
 
 
 
 
 
 
 
 
3478
3479	if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
3480		pin_down_extent(trans, bg, buf->start, buf->len, 1);
3481		btrfs_put_block_group(bg);
3482		goto out;
3483	}
3484
3485	/*
3486	 * If there are tree mod log users we may have recorded mod log
3487	 * operations for this node.  If we re-allocate this node we
3488	 * could replay operations on this node that happened when it
3489	 * existed in a completely different root.  For example if it
3490	 * was part of root A, then was reallocated to root B, and we
3491	 * are doing a btrfs_old_search_slot(root b), we could replay
3492	 * operations that happened when the block was part of root A,
3493	 * giving us an inconsistent view of the btree.
3494	 *
3495	 * We are safe from races here because at this point no other
3496	 * node or root points to this extent buffer, so if after this
3497	 * check a new tree mod log user joins we will not have an
3498	 * existing log of operations on this node that we have to
3499	 * contend with.
3500	 */
3501
3502	if (test_bit(BTRFS_FS_TREE_MOD_LOG_USERS, &fs_info->flags)
3503		     || btrfs_is_zoned(fs_info)) {
3504		pin_down_extent(trans, bg, buf->start, buf->len, 1);
3505		btrfs_put_block_group(bg);
3506		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3507	}
 
3508
3509	WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
 
 
 
3510
3511	btrfs_add_free_space(bg, buf->start, buf->len);
3512	btrfs_free_reserved_bytes(bg, buf->len, 0);
3513	btrfs_put_block_group(bg);
3514	trace_btrfs_reserved_extent_free(fs_info, buf->start, buf->len);
3515
3516out:
 
 
3517
3518	/*
3519	 * Deleting the buffer, clear the corrupt flag since it doesn't
3520	 * matter anymore.
3521	 */
3522	clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);
3523}
3524
3525/* Can return -ENOMEM */
3526int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3527{
3528	struct btrfs_fs_info *fs_info = trans->fs_info;
3529	int ret;
3530
3531	if (btrfs_is_testing(fs_info))
3532		return 0;
3533
3534	/*
3535	 * tree log blocks never actually go into the extent allocation
3536	 * tree, just update pinning info and exit early.
3537	 */
3538	if ((ref->type == BTRFS_REF_METADATA &&
3539	     ref->tree_ref.ref_root == BTRFS_TREE_LOG_OBJECTID) ||
3540	    (ref->type == BTRFS_REF_DATA &&
3541	     ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)) {
3542		btrfs_pin_extent(trans, ref->bytenr, ref->len, 1);
3543		ret = 0;
3544	} else if (ref->type == BTRFS_REF_METADATA) {
3545		ret = btrfs_add_delayed_tree_ref(trans, ref, NULL);
3546	} else {
3547		ret = btrfs_add_delayed_data_ref(trans, ref, 0);
3548	}
3549
3550	if (!((ref->type == BTRFS_REF_METADATA &&
3551	       ref->tree_ref.ref_root == BTRFS_TREE_LOG_OBJECTID) ||
3552	      (ref->type == BTRFS_REF_DATA &&
3553	       ref->data_ref.ref_root == BTRFS_TREE_LOG_OBJECTID)))
3554		btrfs_ref_tree_mod(fs_info, ref);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3555
3556	return ret;
3557}
3558
3559enum btrfs_loop_type {
3560	/*
3561	 * Start caching block groups but do not wait for progress or for them
3562	 * to be done.
3563	 */
3564	LOOP_CACHING_NOWAIT,
3565
3566	/*
3567	 * Wait for the block group free_space >= the space we're waiting for if
3568	 * the block group isn't cached.
3569	 */
3570	LOOP_CACHING_WAIT,
3571
3572	/*
3573	 * Allow allocations to happen from block groups that do not yet have a
3574	 * size classification.
3575	 */
3576	LOOP_UNSET_SIZE_CLASS,
 
 
3577
3578	/*
3579	 * Allocate a chunk and then retry the allocation.
3580	 */
3581	LOOP_ALLOC_CHUNK,
3582
3583	/*
3584	 * Ignore the size class restrictions for this allocation.
3585	 */
3586	LOOP_WRONG_SIZE_CLASS,
 
3587
3588	/*
3589	 * Ignore the empty size, only try to allocate the number of bytes
3590	 * needed for this allocation.
3591	 */
3592	LOOP_NO_EMPTY_SIZE,
3593};
3594
3595static inline void
3596btrfs_lock_block_group(struct btrfs_block_group *cache,
3597		       int delalloc)
3598{
3599	if (delalloc)
3600		down_read(&cache->data_rwsem);
3601}
3602
3603static inline void btrfs_grab_block_group(struct btrfs_block_group *cache,
3604		       int delalloc)
 
3605{
3606	btrfs_get_block_group(cache);
3607	if (delalloc)
3608		down_read(&cache->data_rwsem);
3609}
3610
3611static struct btrfs_block_group *btrfs_lock_cluster(
3612		   struct btrfs_block_group *block_group,
3613		   struct btrfs_free_cluster *cluster,
3614		   int delalloc)
3615	__acquires(&cluster->refill_lock)
3616{
3617	struct btrfs_block_group *used_bg = NULL;
 
3618
3619	spin_lock(&cluster->refill_lock);
3620	while (1) {
3621		used_bg = cluster->block_group;
3622		if (!used_bg)
3623			return NULL;
 
 
 
 
 
 
3624
3625		if (used_bg == block_group)
3626			return used_bg;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3627
3628		btrfs_get_block_group(used_bg);
 
 
3629
3630		if (!delalloc)
3631			return used_bg;
 
 
 
 
 
 
 
 
 
3632
3633		if (down_read_trylock(&used_bg->data_rwsem))
3634			return used_bg;
3635
3636		spin_unlock(&cluster->refill_lock);
 
3637
3638		/* We should only have one-level nested. */
3639		down_read_nested(&used_bg->data_rwsem, SINGLE_DEPTH_NESTING);
3640
3641		spin_lock(&cluster->refill_lock);
3642		if (used_bg == cluster->block_group)
3643			return used_bg;
3644
3645		up_read(&used_bg->data_rwsem);
3646		btrfs_put_block_group(used_bg);
 
 
 
 
3647	}
 
 
 
 
 
 
 
 
 
 
 
 
 
3648}
3649
3650static inline void
3651btrfs_release_block_group(struct btrfs_block_group *cache,
3652			 int delalloc)
3653{
3654	if (delalloc)
3655		up_read(&cache->data_rwsem);
3656	btrfs_put_block_group(cache);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3657}
3658
3659/*
3660 * Helper function for find_free_extent().
3661 *
3662 * Return -ENOENT to inform caller that we need fallback to unclustered mode.
3663 * Return >0 to inform caller that we find nothing
3664 * Return 0 means we have found a location and set ffe_ctl->found_offset.
3665 */
3666static int find_free_extent_clustered(struct btrfs_block_group *bg,
3667				      struct find_free_extent_ctl *ffe_ctl,
3668				      struct btrfs_block_group **cluster_bg_ret)
3669{
3670	struct btrfs_block_group *cluster_bg;
3671	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;
3672	u64 aligned_cluster;
3673	u64 offset;
3674	int ret;
3675
3676	cluster_bg = btrfs_lock_cluster(bg, last_ptr, ffe_ctl->delalloc);
3677	if (!cluster_bg)
3678		goto refill_cluster;
3679	if (cluster_bg != bg && (cluster_bg->ro ||
3680	    !block_group_bits(cluster_bg, ffe_ctl->flags)))
3681		goto release_cluster;
3682
3683	offset = btrfs_alloc_from_cluster(cluster_bg, last_ptr,
3684			ffe_ctl->num_bytes, cluster_bg->start,
3685			&ffe_ctl->max_extent_size);
3686	if (offset) {
3687		/* We have a block, we're done */
3688		spin_unlock(&last_ptr->refill_lock);
3689		trace_btrfs_reserve_extent_cluster(cluster_bg, ffe_ctl);
3690		*cluster_bg_ret = cluster_bg;
3691		ffe_ctl->found_offset = offset;
3692		return 0;
3693	}
3694	WARN_ON(last_ptr->block_group != cluster_bg);
3695
3696release_cluster:
3697	/*
3698	 * If we are on LOOP_NO_EMPTY_SIZE, we can't set up a new clusters, so
3699	 * lets just skip it and let the allocator find whatever block it can
3700	 * find. If we reach this point, we will have tried the cluster
3701	 * allocator plenty of times and not have found anything, so we are
3702	 * likely way too fragmented for the clustering stuff to find anything.
3703	 *
3704	 * However, if the cluster is taken from the current block group,
3705	 * release the cluster first, so that we stand a better chance of
3706	 * succeeding in the unclustered allocation.
3707	 */
3708	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE && cluster_bg != bg) {
3709		spin_unlock(&last_ptr->refill_lock);
3710		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);
3711		return -ENOENT;
3712	}
3713
3714	/* This cluster didn't work out, free it and start over */
3715	btrfs_return_cluster_to_free_space(NULL, last_ptr);
 
 
 
 
 
3716
3717	if (cluster_bg != bg)
3718		btrfs_release_block_group(cluster_bg, ffe_ctl->delalloc);
 
 
 
 
 
 
 
 
3719
3720refill_cluster:
3721	if (ffe_ctl->loop >= LOOP_NO_EMPTY_SIZE) {
3722		spin_unlock(&last_ptr->refill_lock);
3723		return -ENOENT;
3724	}
 
 
 
3725
3726	aligned_cluster = max_t(u64,
3727			ffe_ctl->empty_cluster + ffe_ctl->empty_size,
3728			bg->full_stripe_len);
3729	ret = btrfs_find_space_cluster(bg, last_ptr, ffe_ctl->search_start,
3730			ffe_ctl->num_bytes, aligned_cluster);
3731	if (ret == 0) {
3732		/* Now pull our allocation out of this cluster */
3733		offset = btrfs_alloc_from_cluster(bg, last_ptr,
3734				ffe_ctl->num_bytes, ffe_ctl->search_start,
3735				&ffe_ctl->max_extent_size);
3736		if (offset) {
3737			/* We found one, proceed */
3738			spin_unlock(&last_ptr->refill_lock);
3739			ffe_ctl->found_offset = offset;
3740			trace_btrfs_reserve_extent_cluster(bg, ffe_ctl);
3741			return 0;
3742		}
3743	}
3744	/*
3745	 * At this point we either didn't find a cluster or we weren't able to
3746	 * allocate a block from our cluster.  Free the cluster we've been
3747	 * trying to use, and go to the next block group.
3748	 */
3749	btrfs_return_cluster_to_free_space(NULL, last_ptr);
3750	spin_unlock(&last_ptr->refill_lock);
3751	return 1;
3752}
3753
3754/*
3755 * Return >0 to inform caller that we find nothing
3756 * Return 0 when we found an free extent and set ffe_ctrl->found_offset
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3757 */
3758static int find_free_extent_unclustered(struct btrfs_block_group *bg,
3759					struct find_free_extent_ctl *ffe_ctl)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3760{
3761	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;
3762	u64 offset;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3763
3764	/*
3765	 * We are doing an unclustered allocation, set the fragmented flag so
3766	 * we don't bother trying to setup a cluster again until we get more
3767	 * space.
3768	 */
3769	if (unlikely(last_ptr)) {
3770		spin_lock(&last_ptr->lock);
3771		last_ptr->fragmented = 1;
3772		spin_unlock(&last_ptr->lock);
3773	}
3774	if (ffe_ctl->cached) {
3775		struct btrfs_free_space_ctl *free_space_ctl;
3776
3777		free_space_ctl = bg->free_space_ctl;
3778		spin_lock(&free_space_ctl->tree_lock);
3779		if (free_space_ctl->free_space <
3780		    ffe_ctl->num_bytes + ffe_ctl->empty_cluster +
3781		    ffe_ctl->empty_size) {
3782			ffe_ctl->total_free_space = max_t(u64,
3783					ffe_ctl->total_free_space,
3784					free_space_ctl->free_space);
3785			spin_unlock(&free_space_ctl->tree_lock);
3786			return 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3787		}
3788		spin_unlock(&free_space_ctl->tree_lock);
 
3789	}
3790
3791	offset = btrfs_find_space_for_alloc(bg, ffe_ctl->search_start,
3792			ffe_ctl->num_bytes, ffe_ctl->empty_size,
3793			&ffe_ctl->max_extent_size);
3794	if (!offset)
3795		return 1;
3796	ffe_ctl->found_offset = offset;
 
 
 
 
 
 
 
 
 
3797	return 0;
3798}
3799
3800static int do_allocation_clustered(struct btrfs_block_group *block_group,
3801				   struct find_free_extent_ctl *ffe_ctl,
3802				   struct btrfs_block_group **bg_ret)
 
 
 
 
 
 
 
3803{
3804	int ret;
 
 
3805
3806	/* We want to try and use the cluster allocator, so lets look there */
3807	if (ffe_ctl->last_ptr && ffe_ctl->use_cluster) {
3808		ret = find_free_extent_clustered(block_group, ffe_ctl, bg_ret);
3809		if (ret >= 0)
3810			return ret;
3811		/* ret == -ENOENT case falls through */
3812	}
3813
3814	return find_free_extent_unclustered(block_group, ffe_ctl);
 
 
 
 
 
 
 
 
3815}
3816
3817/*
3818 * Tree-log block group locking
3819 * ============================
 
 
 
3820 *
3821 * fs_info::treelog_bg_lock protects the fs_info::treelog_bg which
3822 * indicates the starting address of a block group, which is reserved only
3823 * for tree-log metadata.
3824 *
3825 * Lock nesting
3826 * ============
3827 *
3828 * space_info::lock
3829 *   block_group::lock
3830 *     fs_info::treelog_bg_lock
3831 */
 
 
 
3832
3833/*
3834 * Simple allocator for sequential-only block group. It only allows sequential
3835 * allocation. No need to play with trees. This function also reserves the
3836 * bytes as in btrfs_add_reserved_bytes.
3837 */
3838static int do_allocation_zoned(struct btrfs_block_group *block_group,
3839			       struct find_free_extent_ctl *ffe_ctl,
3840			       struct btrfs_block_group **bg_ret)
3841{
3842	struct btrfs_fs_info *fs_info = block_group->fs_info;
3843	struct btrfs_space_info *space_info = block_group->space_info;
3844	struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
3845	u64 start = block_group->start;
3846	u64 num_bytes = ffe_ctl->num_bytes;
3847	u64 avail;
3848	u64 bytenr = block_group->start;
3849	u64 log_bytenr;
3850	u64 data_reloc_bytenr;
3851	int ret = 0;
3852	bool skip = false;
3853
3854	ASSERT(btrfs_is_zoned(block_group->fs_info));
 
 
 
 
3855
3856	/*
3857	 * Do not allow non-tree-log blocks in the dedicated tree-log block
3858	 * group, and vice versa.
3859	 */
3860	spin_lock(&fs_info->treelog_bg_lock);
3861	log_bytenr = fs_info->treelog_bg;
3862	if (log_bytenr && ((ffe_ctl->for_treelog && bytenr != log_bytenr) ||
3863			   (!ffe_ctl->for_treelog && bytenr == log_bytenr)))
3864		skip = true;
3865	spin_unlock(&fs_info->treelog_bg_lock);
3866	if (skip)
3867		return 1;
3868
3869	/*
3870	 * Do not allow non-relocation blocks in the dedicated relocation block
3871	 * group, and vice versa.
3872	 */
3873	spin_lock(&fs_info->relocation_bg_lock);
3874	data_reloc_bytenr = fs_info->data_reloc_bg;
3875	if (data_reloc_bytenr &&
3876	    ((ffe_ctl->for_data_reloc && bytenr != data_reloc_bytenr) ||
3877	     (!ffe_ctl->for_data_reloc && bytenr == data_reloc_bytenr)))
3878		skip = true;
3879	spin_unlock(&fs_info->relocation_bg_lock);
3880	if (skip)
3881		return 1;
 
 
 
 
 
3882
3883	/* Check RO and no space case before trying to activate it */
3884	spin_lock(&block_group->lock);
3885	if (block_group->ro || btrfs_zoned_bg_is_full(block_group)) {
3886		ret = 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3887		/*
3888		 * May need to clear fs_info->{treelog,data_reloc}_bg.
3889		 * Return the error after taking the locks.
 
 
3890		 */
3891	}
3892	spin_unlock(&block_group->lock);
3893
3894	/* Metadata block group is activated at write time. */
3895	if (!ret && (block_group->flags & BTRFS_BLOCK_GROUP_DATA) &&
3896	    !btrfs_zone_activate(block_group)) {
3897		ret = 1;
3898		/*
3899		 * May need to clear fs_info->{treelog,data_reloc}_bg.
3900		 * Return the error after taking the locks.
3901		 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3902	}
 
 
3903
3904	spin_lock(&space_info->lock);
3905	spin_lock(&block_group->lock);
3906	spin_lock(&fs_info->treelog_bg_lock);
3907	spin_lock(&fs_info->relocation_bg_lock);
3908
3909	if (ret)
3910		goto out;
 
3911
3912	ASSERT(!ffe_ctl->for_treelog ||
3913	       block_group->start == fs_info->treelog_bg ||
3914	       fs_info->treelog_bg == 0);
3915	ASSERT(!ffe_ctl->for_data_reloc ||
3916	       block_group->start == fs_info->data_reloc_bg ||
3917	       fs_info->data_reloc_bg == 0);
3918
3919	if (block_group->ro ||
3920	    (!ffe_ctl->for_data_reloc &&
3921	     test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags))) {
3922		ret = 1;
3923		goto out;
3924	}
3925
3926	/*
3927	 * Do not allow currently using block group to be tree-log dedicated
3928	 * block group.
3929	 */
3930	if (ffe_ctl->for_treelog && !fs_info->treelog_bg &&
3931	    (block_group->used || block_group->reserved)) {
3932		ret = 1;
3933		goto out;
3934	}
3935
3936	/*
3937	 * Do not allow currently used block group to be the data relocation
3938	 * dedicated block group.
3939	 */
3940	if (ffe_ctl->for_data_reloc && !fs_info->data_reloc_bg &&
3941	    (block_group->used || block_group->reserved)) {
3942		ret = 1;
3943		goto out;
 
 
 
3944	}
 
 
3945
3946	WARN_ON_ONCE(block_group->alloc_offset > block_group->zone_capacity);
3947	avail = block_group->zone_capacity - block_group->alloc_offset;
3948	if (avail < num_bytes) {
3949		if (ffe_ctl->max_extent_size < avail) {
3950			/*
3951			 * With sequential allocator, free space is always
3952			 * contiguous
3953			 */
3954			ffe_ctl->max_extent_size = avail;
3955			ffe_ctl->total_free_space = avail;
3956		}
3957		ret = 1;
3958		goto out;
3959	}
3960
3961	if (ffe_ctl->for_treelog && !fs_info->treelog_bg)
3962		fs_info->treelog_bg = block_group->start;
 
 
 
 
 
3963
3964	if (ffe_ctl->for_data_reloc) {
3965		if (!fs_info->data_reloc_bg)
3966			fs_info->data_reloc_bg = block_group->start;
3967		/*
3968		 * Do not allow allocations from this block group, unless it is
3969		 * for data relocation. Compared to increasing the ->ro, setting
3970		 * the ->zoned_data_reloc_ongoing flag still allows nocow
3971		 * writers to come in. See btrfs_inc_nocow_writers().
3972		 *
3973		 * We need to disable an allocation to avoid an allocation of
3974		 * regular (non-relocation data) extent. With mix of relocation
3975		 * extents and regular extents, we can dispatch WRITE commands
3976		 * (for relocation extents) and ZONE APPEND commands (for
3977		 * regular extents) at the same time to the same zone, which
3978		 * easily break the write pointer.
3979		 *
3980		 * Also, this flag avoids this block group to be zone finished.
3981		 */
3982		set_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags);
3983	}
3984
3985	ffe_ctl->found_offset = start + block_group->alloc_offset;
3986	block_group->alloc_offset += num_bytes;
3987	spin_lock(&ctl->tree_lock);
3988	ctl->free_space -= num_bytes;
3989	spin_unlock(&ctl->tree_lock);
 
 
 
 
 
 
3990
3991	/*
3992	 * We do not check if found_offset is aligned to stripesize. The
3993	 * address is anyway rewritten when using zone append writing.
 
 
3994	 */
 
3995
3996	ffe_ctl->search_start = ffe_ctl->found_offset;
3997
3998out:
3999	if (ret && ffe_ctl->for_treelog)
4000		fs_info->treelog_bg = 0;
4001	if (ret && ffe_ctl->for_data_reloc)
4002		fs_info->data_reloc_bg = 0;
4003	spin_unlock(&fs_info->relocation_bg_lock);
4004	spin_unlock(&fs_info->treelog_bg_lock);
4005	spin_unlock(&block_group->lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4006	spin_unlock(&space_info->lock);
4007	return ret;
4008}
4009
4010static int do_allocation(struct btrfs_block_group *block_group,
4011			 struct find_free_extent_ctl *ffe_ctl,
4012			 struct btrfs_block_group **bg_ret)
4013{
4014	switch (ffe_ctl->policy) {
4015	case BTRFS_EXTENT_ALLOC_CLUSTERED:
4016		return do_allocation_clustered(block_group, ffe_ctl, bg_ret);
4017	case BTRFS_EXTENT_ALLOC_ZONED:
4018		return do_allocation_zoned(block_group, ffe_ctl, bg_ret);
4019	default:
4020		BUG();
 
 
 
 
 
 
 
 
 
4021	}
 
 
 
 
 
 
 
 
 
4022}
4023
4024static void release_block_group(struct btrfs_block_group *block_group,
4025				struct find_free_extent_ctl *ffe_ctl,
4026				int delalloc)
4027{
4028	switch (ffe_ctl->policy) {
4029	case BTRFS_EXTENT_ALLOC_CLUSTERED:
4030		ffe_ctl->retry_uncached = false;
4031		break;
4032	case BTRFS_EXTENT_ALLOC_ZONED:
4033		/* Nothing to do */
4034		break;
4035	default:
4036		BUG();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4037	}
4038
4039	BUG_ON(btrfs_bg_flags_to_raid_index(block_group->flags) !=
4040	       ffe_ctl->index);
4041	btrfs_release_block_group(block_group, delalloc);
4042}
4043
4044static void found_extent_clustered(struct find_free_extent_ctl *ffe_ctl,
4045				   struct btrfs_key *ins)
4046{
4047	struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;
 
 
 
 
4048
4049	if (!ffe_ctl->use_cluster && last_ptr) {
4050		spin_lock(&last_ptr->lock);
4051		last_ptr->window_start = ins->objectid;
4052		spin_unlock(&last_ptr->lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4053	}
 
 
4054}
4055
4056static void found_extent(struct find_free_extent_ctl *ffe_ctl,
4057			 struct btrfs_key *ins)
 
 
 
 
4058{
4059	switch (ffe_ctl->policy) {
4060	case BTRFS_EXTENT_ALLOC_CLUSTERED:
4061		found_extent_clustered(ffe_ctl, ins);
4062		break;
4063	case BTRFS_EXTENT_ALLOC_ZONED:
4064		/* Nothing to do */
4065		break;
4066	default:
4067		BUG();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4068	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4069}
4070
4071static int can_allocate_chunk_zoned(struct btrfs_fs_info *fs_info,
4072				    struct find_free_extent_ctl *ffe_ctl)
 
 
 
 
 
 
4073{
4074	/* Block group's activeness is not a requirement for METADATA block groups. */
4075	if (!(ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA))
4076		return 0;
 
 
4077
4078	/* If we can activate new zone, just allocate a chunk and use it */
4079	if (btrfs_can_activate_zone(fs_info->fs_devices, ffe_ctl->flags))
4080		return 0;
 
 
4081
4082	/*
4083	 * We already reached the max active zones. Try to finish one block
4084	 * group to make a room for a new block group. This is only possible
4085	 * for a data block group because btrfs_zone_finish() may need to wait
4086	 * for a running transaction which can cause a deadlock for metadata
4087	 * allocation.
4088	 */
4089	if (ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA) {
4090		int ret = btrfs_zone_finish_one_bg(fs_info);
4091
4092		if (ret == 1)
4093			return 0;
4094		else if (ret < 0)
4095			return ret;
 
 
 
 
 
 
 
4096	}
4097
4098	/*
4099	 * If we have enough free space left in an already active block group
4100	 * and we can't activate any other zone now, do not allow allocating a
4101	 * new chunk and let find_free_extent() retry with a smaller size.
4102	 */
4103	if (ffe_ctl->max_extent_size >= ffe_ctl->min_alloc_size)
4104		return -ENOSPC;
4105
4106	/*
4107	 * Even min_alloc_size is not left in any block groups. Since we cannot
4108	 * activate a new block group, allocating it may not help. Let's tell a
4109	 * caller to try again and hope it progress something by writing some
4110	 * parts of the region. That is only possible for data block groups,
4111	 * where a part of the region can be written.
4112	 */
4113	if (ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA)
4114		return -EAGAIN;
 
 
 
 
4115
4116	/*
4117	 * We cannot activate a new block group and no enough space left in any
4118	 * block groups. So, allocating a new block group may not help. But,
4119	 * there is nothing to do anyway, so let's go with it.
4120	 */
4121	return 0;
4122}
 
4123
4124static int can_allocate_chunk(struct btrfs_fs_info *fs_info,
4125			      struct find_free_extent_ctl *ffe_ctl)
4126{
4127	switch (ffe_ctl->policy) {
4128	case BTRFS_EXTENT_ALLOC_CLUSTERED:
4129		return 0;
4130	case BTRFS_EXTENT_ALLOC_ZONED:
4131		return can_allocate_chunk_zoned(fs_info, ffe_ctl);
4132	default:
4133		BUG();
4134	}
 
 
4135}
4136
4137/*
4138 * Return >0 means caller needs to re-search for free extent
4139 * Return 0 means we have the needed free extent.
4140 * Return <0 means we failed to locate any free extent.
4141 */
4142static int find_free_extent_update_loop(struct btrfs_fs_info *fs_info,
4143					struct btrfs_key *ins,
4144					struct find_free_extent_ctl *ffe_ctl,
4145					bool full_search)
4146{
4147	struct btrfs_root *root = fs_info->chunk_root;
4148	int ret;
4149
4150	if ((ffe_ctl->loop == LOOP_CACHING_NOWAIT) &&
4151	    ffe_ctl->have_caching_bg && !ffe_ctl->orig_have_caching_bg)
4152		ffe_ctl->orig_have_caching_bg = true;
4153
4154	if (ins->objectid) {
4155		found_extent(ffe_ctl, ins);
4156		return 0;
4157	}
4158
4159	if (ffe_ctl->loop >= LOOP_CACHING_WAIT && ffe_ctl->have_caching_bg)
4160		return 1;
4161
4162	ffe_ctl->index++;
4163	if (ffe_ctl->index < BTRFS_NR_RAID_TYPES)
4164		return 1;
4165
4166	/* See the comments for btrfs_loop_type for an explanation of the phases. */
4167	if (ffe_ctl->loop < LOOP_NO_EMPTY_SIZE) {
4168		ffe_ctl->index = 0;
4169		/*
4170		 * We want to skip the LOOP_CACHING_WAIT step if we don't have
4171		 * any uncached bgs and we've already done a full search
4172		 * through.
4173		 */
4174		if (ffe_ctl->loop == LOOP_CACHING_NOWAIT &&
4175		    (!ffe_ctl->orig_have_caching_bg && full_search))
4176			ffe_ctl->loop++;
4177		ffe_ctl->loop++;
4178
4179		if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {
4180			struct btrfs_trans_handle *trans;
4181			int exist = 0;
4182
4183			/* Check if allocation policy allows to create a new chunk */
4184			ret = can_allocate_chunk(fs_info, ffe_ctl);
4185			if (ret)
4186				return ret;
4187
4188			trans = current->journal_info;
4189			if (trans)
4190				exist = 1;
4191			else
4192				trans = btrfs_join_transaction(root);
4193
4194			if (IS_ERR(trans)) {
4195				ret = PTR_ERR(trans);
4196				return ret;
4197			}
4198
4199			ret = btrfs_chunk_alloc(trans, ffe_ctl->flags,
4200						CHUNK_ALLOC_FORCE_FOR_EXTENT);
4201
4202			/* Do not bail out on ENOSPC since we can do more. */
4203			if (ret == -ENOSPC) {
4204				ret = 0;
4205				ffe_ctl->loop++;
4206			}
4207			else if (ret < 0)
4208				btrfs_abort_transaction(trans, ret);
4209			else
4210				ret = 0;
4211			if (!exist)
4212				btrfs_end_transaction(trans);
4213			if (ret)
4214				return ret;
4215		}
4216
4217		if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {
4218			if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)
4219				return -ENOSPC;
4220
4221			/*
4222			 * Don't loop again if we already have no empty_size and
4223			 * no empty_cluster.
4224			 */
4225			if (ffe_ctl->empty_size == 0 &&
4226			    ffe_ctl->empty_cluster == 0)
4227				return -ENOSPC;
4228			ffe_ctl->empty_size = 0;
4229			ffe_ctl->empty_cluster = 0;
4230		}
4231		return 1;
4232	}
4233	return -ENOSPC;
 
 
 
 
 
 
4234}
4235
4236static bool find_free_extent_check_size_class(struct find_free_extent_ctl *ffe_ctl,
4237					      struct btrfs_block_group *bg)
 
 
4238{
4239	if (ffe_ctl->policy == BTRFS_EXTENT_ALLOC_ZONED)
4240		return true;
4241	if (!btrfs_block_group_should_use_size_class(bg))
4242		return true;
4243	if (ffe_ctl->loop >= LOOP_WRONG_SIZE_CLASS)
4244		return true;
4245	if (ffe_ctl->loop >= LOOP_UNSET_SIZE_CLASS &&
4246	    bg->size_class == BTRFS_BG_SZ_NONE)
4247		return true;
4248	return ffe_ctl->size_class == bg->size_class;
4249}
4250
4251static int prepare_allocation_clustered(struct btrfs_fs_info *fs_info,
4252					struct find_free_extent_ctl *ffe_ctl,
4253					struct btrfs_space_info *space_info,
4254					struct btrfs_key *ins)
4255{
4256	/*
4257	 * If our free space is heavily fragmented we may not be able to make
4258	 * big contiguous allocations, so instead of doing the expensive search
4259	 * for free space, simply return ENOSPC with our max_extent_size so we
4260	 * can go ahead and search for a more manageable chunk.
4261	 *
4262	 * If our max_extent_size is large enough for our allocation simply
4263	 * disable clustering since we will likely not be able to find enough
4264	 * space to create a cluster and induce latency trying.
4265	 */
4266	if (space_info->max_extent_size) {
4267		spin_lock(&space_info->lock);
4268		if (space_info->max_extent_size &&
4269		    ffe_ctl->num_bytes > space_info->max_extent_size) {
4270			ins->offset = space_info->max_extent_size;
4271			spin_unlock(&space_info->lock);
4272			return -ENOSPC;
4273		} else if (space_info->max_extent_size) {
4274			ffe_ctl->use_cluster = false;
4275		}
4276		spin_unlock(&space_info->lock);
 
 
 
 
 
4277	}
 
 
4278
4279	ffe_ctl->last_ptr = fetch_cluster_info(fs_info, space_info,
4280					       &ffe_ctl->empty_cluster);
4281	if (ffe_ctl->last_ptr) {
4282		struct btrfs_free_cluster *last_ptr = ffe_ctl->last_ptr;
 
 
4283
4284		spin_lock(&last_ptr->lock);
4285		if (last_ptr->block_group)
4286			ffe_ctl->hint_byte = last_ptr->window_start;
4287		if (last_ptr->fragmented) {
4288			/*
4289			 * We still set window_start so we can keep track of the
4290			 * last place we found an allocation to try and save
4291			 * some time.
4292			 */
4293			ffe_ctl->hint_byte = last_ptr->window_start;
4294			ffe_ctl->use_cluster = false;
4295		}
4296		spin_unlock(&last_ptr->lock);
4297	}
 
 
 
 
 
 
 
 
 
 
4298
 
4299	return 0;
4300}
4301
4302static int prepare_allocation_zoned(struct btrfs_fs_info *fs_info,
4303				    struct find_free_extent_ctl *ffe_ctl)
4304{
4305	if (ffe_ctl->for_treelog) {
4306		spin_lock(&fs_info->treelog_bg_lock);
4307		if (fs_info->treelog_bg)
4308			ffe_ctl->hint_byte = fs_info->treelog_bg;
4309		spin_unlock(&fs_info->treelog_bg_lock);
4310	} else if (ffe_ctl->for_data_reloc) {
4311		spin_lock(&fs_info->relocation_bg_lock);
4312		if (fs_info->data_reloc_bg)
4313			ffe_ctl->hint_byte = fs_info->data_reloc_bg;
4314		spin_unlock(&fs_info->relocation_bg_lock);
4315	} else if (ffe_ctl->flags & BTRFS_BLOCK_GROUP_DATA) {
4316		struct btrfs_block_group *block_group;
4317
4318		spin_lock(&fs_info->zone_active_bgs_lock);
4319		list_for_each_entry(block_group, &fs_info->zone_active_bgs, active_bg_list) {
4320			/*
4321			 * No lock is OK here because avail is monotinically
4322			 * decreasing, and this is just a hint.
4323			 */
4324			u64 avail = block_group->zone_capacity - block_group->alloc_offset;
4325
4326			if (block_group_bits(block_group, ffe_ctl->flags) &&
4327			    avail >= ffe_ctl->num_bytes) {
4328				ffe_ctl->hint_byte = block_group->start;
4329				break;
4330			}
4331		}
4332		spin_unlock(&fs_info->zone_active_bgs_lock);
4333	}
4334
 
4335	return 0;
4336}
4337
4338static int prepare_allocation(struct btrfs_fs_info *fs_info,
4339			      struct find_free_extent_ctl *ffe_ctl,
4340			      struct btrfs_space_info *space_info,
4341			      struct btrfs_key *ins)
4342{
4343	switch (ffe_ctl->policy) {
4344	case BTRFS_EXTENT_ALLOC_CLUSTERED:
4345		return prepare_allocation_clustered(fs_info, ffe_ctl,
4346						    space_info, ins);
4347	case BTRFS_EXTENT_ALLOC_ZONED:
4348		return prepare_allocation_zoned(fs_info, ffe_ctl);
4349	default:
4350		BUG();
4351	}
 
 
4352}
4353
 
 
 
 
 
 
 
 
 
 
 
 
4354/*
4355 * walks the btree of allocated extents and find a hole of a given size.
4356 * The key ins is changed to record the hole:
4357 * ins->objectid == start position
4358 * ins->flags = BTRFS_EXTENT_ITEM_KEY
4359 * ins->offset == the size of the hole.
4360 * Any available blocks before search_start are skipped.
4361 *
4362 * If there is no suitable free space, we will record the max size of
4363 * the free space extent currently.
4364 *
4365 * The overall logic and call chain:
4366 *
4367 * find_free_extent()
4368 * |- Iterate through all block groups
4369 * |  |- Get a valid block group
4370 * |  |- Try to do clustered allocation in that block group
4371 * |  |- Try to do unclustered allocation in that block group
4372 * |  |- Check if the result is valid
4373 * |  |  |- If valid, then exit
4374 * |  |- Jump to next block group
4375 * |
4376 * |- Push harder to find free extents
4377 *    |- If not found, re-iterate all block groups
4378 */
4379static noinline int find_free_extent(struct btrfs_root *root,
4380				     struct btrfs_key *ins,
4381				     struct find_free_extent_ctl *ffe_ctl)
4382{
4383	struct btrfs_fs_info *fs_info = root->fs_info;
4384	int ret = 0;
4385	int cache_block_group_error = 0;
4386	struct btrfs_block_group *block_group = NULL;
 
 
 
 
 
 
4387	struct btrfs_space_info *space_info;
4388	bool full_search = false;
4389
4390	WARN_ON(ffe_ctl->num_bytes < fs_info->sectorsize);
4391
4392	ffe_ctl->search_start = 0;
4393	/* For clustered allocation */
4394	ffe_ctl->empty_cluster = 0;
4395	ffe_ctl->last_ptr = NULL;
4396	ffe_ctl->use_cluster = true;
4397	ffe_ctl->have_caching_bg = false;
4398	ffe_ctl->orig_have_caching_bg = false;
4399	ffe_ctl->index = btrfs_bg_flags_to_raid_index(ffe_ctl->flags);
4400	ffe_ctl->loop = 0;
4401	ffe_ctl->retry_uncached = false;
4402	ffe_ctl->cached = 0;
4403	ffe_ctl->max_extent_size = 0;
4404	ffe_ctl->total_free_space = 0;
4405	ffe_ctl->found_offset = 0;
4406	ffe_ctl->policy = BTRFS_EXTENT_ALLOC_CLUSTERED;
4407	ffe_ctl->size_class = btrfs_calc_block_group_size_class(ffe_ctl->num_bytes);
4408
4409	if (btrfs_is_zoned(fs_info))
4410		ffe_ctl->policy = BTRFS_EXTENT_ALLOC_ZONED;
4411
4412	ins->type = BTRFS_EXTENT_ITEM_KEY;
4413	ins->objectid = 0;
4414	ins->offset = 0;
4415
4416	trace_find_free_extent(root, ffe_ctl);
4417
4418	space_info = btrfs_find_space_info(fs_info, ffe_ctl->flags);
4419	if (!space_info) {
4420		btrfs_err(fs_info, "No space info for %llu", ffe_ctl->flags);
4421		return -ENOSPC;
4422	}
4423
4424	ret = prepare_allocation(fs_info, ffe_ctl, space_info, ins);
4425	if (ret < 0)
4426		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4427
4428	ffe_ctl->search_start = max(ffe_ctl->search_start,
4429				    first_logical_byte(fs_info));
4430	ffe_ctl->search_start = max(ffe_ctl->search_start, ffe_ctl->hint_byte);
4431	if (ffe_ctl->search_start == ffe_ctl->hint_byte) {
4432		block_group = btrfs_lookup_block_group(fs_info,
4433						       ffe_ctl->search_start);
 
 
 
 
4434		/*
4435		 * we don't want to use the block group if it doesn't match our
4436		 * allocation bits, or if its not cached.
4437		 *
4438		 * However if we are re-searching with an ideal block group
4439		 * picked out then we don't care that the block group is cached.
4440		 */
4441		if (block_group && block_group_bits(block_group, ffe_ctl->flags) &&
4442		    block_group->cached != BTRFS_CACHE_NO) {
4443			down_read(&space_info->groups_sem);
4444			if (list_empty(&block_group->list) ||
4445			    block_group->ro) {
4446				/*
4447				 * someone is removing this block group,
4448				 * we can't jump into the have_block_group
4449				 * target because our list pointers are not
4450				 * valid
4451				 */
4452				btrfs_put_block_group(block_group);
4453				up_read(&space_info->groups_sem);
4454			} else {
4455				ffe_ctl->index = btrfs_bg_flags_to_raid_index(
4456							block_group->flags);
4457				btrfs_lock_block_group(block_group,
4458						       ffe_ctl->delalloc);
4459				ffe_ctl->hinted = true;
4460				goto have_block_group;
4461			}
4462		} else if (block_group) {
4463			btrfs_put_block_group(block_group);
4464		}
4465	}
4466search:
4467	trace_find_free_extent_search_loop(root, ffe_ctl);
4468	ffe_ctl->have_caching_bg = false;
4469	if (ffe_ctl->index == btrfs_bg_flags_to_raid_index(ffe_ctl->flags) ||
4470	    ffe_ctl->index == 0)
4471		full_search = true;
4472	down_read(&space_info->groups_sem);
4473	list_for_each_entry(block_group,
4474			    &space_info->block_groups[ffe_ctl->index], list) {
4475		struct btrfs_block_group *bg_ret;
4476
4477		ffe_ctl->hinted = false;
4478		/* If the block group is read-only, we can skip it entirely. */
4479		if (unlikely(block_group->ro)) {
4480			if (ffe_ctl->for_treelog)
4481				btrfs_clear_treelog_bg(block_group);
4482			if (ffe_ctl->for_data_reloc)
4483				btrfs_clear_data_reloc_bg(block_group);
4484			continue;
4485		}
4486
4487		btrfs_grab_block_group(block_group, ffe_ctl->delalloc);
4488		ffe_ctl->search_start = block_group->start;
4489
4490		/*
4491		 * this can happen if we end up cycling through all the
4492		 * raid types, but we want to make sure we only allocate
4493		 * for the proper type.
4494		 */
4495		if (!block_group_bits(block_group, ffe_ctl->flags)) {
4496			u64 extra = BTRFS_BLOCK_GROUP_DUP |
4497				BTRFS_BLOCK_GROUP_RAID1_MASK |
4498				BTRFS_BLOCK_GROUP_RAID56_MASK |
4499				BTRFS_BLOCK_GROUP_RAID10;
4500
4501			/*
4502			 * if they asked for extra copies and this block group
4503			 * doesn't provide them, bail.  This does allow us to
4504			 * fill raid0 from raid1.
4505			 */
4506			if ((ffe_ctl->flags & extra) && !(block_group->flags & extra))
4507				goto loop;
4508
4509			/*
4510			 * This block group has different flags than we want.
4511			 * It's possible that we have MIXED_GROUP flag but no
4512			 * block group is mixed.  Just skip such block group.
4513			 */
4514			btrfs_release_block_group(block_group, ffe_ctl->delalloc);
4515			continue;
4516		}
4517
4518have_block_group:
4519		trace_find_free_extent_have_block_group(root, ffe_ctl, block_group);
4520		ffe_ctl->cached = btrfs_block_group_done(block_group);
4521		if (unlikely(!ffe_ctl->cached)) {
4522			ffe_ctl->have_caching_bg = true;
4523			ret = btrfs_cache_block_group(block_group, false);
 
 
 
 
 
 
4524
 
 
 
 
 
4525			/*
4526			 * If we get ENOMEM here or something else we want to
4527			 * try other block groups, because it may not be fatal.
4528			 * However if we can't find anything else we need to
4529			 * save our return here so that we return the actual
4530			 * error that caused problems, not ENOSPC.
4531			 */
4532			if (ret < 0) {
4533				if (!cache_block_group_error)
4534					cache_block_group_error = ret;
4535				ret = 0;
4536				goto loop;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4537			}
4538			ret = 0;
4539		}
4540
4541		if (unlikely(block_group->cached == BTRFS_CACHE_ERROR)) {
4542			if (!cache_block_group_error)
4543				cache_block_group_error = -EIO;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4544			goto loop;
4545		}
4546
4547		if (!find_free_extent_check_size_class(ffe_ctl, block_group))
 
 
 
 
 
4548			goto loop;
 
 
4549
4550		bg_ret = NULL;
4551		ret = do_allocation(block_group, ffe_ctl, &bg_ret);
4552		if (ret > 0)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4553			goto loop;
4554
4555		if (bg_ret && bg_ret != block_group) {
4556			btrfs_release_block_group(block_group, ffe_ctl->delalloc);
4557			block_group = bg_ret;
4558		}
4559
4560		/* Checks */
4561		ffe_ctl->search_start = round_up(ffe_ctl->found_offset,
4562						 fs_info->stripesize);
4563
4564		/* move on to the next group */
4565		if (ffe_ctl->search_start + ffe_ctl->num_bytes >
4566		    block_group->start + block_group->length) {
4567			btrfs_add_free_space_unused(block_group,
4568					    ffe_ctl->found_offset,
4569					    ffe_ctl->num_bytes);
4570			goto loop;
4571		}
4572
4573		if (ffe_ctl->found_offset < ffe_ctl->search_start)
4574			btrfs_add_free_space_unused(block_group,
4575					ffe_ctl->found_offset,
4576					ffe_ctl->search_start - ffe_ctl->found_offset);
4577
4578		ret = btrfs_add_reserved_bytes(block_group, ffe_ctl->ram_bytes,
4579					       ffe_ctl->num_bytes,
4580					       ffe_ctl->delalloc,
4581					       ffe_ctl->loop >= LOOP_WRONG_SIZE_CLASS);
4582		if (ret == -EAGAIN) {
4583			btrfs_add_free_space_unused(block_group,
4584					ffe_ctl->found_offset,
4585					ffe_ctl->num_bytes);
4586			goto loop;
4587		}
4588		btrfs_inc_block_group_reservations(block_group);
4589
4590		/* we are all good, lets return */
4591		ins->objectid = ffe_ctl->search_start;
4592		ins->offset = ffe_ctl->num_bytes;
4593
4594		trace_btrfs_reserve_extent(block_group, ffe_ctl);
4595		btrfs_release_block_group(block_group, ffe_ctl->delalloc);
 
 
 
 
 
 
 
4596		break;
4597loop:
4598		if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&
4599		    !ffe_ctl->retry_uncached) {
4600			ffe_ctl->retry_uncached = true;
4601			btrfs_wait_block_group_cache_progress(block_group,
4602						ffe_ctl->num_bytes +
4603						ffe_ctl->empty_cluster +
4604						ffe_ctl->empty_size);
4605			goto have_block_group;
4606		}
4607		release_block_group(block_group, ffe_ctl, ffe_ctl->delalloc);
4608		cond_resched();
4609	}
4610	up_read(&space_info->groups_sem);
4611
4612	ret = find_free_extent_update_loop(fs_info, ins, ffe_ctl, full_search);
4613	if (ret > 0)
4614		goto search;
4615
4616	if (ret == -ENOSPC && !cache_block_group_error) {
4617		/*
4618		 * Use ffe_ctl->total_free_space as fallback if we can't find
4619		 * any contiguous hole.
4620		 */
4621		if (!ffe_ctl->max_extent_size)
4622			ffe_ctl->max_extent_size = ffe_ctl->total_free_space;
4623		spin_lock(&space_info->lock);
4624		space_info->max_extent_size = ffe_ctl->max_extent_size;
4625		spin_unlock(&space_info->lock);
4626		ins->offset = ffe_ctl->max_extent_size;
4627	} else if (ret == -ENOSPC) {
4628		ret = cache_block_group_error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4629	}
 
 
4630	return ret;
4631}
4632
4633/*
4634 * Entry point to the extent allocator. Tries to find a hole that is at least
4635 * as big as @num_bytes.
4636 *
4637 * @root           -	The root that will contain this extent
4638 *
4639 * @ram_bytes      -	The amount of space in ram that @num_bytes take. This
4640 *			is used for accounting purposes. This value differs
4641 *			from @num_bytes only in the case of compressed extents.
4642 *
4643 * @num_bytes      -	Number of bytes to allocate on-disk.
4644 *
4645 * @min_alloc_size -	Indicates the minimum amount of space that the
4646 *			allocator should try to satisfy. In some cases
4647 *			@num_bytes may be larger than what is required and if
4648 *			the filesystem is fragmented then allocation fails.
4649 *			However, the presence of @min_alloc_size gives a
4650 *			chance to try and satisfy the smaller allocation.
4651 *
4652 * @empty_size     -	A hint that you plan on doing more COW. This is the
4653 *			size in bytes the allocator should try to find free
4654 *			next to the block it returns.  This is just a hint and
4655 *			may be ignored by the allocator.
4656 *
4657 * @hint_byte      -	Hint to the allocator to start searching above the byte
4658 *			address passed. It might be ignored.
4659 *
4660 * @ins            -	This key is modified to record the found hole. It will
4661 *			have the following values:
4662 *			ins->objectid == start position
4663 *			ins->flags = BTRFS_EXTENT_ITEM_KEY
4664 *			ins->offset == the size of the hole.
4665 *
4666 * @is_data        -	Boolean flag indicating whether an extent is
4667 *			allocated for data (true) or metadata (false)
4668 *
4669 * @delalloc       -	Boolean flag indicating whether this allocation is for
4670 *			delalloc or not. If 'true' data_rwsem of block groups
4671 *			is going to be acquired.
4672 *
4673 *
4674 * Returns 0 when an allocation succeeded or < 0 when an error occurred. In
4675 * case -ENOSPC is returned then @ins->offset will contain the size of the
4676 * largest available hole the allocator managed to find.
4677 */
4678int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes,
 
4679			 u64 num_bytes, u64 min_alloc_size,
4680			 u64 empty_size, u64 hint_byte,
4681			 struct btrfs_key *ins, int is_data, int delalloc)
4682{
4683	struct btrfs_fs_info *fs_info = root->fs_info;
4684	struct find_free_extent_ctl ffe_ctl = {};
4685	bool final_tried = num_bytes == min_alloc_size;
4686	u64 flags;
4687	int ret;
4688	bool for_treelog = (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
4689	bool for_data_reloc = (btrfs_is_data_reloc_root(root) && is_data);
4690
4691	flags = get_alloc_profile_by_root(root, is_data);
4692again:
4693	WARN_ON(num_bytes < fs_info->sectorsize);
 
 
 
 
 
 
 
 
 
 
 
 
4694
4695	ffe_ctl.ram_bytes = ram_bytes;
4696	ffe_ctl.num_bytes = num_bytes;
4697	ffe_ctl.min_alloc_size = min_alloc_size;
4698	ffe_ctl.empty_size = empty_size;
4699	ffe_ctl.flags = flags;
4700	ffe_ctl.delalloc = delalloc;
4701	ffe_ctl.hint_byte = hint_byte;
4702	ffe_ctl.for_treelog = for_treelog;
4703	ffe_ctl.for_data_reloc = for_data_reloc;
4704
4705	ret = find_free_extent(root, ins, &ffe_ctl);
4706	if (!ret && !is_data) {
4707		btrfs_dec_block_group_reservations(fs_info, ins->objectid);
4708	} else if (ret == -ENOSPC) {
4709		if (!final_tried && ins->offset) {
4710			num_bytes = min(num_bytes >> 1, ins->offset);
4711			num_bytes = round_down(num_bytes,
4712					       fs_info->sectorsize);
4713			num_bytes = max(num_bytes, min_alloc_size);
4714			ram_bytes = num_bytes;
 
 
 
 
 
4715			if (num_bytes == min_alloc_size)
4716				final_tried = true;
4717			goto again;
4718		} else if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
4719			struct btrfs_space_info *sinfo;
4720
4721			sinfo = btrfs_find_space_info(fs_info, flags);
4722			btrfs_err(fs_info,
4723	"allocation failed flags %llu, wanted %llu tree-log %d, relocation: %d",
4724				  flags, num_bytes, for_treelog, for_data_reloc);
4725			if (sinfo)
4726				btrfs_dump_space_info(fs_info, sinfo,
4727						      num_bytes, 1);
4728		}
4729	}
4730
 
 
4731	return ret;
4732}
4733
4734int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
4735			       u64 start, u64 len, int delalloc)
4736{
4737	struct btrfs_block_group *cache;
 
4738
4739	cache = btrfs_lookup_block_group(fs_info, start);
4740	if (!cache) {
4741		btrfs_err(fs_info, "Unable to find block group for %llu",
4742			  start);
4743		return -ENOSPC;
4744	}
4745
4746	btrfs_add_free_space(cache, start, len);
4747	btrfs_free_reserved_bytes(cache, len, delalloc);
4748	trace_btrfs_reserved_extent_free(fs_info, start, len);
4749
 
 
 
 
 
 
4750	btrfs_put_block_group(cache);
4751	return 0;
4752}
4753
4754int btrfs_pin_reserved_extent(struct btrfs_trans_handle *trans,
4755			      const struct extent_buffer *eb)
4756{
4757	struct btrfs_block_group *cache;
4758	int ret = 0;
4759
4760	cache = btrfs_lookup_block_group(trans->fs_info, eb->start);
4761	if (!cache) {
4762		btrfs_err(trans->fs_info, "unable to find block group for %llu",
4763			  eb->start);
4764		return -ENOSPC;
4765	}
4766
4767	ret = pin_down_extent(trans, cache, eb->start, eb->len, 1);
4768	btrfs_put_block_group(cache);
4769	return ret;
4770}
4771
4772static int alloc_reserved_extent(struct btrfs_trans_handle *trans, u64 bytenr,
4773				 u64 num_bytes)
4774{
4775	struct btrfs_fs_info *fs_info = trans->fs_info;
4776	int ret;
4777
4778	ret = remove_from_free_space_tree(trans, bytenr, num_bytes);
4779	if (ret)
4780		return ret;
4781
4782	ret = btrfs_update_block_group(trans, bytenr, num_bytes, true);
4783	if (ret) {
4784		ASSERT(!ret);
4785		btrfs_err(fs_info, "update block group failed for %llu %llu",
4786			  bytenr, num_bytes);
4787		return ret;
4788	}
4789
4790	trace_btrfs_reserved_extent_alloc(fs_info, bytenr, num_bytes);
4791	return 0;
 
 
4792}
4793
4794static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
 
4795				      u64 parent, u64 root_objectid,
4796				      u64 flags, u64 owner, u64 offset,
4797				      struct btrfs_key *ins, int ref_mod, u64 oref_root)
4798{
4799	struct btrfs_fs_info *fs_info = trans->fs_info;
4800	struct btrfs_root *extent_root;
4801	int ret;
 
4802	struct btrfs_extent_item *extent_item;
4803	struct btrfs_extent_owner_ref *oref;
4804	struct btrfs_extent_inline_ref *iref;
4805	struct btrfs_path *path;
4806	struct extent_buffer *leaf;
4807	int type;
4808	u32 size;
4809	const bool simple_quota = (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE);
4810
4811	if (parent > 0)
4812		type = BTRFS_SHARED_DATA_REF_KEY;
4813	else
4814		type = BTRFS_EXTENT_DATA_REF_KEY;
4815
4816	size = sizeof(*extent_item);
4817	if (simple_quota)
4818		size += btrfs_extent_inline_ref_size(BTRFS_EXTENT_OWNER_REF_KEY);
4819	size += btrfs_extent_inline_ref_size(type);
4820
4821	path = btrfs_alloc_path();
4822	if (!path)
4823		return -ENOMEM;
4824
4825	extent_root = btrfs_extent_root(fs_info, ins->objectid);
4826	ret = btrfs_insert_empty_item(trans, extent_root, path, ins, size);
 
4827	if (ret) {
4828		btrfs_free_path(path);
4829		return ret;
4830	}
4831
4832	leaf = path->nodes[0];
4833	extent_item = btrfs_item_ptr(leaf, path->slots[0],
4834				     struct btrfs_extent_item);
4835	btrfs_set_extent_refs(leaf, extent_item, ref_mod);
4836	btrfs_set_extent_generation(leaf, extent_item, trans->transid);
4837	btrfs_set_extent_flags(leaf, extent_item,
4838			       flags | BTRFS_EXTENT_FLAG_DATA);
4839
4840	iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
4841	if (simple_quota) {
4842		btrfs_set_extent_inline_ref_type(leaf, iref, BTRFS_EXTENT_OWNER_REF_KEY);
4843		oref = (struct btrfs_extent_owner_ref *)(&iref->offset);
4844		btrfs_set_extent_owner_ref_root_id(leaf, oref, oref_root);
4845		iref = (struct btrfs_extent_inline_ref *)(oref + 1);
4846	}
4847	btrfs_set_extent_inline_ref_type(leaf, iref, type);
4848
4849	if (parent > 0) {
4850		struct btrfs_shared_data_ref *ref;
4851		ref = (struct btrfs_shared_data_ref *)(iref + 1);
4852		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
4853		btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
4854	} else {
4855		struct btrfs_extent_data_ref *ref;
4856		ref = (struct btrfs_extent_data_ref *)(&iref->offset);
4857		btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
4858		btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
4859		btrfs_set_extent_data_ref_offset(leaf, ref, offset);
4860		btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
4861	}
4862
4863	btrfs_mark_buffer_dirty(trans, path->nodes[0]);
4864	btrfs_free_path(path);
4865
4866	return alloc_reserved_extent(trans, ins->objectid, ins->offset);
 
 
 
 
 
 
 
4867}
4868
4869static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
4870				     struct btrfs_delayed_ref_node *node,
4871				     struct btrfs_delayed_extent_op *extent_op)
 
 
4872{
4873	struct btrfs_fs_info *fs_info = trans->fs_info;
4874	struct btrfs_root *extent_root;
4875	int ret;
 
4876	struct btrfs_extent_item *extent_item;
4877	struct btrfs_key extent_key;
4878	struct btrfs_tree_block_info *block_info;
4879	struct btrfs_extent_inline_ref *iref;
4880	struct btrfs_path *path;
4881	struct extent_buffer *leaf;
4882	struct btrfs_delayed_tree_ref *ref;
4883	u32 size = sizeof(*extent_item) + sizeof(*iref);
4884	u64 flags = extent_op->flags_to_set;
4885	bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);
4886
4887	ref = btrfs_delayed_node_to_tree_ref(node);
4888
4889	extent_key.objectid = node->bytenr;
4890	if (skinny_metadata) {
4891		extent_key.offset = ref->level;
4892		extent_key.type = BTRFS_METADATA_ITEM_KEY;
4893	} else {
4894		extent_key.offset = node->num_bytes;
4895		extent_key.type = BTRFS_EXTENT_ITEM_KEY;
4896		size += sizeof(*block_info);
4897	}
4898
4899	path = btrfs_alloc_path();
4900	if (!path)
4901		return -ENOMEM;
4902
4903	extent_root = btrfs_extent_root(fs_info, extent_key.objectid);
4904	ret = btrfs_insert_empty_item(trans, extent_root, path, &extent_key,
4905				      size);
4906	if (ret) {
4907		btrfs_free_path(path);
4908		return ret;
4909	}
4910
4911	leaf = path->nodes[0];
4912	extent_item = btrfs_item_ptr(leaf, path->slots[0],
4913				     struct btrfs_extent_item);
4914	btrfs_set_extent_refs(leaf, extent_item, 1);
4915	btrfs_set_extent_generation(leaf, extent_item, trans->transid);
4916	btrfs_set_extent_flags(leaf, extent_item,
4917			       flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
 
4918
4919	if (skinny_metadata) {
4920		iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
4921	} else {
4922		block_info = (struct btrfs_tree_block_info *)(extent_item + 1);
4923		btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);
4924		btrfs_set_tree_block_level(leaf, block_info, ref->level);
4925		iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
4926	}
4927
4928	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY) {
 
 
4929		btrfs_set_extent_inline_ref_type(leaf, iref,
4930						 BTRFS_SHARED_BLOCK_REF_KEY);
4931		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->parent);
4932	} else {
4933		btrfs_set_extent_inline_ref_type(leaf, iref,
4934						 BTRFS_TREE_BLOCK_REF_KEY);
4935		btrfs_set_extent_inline_ref_offset(leaf, iref, ref->root);
4936	}
4937
4938	btrfs_mark_buffer_dirty(trans, leaf);
4939	btrfs_free_path(path);
4940
4941	return alloc_reserved_extent(trans, node->bytenr, fs_info->nodesize);
 
 
 
 
 
 
 
4942}
4943
4944int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
4945				     struct btrfs_root *root, u64 owner,
4946				     u64 offset, u64 ram_bytes,
4947				     struct btrfs_key *ins)
4948{
4949	struct btrfs_ref generic_ref = { 0 };
4950	u64 root_objectid = root->root_key.objectid;
4951	u64 owning_root = root_objectid;
4952
4953	BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);
4954
4955	if (btrfs_is_data_reloc_root(root) && is_fstree(root->relocation_src_root))
4956		owning_root = root->relocation_src_root;
4957
4958	btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_EXTENT,
4959			       ins->objectid, ins->offset, 0, owning_root);
4960	btrfs_init_data_ref(&generic_ref, root_objectid, owner,
4961			    offset, 0, false);
4962	btrfs_ref_tree_mod(root->fs_info, &generic_ref);
4963
4964	return btrfs_add_delayed_data_ref(trans, &generic_ref, ram_bytes);
4965}
4966
4967/*
4968 * this is used by the tree logging recovery code.  It records that
4969 * an extent has been allocated and makes sure to clear the free
4970 * space cache bits as well
4971 */
4972int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
 
4973				   u64 root_objectid, u64 owner, u64 offset,
4974				   struct btrfs_key *ins)
4975{
4976	struct btrfs_fs_info *fs_info = trans->fs_info;
4977	int ret;
4978	struct btrfs_block_group *block_group;
4979	struct btrfs_space_info *space_info;
4980	struct btrfs_squota_delta delta = {
4981		.root = root_objectid,
4982		.num_bytes = ins->offset,
4983		.generation = trans->transid,
4984		.is_data = true,
4985		.is_inc = true,
4986	};
 
 
 
 
 
 
4987
4988	/*
4989	 * Mixed block groups will exclude before processing the log so we only
4990	 * need to do the exclude dance if this fs isn't mixed.
4991	 */
4992	if (!btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
4993		ret = __exclude_logged_extent(fs_info, ins->objectid,
4994					      ins->offset);
4995		if (ret)
4996			return ret;
4997	}
 
 
4998
4999	block_group = btrfs_lookup_block_group(fs_info, ins->objectid);
5000	if (!block_group)
5001		return -EINVAL;
 
 
 
5002
5003	space_info = block_group->space_info;
5004	spin_lock(&space_info->lock);
5005	spin_lock(&block_group->lock);
5006	space_info->bytes_reserved += ins->offset;
5007	block_group->reserved += ins->offset;
5008	spin_unlock(&block_group->lock);
5009	spin_unlock(&space_info->lock);
5010
5011	ret = alloc_reserved_file_extent(trans, 0, root_objectid, 0, owner,
5012					 offset, ins, 1, root_objectid);
5013	if (ret)
5014		btrfs_pin_extent(trans, ins->objectid, ins->offset, 1);
5015	ret = btrfs_record_squota_delta(fs_info, &delta);
5016	btrfs_put_block_group(block_group);
 
 
5017	return ret;
5018}
5019
5020#ifdef CONFIG_BTRFS_DEBUG
5021/*
5022 * Extra safety check in case the extent tree is corrupted and extent allocator
5023 * chooses to use a tree block which is already used and locked.
5024 */
5025static bool check_eb_lock_owner(const struct extent_buffer *eb)
5026{
5027	if (eb->lock_owner == current->pid) {
5028		btrfs_err_rl(eb->fs_info,
5029"tree block %llu owner %llu already locked by pid=%d, extent tree corruption detected",
5030			     eb->start, btrfs_header_owner(eb), current->pid);
5031		return true;
5032	}
5033	return false;
5034}
5035#else
5036static bool check_eb_lock_owner(struct extent_buffer *eb)
5037{
5038	return false;
5039}
5040#endif
5041
5042static struct extent_buffer *
5043btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root,
5044		      u64 bytenr, int level, u64 owner,
5045		      enum btrfs_lock_nesting nest)
5046{
5047	struct btrfs_fs_info *fs_info = root->fs_info;
5048	struct extent_buffer *buf;
5049	u64 lockdep_owner = owner;
5050
5051	buf = btrfs_find_create_tree_block(fs_info, bytenr, owner, level);
5052	if (IS_ERR(buf))
5053		return buf;
5054
5055	if (check_eb_lock_owner(buf)) {
5056		free_extent_buffer(buf);
5057		return ERR_PTR(-EUCLEAN);
5058	}
5059
5060	/*
5061	 * The reloc trees are just snapshots, so we need them to appear to be
5062	 * just like any other fs tree WRT lockdep.
5063	 *
5064	 * The exception however is in replace_path() in relocation, where we
5065	 * hold the lock on the original fs root and then search for the reloc
5066	 * root.  At that point we need to make sure any reloc root buffers are
5067	 * set to the BTRFS_TREE_RELOC_OBJECTID lockdep class in order to make
5068	 * lockdep happy.
5069	 */
5070	if (lockdep_owner == BTRFS_TREE_RELOC_OBJECTID &&
5071	    !test_bit(BTRFS_ROOT_RESET_LOCKDEP_CLASS, &root->state))
5072		lockdep_owner = BTRFS_FS_TREE_OBJECTID;
5073
5074	/* btrfs_clear_buffer_dirty() accesses generation field. */
5075	btrfs_set_header_generation(buf, trans->transid);
5076
5077	/*
5078	 * This needs to stay, because we could allocate a freed block from an
5079	 * old tree into a new tree, so we need to make sure this new block is
5080	 * set to the appropriate level and owner.
5081	 */
5082	btrfs_set_buffer_lockdep_class(lockdep_owner, buf, level);
5083
5084	__btrfs_tree_lock(buf, nest);
5085	btrfs_clear_buffer_dirty(trans, buf);
5086	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);
5087	clear_bit(EXTENT_BUFFER_ZONED_ZEROOUT, &buf->bflags);
5088
5089	set_extent_buffer_uptodate(buf);
 
5090
5091	memzero_extent_buffer(buf, 0, sizeof(struct btrfs_header));
5092	btrfs_set_header_level(buf, level);
5093	btrfs_set_header_bytenr(buf, buf->start);
5094	btrfs_set_header_generation(buf, trans->transid);
5095	btrfs_set_header_backref_rev(buf, BTRFS_MIXED_BACKREF_REV);
5096	btrfs_set_header_owner(buf, owner);
5097	write_extent_buffer_fsid(buf, fs_info->fs_devices->metadata_uuid);
5098	write_extent_buffer_chunk_tree_uuid(buf, fs_info->chunk_tree_uuid);
5099	if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
5100		buf->log_index = root->log_transid % 2;
5101		/*
5102		 * we allow two log transactions at a time, use different
5103		 * EXTENT bit to differentiate dirty pages.
5104		 */
5105		if (buf->log_index == 0)
5106			set_extent_bit(&root->dirty_log_pages, buf->start,
5107				       buf->start + buf->len - 1,
5108				       EXTENT_DIRTY, NULL);
5109		else
5110			set_extent_bit(&root->dirty_log_pages, buf->start,
5111				       buf->start + buf->len - 1,
5112				       EXTENT_NEW, NULL);
5113	} else {
5114		buf->log_index = -1;
5115		set_extent_bit(&trans->transaction->dirty_pages, buf->start,
5116			       buf->start + buf->len - 1, EXTENT_DIRTY, NULL);
5117	}
 
5118	/* this returns a buffer locked for blocking */
5119	return buf;
5120}
5121
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5122/*
5123 * finds a free extent and does all the dirty work required for allocation
5124 * returns the tree buffer or an ERR_PTR on error.
 
 
 
5125 */
5126struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
5127					     struct btrfs_root *root,
5128					     u64 parent, u64 root_objectid,
5129					     const struct btrfs_disk_key *key,
5130					     int level, u64 hint,
5131					     u64 empty_size,
5132					     u64 reloc_src_root,
5133					     enum btrfs_lock_nesting nest)
5134{
5135	struct btrfs_fs_info *fs_info = root->fs_info;
5136	struct btrfs_key ins;
5137	struct btrfs_block_rsv *block_rsv;
5138	struct extent_buffer *buf;
5139	struct btrfs_delayed_extent_op *extent_op;
5140	struct btrfs_ref generic_ref = { 0 };
5141	u64 flags = 0;
5142	int ret;
5143	u32 blocksize = fs_info->nodesize;
5144	bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);
5145	u64 owning_root;
5146
5147#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
5148	if (btrfs_is_testing(fs_info)) {
5149		buf = btrfs_init_new_buffer(trans, root, root->alloc_bytenr,
5150					    level, root_objectid, nest);
5151		if (!IS_ERR(buf))
5152			root->alloc_bytenr += blocksize;
5153		return buf;
5154	}
5155#endif
5156
5157	block_rsv = btrfs_use_block_rsv(trans, root, blocksize);
 
5158	if (IS_ERR(block_rsv))
5159		return ERR_CAST(block_rsv);
5160
5161	ret = btrfs_reserve_extent(root, blocksize, blocksize, blocksize,
5162				   empty_size, hint, &ins, 0, 0);
5163	if (ret)
5164		goto out_unuse;
5165
5166	buf = btrfs_init_new_buffer(trans, root, ins.objectid, level,
5167				    root_objectid, nest);
5168	if (IS_ERR(buf)) {
5169		ret = PTR_ERR(buf);
5170		goto out_free_reserved;
5171	}
5172	owning_root = btrfs_header_owner(buf);
 
 
 
5173
5174	if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
5175		if (parent == 0)
5176			parent = ins.objectid;
5177		flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
5178		owning_root = reloc_src_root;
5179	} else
5180		BUG_ON(parent > 0);
5181
5182	if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
5183		extent_op = btrfs_alloc_delayed_extent_op();
5184		if (!extent_op) {
5185			ret = -ENOMEM;
5186			goto out_free_buf;
5187		}
5188		if (key)
5189			memcpy(&extent_op->key, key, sizeof(extent_op->key));
5190		else
5191			memset(&extent_op->key, 0, sizeof(extent_op->key));
5192		extent_op->flags_to_set = flags;
5193		extent_op->update_key = skinny_metadata ? false : true;
5194		extent_op->update_flags = true;
5195		extent_op->level = level;
5196
5197		btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_EXTENT,
5198				       ins.objectid, ins.offset, parent, owning_root);
5199		btrfs_init_tree_ref(&generic_ref, level, root_objectid,
5200				    root->root_key.objectid, false);
5201		btrfs_ref_tree_mod(fs_info, &generic_ref);
5202		ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, extent_op);
5203		if (ret)
5204			goto out_free_delayed;
5205	}
5206	return buf;
5207
5208out_free_delayed:
5209	btrfs_free_delayed_extent_op(extent_op);
5210out_free_buf:
5211	btrfs_tree_unlock(buf);
5212	free_extent_buffer(buf);
5213out_free_reserved:
5214	btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, 0);
5215out_unuse:
5216	btrfs_unuse_block_rsv(fs_info, block_rsv, blocksize);
5217	return ERR_PTR(ret);
5218}
5219
5220struct walk_control {
5221	u64 refs[BTRFS_MAX_LEVEL];
5222	u64 flags[BTRFS_MAX_LEVEL];
5223	struct btrfs_key update_progress;
5224	struct btrfs_key drop_progress;
5225	int drop_level;
5226	int stage;
5227	int level;
5228	int shared_level;
5229	int update_ref;
5230	int keep_locks;
5231	int reada_slot;
5232	int reada_count;
5233	int restarted;
5234};
5235
5236#define DROP_REFERENCE	1
5237#define UPDATE_BACKREF	2
5238
5239static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
5240				     struct btrfs_root *root,
5241				     struct walk_control *wc,
5242				     struct btrfs_path *path)
5243{
5244	struct btrfs_fs_info *fs_info = root->fs_info;
5245	u64 bytenr;
5246	u64 generation;
5247	u64 refs;
5248	u64 flags;
5249	u32 nritems;
 
5250	struct btrfs_key key;
5251	struct extent_buffer *eb;
5252	int ret;
5253	int slot;
5254	int nread = 0;
5255
5256	if (path->slots[wc->level] < wc->reada_slot) {
5257		wc->reada_count = wc->reada_count * 2 / 3;
5258		wc->reada_count = max(wc->reada_count, 2);
5259	} else {
5260		wc->reada_count = wc->reada_count * 3 / 2;
5261		wc->reada_count = min_t(int, wc->reada_count,
5262					BTRFS_NODEPTRS_PER_BLOCK(fs_info));
5263	}
5264
5265	eb = path->nodes[wc->level];
5266	nritems = btrfs_header_nritems(eb);
 
5267
5268	for (slot = path->slots[wc->level]; slot < nritems; slot++) {
5269		if (nread >= wc->reada_count)
5270			break;
5271
5272		cond_resched();
5273		bytenr = btrfs_node_blockptr(eb, slot);
5274		generation = btrfs_node_ptr_generation(eb, slot);
5275
5276		if (slot == path->slots[wc->level])
5277			goto reada;
5278
5279		if (wc->stage == UPDATE_BACKREF &&
5280		    generation <= root->root_key.offset)
5281			continue;
5282
5283		/* We don't lock the tree block, it's OK to be racy here */
5284		ret = btrfs_lookup_extent_info(trans, fs_info, bytenr,
5285					       wc->level - 1, 1, &refs,
5286					       &flags, NULL);
5287		/* We don't care about errors in readahead. */
5288		if (ret < 0)
5289			continue;
5290		BUG_ON(refs == 0);
5291
5292		if (wc->stage == DROP_REFERENCE) {
5293			if (refs == 1)
5294				goto reada;
5295
5296			if (wc->level == 1 &&
5297			    (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5298				continue;
5299			if (!wc->update_ref ||
5300			    generation <= root->root_key.offset)
5301				continue;
5302			btrfs_node_key_to_cpu(eb, &key, slot);
5303			ret = btrfs_comp_cpu_keys(&key,
5304						  &wc->update_progress);
5305			if (ret < 0)
5306				continue;
5307		} else {
5308			if (wc->level == 1 &&
5309			    (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5310				continue;
5311		}
5312reada:
5313		btrfs_readahead_node_child(eb, slot);
 
 
 
5314		nread++;
5315	}
5316	wc->reada_slot = slot;
5317}
5318
5319/*
5320 * helper to process tree block while walking down the tree.
5321 *
5322 * when wc->stage == UPDATE_BACKREF, this function updates
5323 * back refs for pointers in the block.
5324 *
5325 * NOTE: return value 1 means we should stop walking down.
5326 */
5327static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
5328				   struct btrfs_root *root,
5329				   struct btrfs_path *path,
5330				   struct walk_control *wc, int lookup_info)
5331{
5332	struct btrfs_fs_info *fs_info = root->fs_info;
5333	int level = wc->level;
5334	struct extent_buffer *eb = path->nodes[level];
5335	u64 flag = BTRFS_BLOCK_FLAG_FULL_BACKREF;
5336	int ret;
5337
5338	if (wc->stage == UPDATE_BACKREF &&
5339	    btrfs_header_owner(eb) != root->root_key.objectid)
5340		return 1;
5341
5342	/*
5343	 * when reference count of tree block is 1, it won't increase
5344	 * again. once full backref flag is set, we never clear it.
5345	 */
5346	if (lookup_info &&
5347	    ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
5348	     (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
5349		BUG_ON(!path->locks[level]);
5350		ret = btrfs_lookup_extent_info(trans, fs_info,
5351					       eb->start, level, 1,
5352					       &wc->refs[level],
5353					       &wc->flags[level],
5354					       NULL);
5355		BUG_ON(ret == -ENOMEM);
5356		if (ret)
5357			return ret;
5358		BUG_ON(wc->refs[level] == 0);
5359	}
5360
5361	if (wc->stage == DROP_REFERENCE) {
5362		if (wc->refs[level] > 1)
5363			return 1;
5364
5365		if (path->locks[level] && !wc->keep_locks) {
5366			btrfs_tree_unlock_rw(eb, path->locks[level]);
5367			path->locks[level] = 0;
5368		}
5369		return 0;
5370	}
5371
5372	/* wc->stage == UPDATE_BACKREF */
5373	if (!(wc->flags[level] & flag)) {
5374		BUG_ON(!path->locks[level]);
5375		ret = btrfs_inc_ref(trans, root, eb, 1);
5376		BUG_ON(ret); /* -ENOMEM */
5377		ret = btrfs_dec_ref(trans, root, eb, 0);
5378		BUG_ON(ret); /* -ENOMEM */
5379		ret = btrfs_set_disk_extent_flags(trans, eb, flag);
 
5380		BUG_ON(ret); /* -ENOMEM */
5381		wc->flags[level] |= flag;
5382	}
5383
5384	/*
5385	 * the block is shared by multiple trees, so it's not good to
5386	 * keep the tree lock
5387	 */
5388	if (path->locks[level] && level > 0) {
5389		btrfs_tree_unlock_rw(eb, path->locks[level]);
5390		path->locks[level] = 0;
5391	}
5392	return 0;
5393}
5394
5395/*
5396 * This is used to verify a ref exists for this root to deal with a bug where we
5397 * would have a drop_progress key that hadn't been updated properly.
5398 */
5399static int check_ref_exists(struct btrfs_trans_handle *trans,
5400			    struct btrfs_root *root, u64 bytenr, u64 parent,
5401			    int level)
5402{
5403	struct btrfs_path *path;
5404	struct btrfs_extent_inline_ref *iref;
5405	int ret;
5406
5407	path = btrfs_alloc_path();
5408	if (!path)
5409		return -ENOMEM;
5410
5411	ret = lookup_extent_backref(trans, path, &iref, bytenr,
5412				    root->fs_info->nodesize, parent,
5413				    root->root_key.objectid, level, 0);
5414	btrfs_free_path(path);
5415	if (ret == -ENOENT)
5416		return 0;
5417	if (ret < 0)
5418		return ret;
5419	return 1;
5420}
5421
5422/*
5423 * helper to process tree block pointer.
5424 *
5425 * when wc->stage == DROP_REFERENCE, this function checks
5426 * reference count of the block pointed to. if the block
5427 * is shared and we need update back refs for the subtree
5428 * rooted at the block, this function changes wc->stage to
5429 * UPDATE_BACKREF. if the block is shared and there is no
5430 * need to update back, this function drops the reference
5431 * to the block.
5432 *
5433 * NOTE: return value 1 means we should stop walking down.
5434 */
5435static noinline int do_walk_down(struct btrfs_trans_handle *trans,
5436				 struct btrfs_root *root,
5437				 struct btrfs_path *path,
5438				 struct walk_control *wc, int *lookup_info)
5439{
5440	struct btrfs_fs_info *fs_info = root->fs_info;
5441	u64 bytenr;
5442	u64 generation;
5443	u64 parent;
5444	u64 owner_root = 0;
5445	struct btrfs_tree_parent_check check = { 0 };
5446	struct btrfs_key key;
5447	struct btrfs_ref ref = { 0 };
5448	struct extent_buffer *next;
5449	int level = wc->level;
5450	int reada = 0;
5451	int ret = 0;
5452	bool need_account = false;
5453
5454	generation = btrfs_node_ptr_generation(path->nodes[level],
5455					       path->slots[level]);
5456	/*
5457	 * if the lower level block was created before the snapshot
5458	 * was created, we know there is no need to update back refs
5459	 * for the subtree
5460	 */
5461	if (wc->stage == UPDATE_BACKREF &&
5462	    generation <= root->root_key.offset) {
5463		*lookup_info = 1;
5464		return 1;
5465	}
5466
5467	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
 
5468
5469	check.level = level - 1;
5470	check.transid = generation;
5471	check.owner_root = root->root_key.objectid;
5472	check.has_first_key = true;
5473	btrfs_node_key_to_cpu(path->nodes[level], &check.first_key,
5474			      path->slots[level]);
5475
5476	next = find_extent_buffer(fs_info, bytenr);
5477	if (!next) {
5478		next = btrfs_find_create_tree_block(fs_info, bytenr,
5479				root->root_key.objectid, level - 1);
5480		if (IS_ERR(next))
5481			return PTR_ERR(next);
5482		reada = 1;
5483	}
5484	btrfs_tree_lock(next);
 
5485
5486	ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,
5487				       &wc->refs[level - 1],
5488				       &wc->flags[level - 1],
5489				       &owner_root);
5490	if (ret < 0)
5491		goto out_unlock;
5492
5493	if (unlikely(wc->refs[level - 1] == 0)) {
5494		btrfs_err(fs_info, "Missing references.");
5495		ret = -EIO;
5496		goto out_unlock;
5497	}
 
 
5498	*lookup_info = 0;
5499
5500	if (wc->stage == DROP_REFERENCE) {
5501		if (wc->refs[level - 1] > 1) {
5502			need_account = true;
5503			if (level == 1 &&
5504			    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5505				goto skip;
5506
5507			if (!wc->update_ref ||
5508			    generation <= root->root_key.offset)
5509				goto skip;
5510
5511			btrfs_node_key_to_cpu(path->nodes[level], &key,
5512					      path->slots[level]);
5513			ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
5514			if (ret < 0)
5515				goto skip;
5516
5517			wc->stage = UPDATE_BACKREF;
5518			wc->shared_level = level - 1;
5519		}
5520	} else {
5521		if (level == 1 &&
5522		    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5523			goto skip;
5524	}
5525
5526	if (!btrfs_buffer_uptodate(next, generation, 0)) {
5527		btrfs_tree_unlock(next);
5528		free_extent_buffer(next);
5529		next = NULL;
5530		*lookup_info = 1;
5531	}
5532
5533	if (!next) {
5534		if (reada && level == 1)
5535			reada_walk_down(trans, root, wc, path);
5536		next = read_tree_block(fs_info, bytenr, &check);
5537		if (IS_ERR(next)) {
5538			return PTR_ERR(next);
5539		} else if (!extent_buffer_uptodate(next)) {
5540			free_extent_buffer(next);
5541			return -EIO;
5542		}
5543		btrfs_tree_lock(next);
 
5544	}
5545
5546	level--;
5547	ASSERT(level == btrfs_header_level(next));
5548	if (level != btrfs_header_level(next)) {
5549		btrfs_err(root->fs_info, "mismatched level");
5550		ret = -EIO;
5551		goto out_unlock;
5552	}
5553	path->nodes[level] = next;
5554	path->slots[level] = 0;
5555	path->locks[level] = BTRFS_WRITE_LOCK;
5556	wc->level = level;
5557	if (wc->level == 1)
5558		wc->reada_slot = 0;
5559	return 0;
5560skip:
5561	wc->refs[level - 1] = 0;
5562	wc->flags[level - 1] = 0;
5563	if (wc->stage == DROP_REFERENCE) {
5564		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
5565			parent = path->nodes[level]->start;
5566		} else {
5567			ASSERT(root->root_key.objectid ==
5568			       btrfs_header_owner(path->nodes[level]));
5569			if (root->root_key.objectid !=
5570			    btrfs_header_owner(path->nodes[level])) {
5571				btrfs_err(root->fs_info,
5572						"mismatched block owner");
5573				ret = -EIO;
5574				goto out_unlock;
5575			}
5576			parent = 0;
5577		}
5578
5579		/*
5580		 * If we had a drop_progress we need to verify the refs are set
5581		 * as expected.  If we find our ref then we know that from here
5582		 * on out everything should be correct, and we can clear the
5583		 * ->restarted flag.
5584		 */
5585		if (wc->restarted) {
5586			ret = check_ref_exists(trans, root, bytenr, parent,
5587					       level - 1);
5588			if (ret < 0)
5589				goto out_unlock;
5590			if (ret == 0)
5591				goto no_delete;
5592			ret = 0;
5593			wc->restarted = 0;
5594		}
5595
5596		/*
5597		 * Reloc tree doesn't contribute to qgroup numbers, and we have
5598		 * already accounted them at merge time (replace_path),
5599		 * thus we could skip expensive subtree trace here.
5600		 */
5601		if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
5602		    need_account) {
5603			ret = btrfs_qgroup_trace_subtree(trans, next,
5604							 generation, level - 1);
5605			if (ret) {
5606				btrfs_err_rl(fs_info,
5607					     "Error %d accounting shared subtree. Quota is out of sync, rescan required.",
5608					     ret);
5609			}
5610		}
5611
5612		/*
5613		 * We need to update the next key in our walk control so we can
5614		 * update the drop_progress key accordingly.  We don't care if
5615		 * find_next_key doesn't find a key because that means we're at
5616		 * the end and are going to clean up now.
5617		 */
5618		wc->drop_level = level;
5619		find_next_key(path, level, &wc->drop_progress);
5620
5621		btrfs_init_generic_ref(&ref, BTRFS_DROP_DELAYED_REF, bytenr,
5622				       fs_info->nodesize, parent, owner_root);
5623		btrfs_init_tree_ref(&ref, level - 1, root->root_key.objectid,
5624				    0, false);
5625		ret = btrfs_free_extent(trans, &ref);
5626		if (ret)
5627			goto out_unlock;
5628	}
5629no_delete:
5630	*lookup_info = 1;
5631	ret = 1;
5632
5633out_unlock:
5634	btrfs_tree_unlock(next);
5635	free_extent_buffer(next);
5636
5637	return ret;
5638}
5639
5640/*
5641 * helper to process tree block while walking up the tree.
5642 *
5643 * when wc->stage == DROP_REFERENCE, this function drops
5644 * reference count on the block.
5645 *
5646 * when wc->stage == UPDATE_BACKREF, this function changes
5647 * wc->stage back to DROP_REFERENCE if we changed wc->stage
5648 * to UPDATE_BACKREF previously while processing the block.
5649 *
5650 * NOTE: return value 1 means we should stop walking up.
5651 */
5652static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
5653				 struct btrfs_root *root,
5654				 struct btrfs_path *path,
5655				 struct walk_control *wc)
5656{
5657	struct btrfs_fs_info *fs_info = root->fs_info;
5658	int ret;
5659	int level = wc->level;
5660	struct extent_buffer *eb = path->nodes[level];
5661	u64 parent = 0;
5662
5663	if (wc->stage == UPDATE_BACKREF) {
5664		BUG_ON(wc->shared_level < level);
5665		if (level < wc->shared_level)
5666			goto out;
5667
5668		ret = find_next_key(path, level + 1, &wc->update_progress);
5669		if (ret > 0)
5670			wc->update_ref = 0;
5671
5672		wc->stage = DROP_REFERENCE;
5673		wc->shared_level = -1;
5674		path->slots[level] = 0;
5675
5676		/*
5677		 * check reference count again if the block isn't locked.
5678		 * we should start walking down the tree again if reference
5679		 * count is one.
5680		 */
5681		if (!path->locks[level]) {
5682			BUG_ON(level == 0);
5683			btrfs_tree_lock(eb);
5684			path->locks[level] = BTRFS_WRITE_LOCK;
 
5685
5686			ret = btrfs_lookup_extent_info(trans, fs_info,
5687						       eb->start, level, 1,
5688						       &wc->refs[level],
5689						       &wc->flags[level],
5690						       NULL);
5691			if (ret < 0) {
5692				btrfs_tree_unlock_rw(eb, path->locks[level]);
5693				path->locks[level] = 0;
5694				return ret;
5695			}
5696			BUG_ON(wc->refs[level] == 0);
5697			if (wc->refs[level] == 1) {
5698				btrfs_tree_unlock_rw(eb, path->locks[level]);
5699				path->locks[level] = 0;
5700				return 1;
5701			}
5702		}
5703	}
5704
5705	/* wc->stage == DROP_REFERENCE */
5706	BUG_ON(wc->refs[level] > 1 && !path->locks[level]);
5707
5708	if (wc->refs[level] == 1) {
5709		if (level == 0) {
5710			if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5711				ret = btrfs_dec_ref(trans, root, eb, 1);
 
5712			else
5713				ret = btrfs_dec_ref(trans, root, eb, 0);
 
5714			BUG_ON(ret); /* -ENOMEM */
5715			if (is_fstree(root->root_key.objectid)) {
5716				ret = btrfs_qgroup_trace_leaf_items(trans, eb);
5717				if (ret) {
5718					btrfs_err_rl(fs_info,
5719	"error %d accounting leaf items, quota is out of sync, rescan required",
5720					     ret);
5721				}
5722			}
5723		}
5724		/* Make block locked assertion in btrfs_clear_buffer_dirty happy. */
5725		if (!path->locks[level]) {
 
5726			btrfs_tree_lock(eb);
5727			path->locks[level] = BTRFS_WRITE_LOCK;
 
5728		}
5729		btrfs_clear_buffer_dirty(trans, eb);
5730	}
5731
5732	if (eb == root->node) {
5733		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5734			parent = eb->start;
5735		else if (root->root_key.objectid != btrfs_header_owner(eb))
5736			goto owner_mismatch;
 
5737	} else {
5738		if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5739			parent = path->nodes[level + 1]->start;
5740		else if (root->root_key.objectid !=
5741			 btrfs_header_owner(path->nodes[level + 1]))
5742			goto owner_mismatch;
5743	}
5744
5745	btrfs_free_tree_block(trans, btrfs_root_id(root), eb, parent,
5746			      wc->refs[level] == 1);
5747out:
5748	wc->refs[level] = 0;
5749	wc->flags[level] = 0;
5750	return 0;
5751
5752owner_mismatch:
5753	btrfs_err_rl(fs_info, "unexpected tree owner, have %llu expect %llu",
5754		     btrfs_header_owner(eb), root->root_key.objectid);
5755	return -EUCLEAN;
5756}
5757
5758static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
5759				   struct btrfs_root *root,
5760				   struct btrfs_path *path,
5761				   struct walk_control *wc)
5762{
5763	int level = wc->level;
5764	int lookup_info = 1;
5765	int ret = 0;
5766
5767	while (level >= 0) {
5768		ret = walk_down_proc(trans, root, path, wc, lookup_info);
5769		if (ret)
5770			break;
5771
5772		if (level == 0)
5773			break;
5774
5775		if (path->slots[level] >=
5776		    btrfs_header_nritems(path->nodes[level]))
5777			break;
5778
5779		ret = do_walk_down(trans, root, path, wc, &lookup_info);
5780		if (ret > 0) {
5781			path->slots[level]++;
5782			continue;
5783		} else if (ret < 0)
5784			break;
5785		level = wc->level;
5786	}
5787	return (ret == 1) ? 0 : ret;
5788}
5789
5790static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
5791				 struct btrfs_root *root,
5792				 struct btrfs_path *path,
5793				 struct walk_control *wc, int max_level)
5794{
5795	int level = wc->level;
5796	int ret;
5797
5798	path->slots[level] = btrfs_header_nritems(path->nodes[level]);
5799	while (level < max_level && path->nodes[level]) {
5800		wc->level = level;
5801		if (path->slots[level] + 1 <
5802		    btrfs_header_nritems(path->nodes[level])) {
5803			path->slots[level]++;
5804			return 0;
5805		} else {
5806			ret = walk_up_proc(trans, root, path, wc);
5807			if (ret > 0)
5808				return 0;
5809			if (ret < 0)
5810				return ret;
5811
5812			if (path->locks[level]) {
5813				btrfs_tree_unlock_rw(path->nodes[level],
5814						     path->locks[level]);
5815				path->locks[level] = 0;
5816			}
5817			free_extent_buffer(path->nodes[level]);
5818			path->nodes[level] = NULL;
5819			level++;
5820		}
5821	}
5822	return 1;
5823}
5824
5825/*
5826 * drop a subvolume tree.
5827 *
5828 * this function traverses the tree freeing any blocks that only
5829 * referenced by the tree.
5830 *
5831 * when a shared tree block is found. this function decreases its
5832 * reference count by one. if update_ref is true, this function
5833 * also make sure backrefs for the shared block and all lower level
5834 * blocks are properly updated.
5835 *
5836 * If called with for_reloc == 0, may exit early with -EAGAIN
5837 */
5838int btrfs_drop_snapshot(struct btrfs_root *root, int update_ref, int for_reloc)
 
 
5839{
5840	const bool is_reloc_root = (root->root_key.objectid ==
5841				    BTRFS_TREE_RELOC_OBJECTID);
5842	struct btrfs_fs_info *fs_info = root->fs_info;
5843	struct btrfs_path *path;
5844	struct btrfs_trans_handle *trans;
5845	struct btrfs_root *tree_root = fs_info->tree_root;
5846	struct btrfs_root_item *root_item = &root->root_item;
5847	struct walk_control *wc;
5848	struct btrfs_key key;
5849	int err = 0;
5850	int ret;
5851	int level;
5852	bool root_dropped = false;
5853	bool unfinished_drop = false;
5854
5855	btrfs_debug(fs_info, "Drop subvolume %llu", root->root_key.objectid);
5856
5857	path = btrfs_alloc_path();
5858	if (!path) {
5859		err = -ENOMEM;
5860		goto out;
5861	}
5862
5863	wc = kzalloc(sizeof(*wc), GFP_NOFS);
5864	if (!wc) {
5865		btrfs_free_path(path);
5866		err = -ENOMEM;
5867		goto out;
5868	}
5869
5870	/*
5871	 * Use join to avoid potential EINTR from transaction start. See
5872	 * wait_reserve_ticket and the whole reservation callchain.
5873	 */
5874	if (for_reloc)
5875		trans = btrfs_join_transaction(tree_root);
5876	else
5877		trans = btrfs_start_transaction(tree_root, 0);
5878	if (IS_ERR(trans)) {
5879		err = PTR_ERR(trans);
5880		goto out_free;
5881	}
5882
5883	err = btrfs_run_delayed_items(trans);
5884	if (err)
5885		goto out_end_trans;
5886
5887	/*
5888	 * This will help us catch people modifying the fs tree while we're
5889	 * dropping it.  It is unsafe to mess with the fs tree while it's being
5890	 * dropped as we unlock the root node and parent nodes as we walk down
5891	 * the tree, assuming nothing will change.  If something does change
5892	 * then we'll have stale information and drop references to blocks we've
5893	 * already dropped.
5894	 */
5895	set_bit(BTRFS_ROOT_DELETING, &root->state);
5896	unfinished_drop = test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state);
5897
5898	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
5899		level = btrfs_header_level(root->node);
5900		path->nodes[level] = btrfs_lock_root_node(root);
 
5901		path->slots[level] = 0;
5902		path->locks[level] = BTRFS_WRITE_LOCK;
5903		memset(&wc->update_progress, 0,
5904		       sizeof(wc->update_progress));
5905	} else {
5906		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5907		memcpy(&wc->update_progress, &key,
5908		       sizeof(wc->update_progress));
5909
5910		level = btrfs_root_drop_level(root_item);
5911		BUG_ON(level == 0);
5912		path->lowest_level = level;
5913		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5914		path->lowest_level = 0;
5915		if (ret < 0) {
5916			err = ret;
5917			goto out_end_trans;
5918		}
5919		WARN_ON(ret > 0);
5920
5921		/*
5922		 * unlock our path, this is safe because only this
5923		 * function is allowed to delete this snapshot
5924		 */
5925		btrfs_unlock_up_safe(path, 0);
5926
5927		level = btrfs_header_level(root->node);
5928		while (1) {
5929			btrfs_tree_lock(path->nodes[level]);
5930			path->locks[level] = BTRFS_WRITE_LOCK;
5931
5932			ret = btrfs_lookup_extent_info(trans, fs_info,
5933						path->nodes[level]->start,
5934						level, 1, &wc->refs[level],
5935						&wc->flags[level], NULL);
 
5936			if (ret < 0) {
5937				err = ret;
5938				goto out_end_trans;
5939			}
5940			BUG_ON(wc->refs[level] == 0);
5941
5942			if (level == btrfs_root_drop_level(root_item))
5943				break;
5944
5945			btrfs_tree_unlock(path->nodes[level]);
5946			path->locks[level] = 0;
5947			WARN_ON(wc->refs[level] != 1);
5948			level--;
5949		}
5950	}
5951
5952	wc->restarted = test_bit(BTRFS_ROOT_DEAD_TREE, &root->state);
5953	wc->level = level;
5954	wc->shared_level = -1;
5955	wc->stage = DROP_REFERENCE;
5956	wc->update_ref = update_ref;
5957	wc->keep_locks = 0;
5958	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);
 
5959
5960	while (1) {
5961
5962		ret = walk_down_tree(trans, root, path, wc);
5963		if (ret < 0) {
5964			btrfs_abort_transaction(trans, ret);
5965			err = ret;
5966			break;
5967		}
5968
5969		ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);
5970		if (ret < 0) {
5971			btrfs_abort_transaction(trans, ret);
5972			err = ret;
5973			break;
5974		}
5975
5976		if (ret > 0) {
5977			BUG_ON(wc->stage != DROP_REFERENCE);
5978			break;
5979		}
5980
5981		if (wc->stage == DROP_REFERENCE) {
5982			wc->drop_level = wc->level;
5983			btrfs_node_key_to_cpu(path->nodes[wc->drop_level],
5984					      &wc->drop_progress,
5985					      path->slots[wc->drop_level]);
5986		}
5987		btrfs_cpu_key_to_disk(&root_item->drop_progress,
5988				      &wc->drop_progress);
5989		btrfs_set_root_drop_level(root_item, wc->drop_level);
5990
5991		BUG_ON(wc->level == 0);
5992		if (btrfs_should_end_transaction(trans) ||
5993		    (!for_reloc && btrfs_need_cleaner_sleep(fs_info))) {
5994			ret = btrfs_update_root(trans, tree_root,
5995						&root->root_key,
5996						root_item);
5997			if (ret) {
5998				btrfs_abort_transaction(trans, ret);
5999				err = ret;
6000				goto out_end_trans;
6001			}
6002
6003			if (!is_reloc_root)
6004				btrfs_set_last_root_drop_gen(fs_info, trans->transid);
6005
6006			btrfs_end_transaction_throttle(trans);
6007			if (!for_reloc && btrfs_need_cleaner_sleep(fs_info)) {
6008				btrfs_debug(fs_info,
6009					    "drop snapshot early exit");
6010				err = -EAGAIN;
6011				goto out_free;
6012			}
6013
6014		       /*
6015			* Use join to avoid potential EINTR from transaction
6016			* start. See wait_reserve_ticket and the whole
6017			* reservation callchain.
6018			*/
6019			if (for_reloc)
6020				trans = btrfs_join_transaction(tree_root);
6021			else
6022				trans = btrfs_start_transaction(tree_root, 0);
6023			if (IS_ERR(trans)) {
6024				err = PTR_ERR(trans);
6025				goto out_free;
6026			}
 
 
6027		}
6028	}
6029	btrfs_release_path(path);
6030	if (err)
6031		goto out_end_trans;
6032
6033	ret = btrfs_del_root(trans, &root->root_key);
6034	if (ret) {
6035		btrfs_abort_transaction(trans, ret);
6036		err = ret;
6037		goto out_end_trans;
6038	}
6039
6040	if (!is_reloc_root) {
6041		ret = btrfs_find_root(tree_root, &root->root_key, path,
6042				      NULL, NULL);
6043		if (ret < 0) {
6044			btrfs_abort_transaction(trans, ret);
6045			err = ret;
6046			goto out_end_trans;
6047		} else if (ret > 0) {
6048			/* if we fail to delete the orphan item this time
6049			 * around, it'll get picked up the next time.
6050			 *
6051			 * The most common failure here is just -ENOENT.
6052			 */
6053			btrfs_del_orphan_item(trans, tree_root,
6054					      root->root_key.objectid);
6055		}
6056	}
6057
6058	/*
6059	 * This subvolume is going to be completely dropped, and won't be
6060	 * recorded as dirty roots, thus pertrans meta rsv will not be freed at
6061	 * commit transaction time.  So free it here manually.
6062	 */
6063	btrfs_qgroup_convert_reserved_meta(root, INT_MAX);
6064	btrfs_qgroup_free_meta_all_pertrans(root);
6065
6066	if (test_bit(BTRFS_ROOT_IN_RADIX, &root->state))
6067		btrfs_add_dropped_root(trans, root);
6068	else
6069		btrfs_put_root(root);
6070	root_dropped = true;
6071out_end_trans:
6072	if (!is_reloc_root)
6073		btrfs_set_last_root_drop_gen(fs_info, trans->transid);
6074
6075	btrfs_end_transaction_throttle(trans);
6076out_free:
6077	kfree(wc);
6078	btrfs_free_path(path);
6079out:
6080	/*
6081	 * We were an unfinished drop root, check to see if there are any
6082	 * pending, and if not clear and wake up any waiters.
6083	 */
6084	if (!err && unfinished_drop)
6085		btrfs_maybe_wake_unfinished_drop(fs_info);
6086
6087	/*
6088	 * So if we need to stop dropping the snapshot for whatever reason we
6089	 * need to make sure to add it back to the dead root list so that we
6090	 * keep trying to do the work later.  This also cleans up roots if we
6091	 * don't have it in the radix (like when we recover after a power fail
6092	 * or unmount) so we don't leak memory.
6093	 */
6094	if (!for_reloc && !root_dropped)
6095		btrfs_add_dead_root(root);
6096	return err;
6097}
6098
6099/*
6100 * drop subtree rooted at tree block 'node'.
6101 *
6102 * NOTE: this function will unlock and release tree block 'node'
6103 * only used by relocation code
6104 */
6105int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
6106			struct btrfs_root *root,
6107			struct extent_buffer *node,
6108			struct extent_buffer *parent)
6109{
6110	struct btrfs_fs_info *fs_info = root->fs_info;
6111	struct btrfs_path *path;
6112	struct walk_control *wc;
6113	int level;
6114	int parent_level;
6115	int ret = 0;
6116	int wret;
6117
6118	BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
6119
6120	path = btrfs_alloc_path();
6121	if (!path)
6122		return -ENOMEM;
6123
6124	wc = kzalloc(sizeof(*wc), GFP_NOFS);
6125	if (!wc) {
6126		btrfs_free_path(path);
6127		return -ENOMEM;
6128	}
6129
6130	btrfs_assert_tree_write_locked(parent);
6131	parent_level = btrfs_header_level(parent);
6132	atomic_inc(&parent->refs);
6133	path->nodes[parent_level] = parent;
6134	path->slots[parent_level] = btrfs_header_nritems(parent);
6135
6136	btrfs_assert_tree_write_locked(node);
6137	level = btrfs_header_level(node);
6138	path->nodes[level] = node;
6139	path->slots[level] = 0;
6140	path->locks[level] = BTRFS_WRITE_LOCK;
6141
6142	wc->refs[parent_level] = 1;
6143	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;
6144	wc->level = level;
6145	wc->shared_level = -1;
6146	wc->stage = DROP_REFERENCE;
6147	wc->update_ref = 0;
6148	wc->keep_locks = 1;
6149	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(fs_info);
 
6150
6151	while (1) {
6152		wret = walk_down_tree(trans, root, path, wc);
6153		if (wret < 0) {
6154			ret = wret;
6155			break;
6156		}
6157
6158		wret = walk_up_tree(trans, root, path, wc, parent_level);
6159		if (wret < 0)
6160			ret = wret;
6161		if (wret != 0)
6162			break;
6163	}
6164
6165	kfree(wc);
6166	btrfs_free_path(path);
6167	return ret;
6168}
6169
6170int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
6171				   u64 start, u64 end)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6172{
6173	return unpin_extent_range(fs_info, start, end, false);
 
 
6174}
6175
6176/*
6177 * It used to be that old block groups would be left around forever.
6178 * Iterating over them would be enough to trim unused space.  Since we
6179 * now automatically remove them, we also need to iterate over unallocated
6180 * space.
6181 *
6182 * We don't want a transaction for this since the discard may take a
6183 * substantial amount of time.  We don't require that a transaction be
6184 * running, but we do need to take a running transaction into account
6185 * to ensure that we're not discarding chunks that were released or
6186 * allocated in the current transaction.
6187 *
6188 * Holding the chunks lock will prevent other threads from allocating
6189 * or releasing chunks, but it won't prevent a running transaction
6190 * from committing and releasing the memory that the pending chunks
6191 * list head uses.  For that, we need to take a reference to the
6192 * transaction and hold the commit root sem.  We only need to hold
6193 * it while performing the free space search since we have already
6194 * held back allocations.
6195 */
6196static int btrfs_trim_free_extents(struct btrfs_device *device, u64 *trimmed)
6197{
6198	u64 start = BTRFS_DEVICE_RANGE_RESERVED, len = 0, end = 0;
6199	int ret;
 
6200
6201	*trimmed = 0;
 
6202
6203	/* Discard not supported = nothing to do. */
6204	if (!bdev_max_discard_sectors(device->bdev))
6205		return 0;
 
6206
6207	/* Not writable = nothing to do. */
6208	if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state))
6209		return 0;
 
 
 
6210
6211	/* No free space = nothing to do. */
6212	if (device->total_bytes <= device->bytes_used)
6213		return 0;
6214
6215	ret = 0;
 
6216
6217	while (1) {
6218		struct btrfs_fs_info *fs_info = device->fs_info;
6219		u64 bytes;
6220
6221		ret = mutex_lock_interruptible(&fs_info->chunk_mutex);
6222		if (ret)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6223			break;
 
 
6224
6225		find_first_clear_extent_bit(&device->alloc_state, start,
6226					    &start, &end,
6227					    CHUNK_TRIMMED | CHUNK_ALLOCATED);
6228
6229		/* Check if there are any CHUNK_* bits left */
6230		if (start > device->total_bytes) {
6231			WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
6232			btrfs_warn_in_rcu(fs_info,
6233"ignoring attempt to trim beyond device size: offset %llu length %llu device %s device size %llu",
6234					  start, end - start + 1,
6235					  btrfs_dev_name(device),
6236					  device->total_bytes);
6237			mutex_unlock(&fs_info->chunk_mutex);
6238			ret = 0;
6239			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6240		}
6241
6242		/* Ensure we skip the reserved space on each device. */
6243		start = max_t(u64, start, BTRFS_DEVICE_RANGE_RESERVED);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6244
6245		/*
6246		 * If find_first_clear_extent_bit find a range that spans the
6247		 * end of the device it will set end to -1, in this case it's up
6248		 * to the caller to trim the value to the size of the device.
6249		 */
6250		end = min(end, device->total_bytes - 1);
 
6251
6252		len = end - start + 1;
 
6253
6254		/* We didn't find any extents */
6255		if (!len) {
6256			mutex_unlock(&fs_info->chunk_mutex);
6257			ret = 0;
6258			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6259		}
 
 
 
 
 
6260
6261		ret = btrfs_issue_discard(device->bdev, start, len,
6262					  &bytes);
6263		if (!ret)
6264			set_extent_bit(&device->alloc_state, start,
6265				       start + bytes - 1, CHUNK_TRIMMED, NULL);
6266		mutex_unlock(&fs_info->chunk_mutex);
6267
6268		if (ret)
6269			break;
 
 
6270
6271		start += len;
6272		*trimmed += bytes;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6273
6274		if (fatal_signal_pending(current)) {
6275			ret = -ERESTARTSYS;
 
 
 
 
 
 
 
 
6276			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6277		}
6278
6279		cond_resched();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6280	}
6281
 
 
 
 
6282	return ret;
6283}
6284
6285/*
6286 * Trim the whole filesystem by:
6287 * 1) trimming the free space in each block group
6288 * 2) trimming the unallocated space on each device
6289 *
6290 * This will also continue trimming even if a block group or device encounters
6291 * an error.  The return value will be the last error, or 0 if nothing bad
6292 * happens.
6293 */
6294int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range)
6295{
6296	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6297	struct btrfs_block_group *cache = NULL;
6298	struct btrfs_device *device;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6299	u64 group_trimmed;
6300	u64 range_end = U64_MAX;
6301	u64 start;
6302	u64 end;
6303	u64 trimmed = 0;
6304	u64 bg_failed = 0;
6305	u64 dev_failed = 0;
6306	int bg_ret = 0;
6307	int dev_ret = 0;
6308	int ret = 0;
6309
6310	if (range->start == U64_MAX)
6311		return -EINVAL;
6312
6313	/*
6314	 * Check range overflow if range->len is set.
6315	 * The default range->len is U64_MAX.
6316	 */
6317	if (range->len != U64_MAX &&
6318	    check_add_overflow(range->start, range->len, &range_end))
6319		return -EINVAL;
 
6320
6321	cache = btrfs_lookup_first_block_group(fs_info, range->start);
6322	for (; cache; cache = btrfs_next_block_group(cache)) {
6323		if (cache->start >= range_end) {
6324			btrfs_put_block_group(cache);
6325			break;
6326		}
6327
6328		start = max(range->start, cache->start);
6329		end = min(range_end, cache->start + cache->length);
 
6330
6331		if (end - start >= range->minlen) {
6332			if (!btrfs_block_group_done(cache)) {
6333				ret = btrfs_cache_block_group(cache, true);
6334				if (ret) {
6335					bg_failed++;
6336					bg_ret = ret;
6337					continue;
6338				}
6339			}
6340			ret = btrfs_trim_block_group(cache,
6341						     &group_trimmed,
6342						     start,
6343						     end,
6344						     range->minlen);
6345
6346			trimmed += group_trimmed;
6347			if (ret) {
6348				bg_failed++;
6349				bg_ret = ret;
6350				continue;
6351			}
6352		}
6353	}
6354
6355	if (bg_failed)
6356		btrfs_warn(fs_info,
6357			"failed to trim %llu block group(s), last error %d",
6358			bg_failed, bg_ret);
6359
6360	mutex_lock(&fs_devices->device_list_mutex);
6361	list_for_each_entry(device, &fs_devices->devices, dev_list) {
6362		if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))
6363			continue;
6364
6365		ret = btrfs_trim_free_extents(device, &group_trimmed);
6366		if (ret) {
6367			dev_failed++;
6368			dev_ret = ret;
6369			break;
6370		}
6371
6372		trimmed += group_trimmed;
6373	}
6374	mutex_unlock(&fs_devices->device_list_mutex);
6375
6376	if (dev_failed)
6377		btrfs_warn(fs_info,
6378			"failed to trim %llu device(s), last error %d",
6379			dev_failed, dev_ret);
6380	range->len = trimmed;
6381	if (bg_ret)
6382		return bg_ret;
6383	return dev_ret;
6384}
v3.5.6
 
   1/*
   2 * Copyright (C) 2007 Oracle.  All rights reserved.
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public
   6 * License v2 as published by the Free Software Foundation.
   7 *
   8 * This program is distributed in the hope that it will be useful,
   9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 * General Public License for more details.
  12 *
  13 * You should have received a copy of the GNU General Public
  14 * License along with this program; if not, write to the
  15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16 * Boston, MA 021110-1307, USA.
  17 */
 
  18#include <linux/sched.h>
 
  19#include <linux/pagemap.h>
  20#include <linux/writeback.h>
  21#include <linux/blkdev.h>
  22#include <linux/sort.h>
  23#include <linux/rcupdate.h>
  24#include <linux/kthread.h>
  25#include <linux/slab.h>
  26#include <linux/ratelimit.h>
  27#include "compat.h"
  28#include "hash.h"
 
  29#include "ctree.h"
 
 
  30#include "disk-io.h"
  31#include "print-tree.h"
  32#include "transaction.h"
  33#include "volumes.h"
 
  34#include "locking.h"
  35#include "free-space-cache.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  36
  37/*
  38 * control flags for do_chunk_alloc's force field
  39 * CHUNK_ALLOC_NO_FORCE means to only allocate a chunk
  40 * if we really need one.
  41 *
  42 * CHUNK_ALLOC_LIMITED means to only try and allocate one
  43 * if we have very few chunks already allocated.  This is
  44 * used as part of the clustering code to help make sure
  45 * we have a good pool of storage to cluster in, without
  46 * filling the FS with empty chunks
  47 *
  48 * CHUNK_ALLOC_FORCE means it must try to allocate one
  49 *
  50 */
  51enum {
  52	CHUNK_ALLOC_NO_FORCE = 0,
  53	CHUNK_ALLOC_LIMITED = 1,
  54	CHUNK_ALLOC_FORCE = 2,
  55};
  56
  57/*
  58 * Control how reservations are dealt with.
  59 *
  60 * RESERVE_FREE - freeing a reservation.
  61 * RESERVE_ALLOC - allocating space and we need to update bytes_may_use for
  62 *   ENOSPC accounting
  63 * RESERVE_ALLOC_NO_ACCOUNT - allocating space and we should not update
  64 *   bytes_may_use as the ENOSPC accounting is done elsewhere
  65 */
  66enum {
  67	RESERVE_FREE = 0,
  68	RESERVE_ALLOC = 1,
  69	RESERVE_ALLOC_NO_ACCOUNT = 2,
  70};
  71
  72static int update_block_group(struct btrfs_trans_handle *trans,
  73			      struct btrfs_root *root,
  74			      u64 bytenr, u64 num_bytes, int alloc);
  75static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
  76				struct btrfs_root *root,
  77				u64 bytenr, u64 num_bytes, u64 parent,
  78				u64 root_objectid, u64 owner_objectid,
  79				u64 owner_offset, int refs_to_drop,
  80				struct btrfs_delayed_extent_op *extra_op);
  81static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
  82				    struct extent_buffer *leaf,
  83				    struct btrfs_extent_item *ei);
  84static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
  85				      struct btrfs_root *root,
  86				      u64 parent, u64 root_objectid,
  87				      u64 flags, u64 owner, u64 offset,
  88				      struct btrfs_key *ins, int ref_mod);
  89static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
  90				     struct btrfs_root *root,
  91				     u64 parent, u64 root_objectid,
  92				     u64 flags, struct btrfs_disk_key *key,
  93				     int level, struct btrfs_key *ins);
  94static int do_chunk_alloc(struct btrfs_trans_handle *trans,
  95			  struct btrfs_root *extent_root, u64 alloc_bytes,
  96			  u64 flags, int force);
  97static int find_next_key(struct btrfs_path *path, int level,
  98			 struct btrfs_key *key);
  99static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
 100			    int dump_block_groups);
 101static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
 102				       u64 num_bytes, int reserve);
 103
 104static noinline int
 105block_group_cache_done(struct btrfs_block_group_cache *cache)
 106{
 107	smp_mb();
 108	return cache->cached == BTRFS_CACHE_FINISHED;
 109}
 110
 111static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
 112{
 113	return (cache->flags & bits) == bits;
 114}
 115
 116static void btrfs_get_block_group(struct btrfs_block_group_cache *cache)
 117{
 118	atomic_inc(&cache->count);
 119}
 120
 121void btrfs_put_block_group(struct btrfs_block_group_cache *cache)
 122{
 123	if (atomic_dec_and_test(&cache->count)) {
 124		WARN_ON(cache->pinned > 0);
 125		WARN_ON(cache->reserved > 0);
 126		kfree(cache->free_space_ctl);
 127		kfree(cache);
 128	}
 129}
 130
 131/*
 132 * this adds the block group to the fs_info rb tree for the block group
 133 * cache
 134 */
 135static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
 136				struct btrfs_block_group_cache *block_group)
 137{
 138	struct rb_node **p;
 139	struct rb_node *parent = NULL;
 140	struct btrfs_block_group_cache *cache;
 141
 142	spin_lock(&info->block_group_cache_lock);
 143	p = &info->block_group_cache_tree.rb_node;
 144
 145	while (*p) {
 146		parent = *p;
 147		cache = rb_entry(parent, struct btrfs_block_group_cache,
 148				 cache_node);
 149		if (block_group->key.objectid < cache->key.objectid) {
 150			p = &(*p)->rb_left;
 151		} else if (block_group->key.objectid > cache->key.objectid) {
 152			p = &(*p)->rb_right;
 153		} else {
 154			spin_unlock(&info->block_group_cache_lock);
 155			return -EEXIST;
 156		}
 157	}
 158
 159	rb_link_node(&block_group->cache_node, parent, p);
 160	rb_insert_color(&block_group->cache_node,
 161			&info->block_group_cache_tree);
 162	spin_unlock(&info->block_group_cache_lock);
 163
 164	return 0;
 165}
 166
 167/*
 168 * This will return the block group at or after bytenr if contains is 0, else
 169 * it will return the block group that contains the bytenr
 170 */
 171static struct btrfs_block_group_cache *
 172block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
 173			      int contains)
 174{
 175	struct btrfs_block_group_cache *cache, *ret = NULL;
 176	struct rb_node *n;
 177	u64 end, start;
 178
 179	spin_lock(&info->block_group_cache_lock);
 180	n = info->block_group_cache_tree.rb_node;
 181
 182	while (n) {
 183		cache = rb_entry(n, struct btrfs_block_group_cache,
 184				 cache_node);
 185		end = cache->key.objectid + cache->key.offset - 1;
 186		start = cache->key.objectid;
 187
 188		if (bytenr < start) {
 189			if (!contains && (!ret || start < ret->key.objectid))
 190				ret = cache;
 191			n = n->rb_left;
 192		} else if (bytenr > start) {
 193			if (contains && bytenr <= end) {
 194				ret = cache;
 195				break;
 196			}
 197			n = n->rb_right;
 198		} else {
 199			ret = cache;
 200			break;
 201		}
 202	}
 203	if (ret)
 204		btrfs_get_block_group(ret);
 205	spin_unlock(&info->block_group_cache_lock);
 206
 207	return ret;
 208}
 209
 210static int add_excluded_extent(struct btrfs_root *root,
 211			       u64 start, u64 num_bytes)
 212{
 213	u64 end = start + num_bytes - 1;
 214	set_extent_bits(&root->fs_info->freed_extents[0],
 215			start, end, EXTENT_UPTODATE, GFP_NOFS);
 216	set_extent_bits(&root->fs_info->freed_extents[1],
 217			start, end, EXTENT_UPTODATE, GFP_NOFS);
 218	return 0;
 219}
 220
 221static void free_excluded_extents(struct btrfs_root *root,
 222				  struct btrfs_block_group_cache *cache)
 223{
 224	u64 start, end;
 225
 226	start = cache->key.objectid;
 227	end = start + cache->key.offset - 1;
 228
 229	clear_extent_bits(&root->fs_info->freed_extents[0],
 230			  start, end, EXTENT_UPTODATE, GFP_NOFS);
 231	clear_extent_bits(&root->fs_info->freed_extents[1],
 232			  start, end, EXTENT_UPTODATE, GFP_NOFS);
 233}
 234
 235static int exclude_super_stripes(struct btrfs_root *root,
 236				 struct btrfs_block_group_cache *cache)
 237{
 238	u64 bytenr;
 239	u64 *logical;
 240	int stripe_len;
 241	int i, nr, ret;
 242
 243	if (cache->key.objectid < BTRFS_SUPER_INFO_OFFSET) {
 244		stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->key.objectid;
 245		cache->bytes_super += stripe_len;
 246		ret = add_excluded_extent(root, cache->key.objectid,
 247					  stripe_len);
 248		BUG_ON(ret); /* -ENOMEM */
 249	}
 250
 251	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
 252		bytenr = btrfs_sb_offset(i);
 253		ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
 254				       cache->key.objectid, bytenr,
 255				       0, &logical, &nr, &stripe_len);
 256		BUG_ON(ret); /* -ENOMEM */
 257
 258		while (nr--) {
 259			cache->bytes_super += stripe_len;
 260			ret = add_excluded_extent(root, logical[nr],
 261						  stripe_len);
 262			BUG_ON(ret); /* -ENOMEM */
 263		}
 264
 265		kfree(logical);
 266	}
 267	return 0;
 268}
 269
 270static struct btrfs_caching_control *
 271get_caching_control(struct btrfs_block_group_cache *cache)
 272{
 273	struct btrfs_caching_control *ctl;
 274
 275	spin_lock(&cache->lock);
 276	if (cache->cached != BTRFS_CACHE_STARTED) {
 277		spin_unlock(&cache->lock);
 278		return NULL;
 279	}
 280
 281	/* We're loading it the fast way, so we don't have a caching_ctl. */
 282	if (!cache->caching_ctl) {
 283		spin_unlock(&cache->lock);
 284		return NULL;
 285	}
 286
 287	ctl = cache->caching_ctl;
 288	atomic_inc(&ctl->count);
 289	spin_unlock(&cache->lock);
 290	return ctl;
 291}
 292
 293static void put_caching_control(struct btrfs_caching_control *ctl)
 294{
 295	if (atomic_dec_and_test(&ctl->count))
 296		kfree(ctl);
 297}
 298
 299/*
 300 * this is only called by cache_block_group, since we could have freed extents
 301 * we need to check the pinned_extents for any extents that can't be used yet
 302 * since their free space will be released as soon as the transaction commits.
 303 */
 304static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
 305			      struct btrfs_fs_info *info, u64 start, u64 end)
 306{
 307	u64 extent_start, extent_end, size, total_added = 0;
 308	int ret;
 309
 310	while (start < end) {
 311		ret = find_first_extent_bit(info->pinned_extents, start,
 312					    &extent_start, &extent_end,
 313					    EXTENT_DIRTY | EXTENT_UPTODATE);
 314		if (ret)
 315			break;
 316
 317		if (extent_start <= start) {
 318			start = extent_end + 1;
 319		} else if (extent_start > start && extent_start < end) {
 320			size = extent_start - start;
 321			total_added += size;
 322			ret = btrfs_add_free_space(block_group, start,
 323						   size);
 324			BUG_ON(ret); /* -ENOMEM or logic error */
 325			start = extent_end + 1;
 326		} else {
 327			break;
 328		}
 329	}
 330
 331	if (start < end) {
 332		size = end - start;
 333		total_added += size;
 334		ret = btrfs_add_free_space(block_group, start, size);
 335		BUG_ON(ret); /* -ENOMEM or logic error */
 336	}
 337
 338	return total_added;
 339}
 340
 341static noinline void caching_thread(struct btrfs_work *work)
 342{
 343	struct btrfs_block_group_cache *block_group;
 344	struct btrfs_fs_info *fs_info;
 345	struct btrfs_caching_control *caching_ctl;
 346	struct btrfs_root *extent_root;
 347	struct btrfs_path *path;
 348	struct extent_buffer *leaf;
 349	struct btrfs_key key;
 350	u64 total_found = 0;
 351	u64 last = 0;
 352	u32 nritems;
 353	int ret = 0;
 354
 355	caching_ctl = container_of(work, struct btrfs_caching_control, work);
 356	block_group = caching_ctl->block_group;
 357	fs_info = block_group->fs_info;
 358	extent_root = fs_info->extent_root;
 359
 360	path = btrfs_alloc_path();
 361	if (!path)
 362		goto out;
 363
 364	last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
 365
 366	/*
 367	 * We don't want to deadlock with somebody trying to allocate a new
 368	 * extent for the extent root while also trying to search the extent
 369	 * root to add free space.  So we skip locking and search the commit
 370	 * root, since its read-only
 371	 */
 372	path->skip_locking = 1;
 373	path->search_commit_root = 1;
 374	path->reada = 1;
 375
 376	key.objectid = last;
 377	key.offset = 0;
 378	key.type = BTRFS_EXTENT_ITEM_KEY;
 379again:
 380	mutex_lock(&caching_ctl->mutex);
 381	/* need to make sure the commit_root doesn't disappear */
 382	down_read(&fs_info->extent_commit_sem);
 383
 384	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
 385	if (ret < 0)
 386		goto err;
 387
 388	leaf = path->nodes[0];
 389	nritems = btrfs_header_nritems(leaf);
 390
 391	while (1) {
 392		if (btrfs_fs_closing(fs_info) > 1) {
 393			last = (u64)-1;
 394			break;
 395		}
 396
 397		if (path->slots[0] < nritems) {
 398			btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 399		} else {
 400			ret = find_next_key(path, 0, &key);
 401			if (ret)
 402				break;
 403
 404			if (need_resched() ||
 405			    btrfs_next_leaf(extent_root, path)) {
 406				caching_ctl->progress = last;
 407				btrfs_release_path(path);
 408				up_read(&fs_info->extent_commit_sem);
 409				mutex_unlock(&caching_ctl->mutex);
 410				cond_resched();
 411				goto again;
 412			}
 413			leaf = path->nodes[0];
 414			nritems = btrfs_header_nritems(leaf);
 415			continue;
 416		}
 417
 418		if (key.objectid < block_group->key.objectid) {
 419			path->slots[0]++;
 420			continue;
 421		}
 422
 423		if (key.objectid >= block_group->key.objectid +
 424		    block_group->key.offset)
 425			break;
 426
 427		if (key.type == BTRFS_EXTENT_ITEM_KEY) {
 428			total_found += add_new_free_space(block_group,
 429							  fs_info, last,
 430							  key.objectid);
 431			last = key.objectid + key.offset;
 432
 433			if (total_found > (1024 * 1024 * 2)) {
 434				total_found = 0;
 435				wake_up(&caching_ctl->wait);
 436			}
 437		}
 438		path->slots[0]++;
 439	}
 440	ret = 0;
 441
 442	total_found += add_new_free_space(block_group, fs_info, last,
 443					  block_group->key.objectid +
 444					  block_group->key.offset);
 445	caching_ctl->progress = (u64)-1;
 446
 447	spin_lock(&block_group->lock);
 448	block_group->caching_ctl = NULL;
 449	block_group->cached = BTRFS_CACHE_FINISHED;
 450	spin_unlock(&block_group->lock);
 451
 452err:
 453	btrfs_free_path(path);
 454	up_read(&fs_info->extent_commit_sem);
 455
 456	free_excluded_extents(extent_root, block_group);
 457
 458	mutex_unlock(&caching_ctl->mutex);
 459out:
 460	wake_up(&caching_ctl->wait);
 461
 462	put_caching_control(caching_ctl);
 463	btrfs_put_block_group(block_group);
 464}
 465
 466static int cache_block_group(struct btrfs_block_group_cache *cache,
 467			     struct btrfs_trans_handle *trans,
 468			     struct btrfs_root *root,
 469			     int load_cache_only)
 470{
 471	DEFINE_WAIT(wait);
 472	struct btrfs_fs_info *fs_info = cache->fs_info;
 473	struct btrfs_caching_control *caching_ctl;
 474	int ret = 0;
 475
 476	caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
 477	if (!caching_ctl)
 478		return -ENOMEM;
 479
 480	INIT_LIST_HEAD(&caching_ctl->list);
 481	mutex_init(&caching_ctl->mutex);
 482	init_waitqueue_head(&caching_ctl->wait);
 483	caching_ctl->block_group = cache;
 484	caching_ctl->progress = cache->key.objectid;
 485	atomic_set(&caching_ctl->count, 1);
 486	caching_ctl->work.func = caching_thread;
 487
 488	spin_lock(&cache->lock);
 489	/*
 490	 * This should be a rare occasion, but this could happen I think in the
 491	 * case where one thread starts to load the space cache info, and then
 492	 * some other thread starts a transaction commit which tries to do an
 493	 * allocation while the other thread is still loading the space cache
 494	 * info.  The previous loop should have kept us from choosing this block
 495	 * group, but if we've moved to the state where we will wait on caching
 496	 * block groups we need to first check if we're doing a fast load here,
 497	 * so we can wait for it to finish, otherwise we could end up allocating
 498	 * from a block group who's cache gets evicted for one reason or
 499	 * another.
 500	 */
 501	while (cache->cached == BTRFS_CACHE_FAST) {
 502		struct btrfs_caching_control *ctl;
 503
 504		ctl = cache->caching_ctl;
 505		atomic_inc(&ctl->count);
 506		prepare_to_wait(&ctl->wait, &wait, TASK_UNINTERRUPTIBLE);
 507		spin_unlock(&cache->lock);
 508
 509		schedule();
 510
 511		finish_wait(&ctl->wait, &wait);
 512		put_caching_control(ctl);
 513		spin_lock(&cache->lock);
 514	}
 515
 516	if (cache->cached != BTRFS_CACHE_NO) {
 517		spin_unlock(&cache->lock);
 518		kfree(caching_ctl);
 519		return 0;
 520	}
 521	WARN_ON(cache->caching_ctl);
 522	cache->caching_ctl = caching_ctl;
 523	cache->cached = BTRFS_CACHE_FAST;
 524	spin_unlock(&cache->lock);
 525
 526	/*
 527	 * We can't do the read from on-disk cache during a commit since we need
 528	 * to have the normal tree locking.  Also if we are currently trying to
 529	 * allocate blocks for the tree root we can't do the fast caching since
 530	 * we likely hold important locks.
 531	 */
 532	if (fs_info->mount_opt & BTRFS_MOUNT_SPACE_CACHE) {
 533		ret = load_free_space_cache(fs_info, cache);
 534
 535		spin_lock(&cache->lock);
 536		if (ret == 1) {
 537			cache->caching_ctl = NULL;
 538			cache->cached = BTRFS_CACHE_FINISHED;
 539			cache->last_byte_to_unpin = (u64)-1;
 540		} else {
 541			if (load_cache_only) {
 542				cache->caching_ctl = NULL;
 543				cache->cached = BTRFS_CACHE_NO;
 544			} else {
 545				cache->cached = BTRFS_CACHE_STARTED;
 546			}
 547		}
 548		spin_unlock(&cache->lock);
 549		wake_up(&caching_ctl->wait);
 550		if (ret == 1) {
 551			put_caching_control(caching_ctl);
 552			free_excluded_extents(fs_info->extent_root, cache);
 553			return 0;
 554		}
 555	} else {
 556		/*
 557		 * We are not going to do the fast caching, set cached to the
 558		 * appropriate value and wakeup any waiters.
 559		 */
 560		spin_lock(&cache->lock);
 561		if (load_cache_only) {
 562			cache->caching_ctl = NULL;
 563			cache->cached = BTRFS_CACHE_NO;
 564		} else {
 565			cache->cached = BTRFS_CACHE_STARTED;
 566		}
 567		spin_unlock(&cache->lock);
 568		wake_up(&caching_ctl->wait);
 569	}
 570
 571	if (load_cache_only) {
 572		put_caching_control(caching_ctl);
 573		return 0;
 574	}
 575
 576	down_write(&fs_info->extent_commit_sem);
 577	atomic_inc(&caching_ctl->count);
 578	list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
 579	up_write(&fs_info->extent_commit_sem);
 580
 581	btrfs_get_block_group(cache);
 582
 583	btrfs_queue_worker(&fs_info->caching_workers, &caching_ctl->work);
 584
 585	return ret;
 586}
 587
 588/*
 589 * return the block group that starts at or after bytenr
 590 */
 591static struct btrfs_block_group_cache *
 592btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
 593{
 594	struct btrfs_block_group_cache *cache;
 595
 596	cache = block_group_cache_tree_search(info, bytenr, 0);
 597
 598	return cache;
 599}
 600
 601/*
 602 * return the block group that contains the given bytenr
 603 */
 604struct btrfs_block_group_cache *btrfs_lookup_block_group(
 605						 struct btrfs_fs_info *info,
 606						 u64 bytenr)
 607{
 608	struct btrfs_block_group_cache *cache;
 609
 610	cache = block_group_cache_tree_search(info, bytenr, 1);
 611
 612	return cache;
 613}
 614
 615static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
 616						  u64 flags)
 617{
 618	struct list_head *head = &info->space_info;
 619	struct btrfs_space_info *found;
 620
 621	flags &= BTRFS_BLOCK_GROUP_TYPE_MASK;
 622
 623	rcu_read_lock();
 624	list_for_each_entry_rcu(found, head, list) {
 625		if (found->flags & flags) {
 626			rcu_read_unlock();
 627			return found;
 628		}
 629	}
 630	rcu_read_unlock();
 631	return NULL;
 632}
 633
 634/*
 635 * after adding space to the filesystem, we need to clear the full flags
 636 * on all the space infos.
 637 */
 638void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
 639{
 640	struct list_head *head = &info->space_info;
 641	struct btrfs_space_info *found;
 642
 643	rcu_read_lock();
 644	list_for_each_entry_rcu(found, head, list)
 645		found->full = 0;
 646	rcu_read_unlock();
 647}
 648
 649static u64 div_factor(u64 num, int factor)
 650{
 651	if (factor == 10)
 652		return num;
 653	num *= factor;
 654	do_div(num, 10);
 655	return num;
 656}
 657
 658static u64 div_factor_fine(u64 num, int factor)
 659{
 660	if (factor == 100)
 661		return num;
 662	num *= factor;
 663	do_div(num, 100);
 664	return num;
 665}
 666
 667u64 btrfs_find_block_group(struct btrfs_root *root,
 668			   u64 search_start, u64 search_hint, int owner)
 669{
 670	struct btrfs_block_group_cache *cache;
 671	u64 used;
 672	u64 last = max(search_hint, search_start);
 673	u64 group_start = 0;
 674	int full_search = 0;
 675	int factor = 9;
 676	int wrapped = 0;
 677again:
 678	while (1) {
 679		cache = btrfs_lookup_first_block_group(root->fs_info, last);
 680		if (!cache)
 681			break;
 682
 683		spin_lock(&cache->lock);
 684		last = cache->key.objectid + cache->key.offset;
 685		used = btrfs_block_group_used(&cache->item);
 686
 687		if ((full_search || !cache->ro) &&
 688		    block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
 689			if (used + cache->pinned + cache->reserved <
 690			    div_factor(cache->key.offset, factor)) {
 691				group_start = cache->key.objectid;
 692				spin_unlock(&cache->lock);
 693				btrfs_put_block_group(cache);
 694				goto found;
 695			}
 696		}
 697		spin_unlock(&cache->lock);
 698		btrfs_put_block_group(cache);
 699		cond_resched();
 700	}
 701	if (!wrapped) {
 702		last = search_start;
 703		wrapped = 1;
 704		goto again;
 705	}
 706	if (!full_search && factor < 10) {
 707		last = search_start;
 708		full_search = 1;
 709		factor = 10;
 710		goto again;
 711	}
 712found:
 713	return group_start;
 714}
 715
 716/* simple helper to search for an existing extent at a given offset */
 717int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
 718{
 
 719	int ret;
 720	struct btrfs_key key;
 721	struct btrfs_path *path;
 722
 723	path = btrfs_alloc_path();
 724	if (!path)
 725		return -ENOMEM;
 726
 727	key.objectid = start;
 728	key.offset = len;
 729	btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
 730	ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
 731				0, 0);
 732	btrfs_free_path(path);
 733	return ret;
 734}
 735
 736/*
 737 * helper function to lookup reference count and flags of extent.
 738 *
 739 * the head node for delayed ref is used to store the sum of all the
 740 * reference count modifications queued up in the rbtree. the head
 741 * node may also store the extent flags to set. This way you can check
 742 * to see what the reference count and extent flags would be if all of
 743 * the delayed refs are not processed.
 744 */
 745int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
 746			     struct btrfs_root *root, u64 bytenr,
 747			     u64 num_bytes, u64 *refs, u64 *flags)
 
 748{
 
 749	struct btrfs_delayed_ref_head *head;
 750	struct btrfs_delayed_ref_root *delayed_refs;
 751	struct btrfs_path *path;
 752	struct btrfs_extent_item *ei;
 753	struct extent_buffer *leaf;
 754	struct btrfs_key key;
 755	u32 item_size;
 756	u64 num_refs;
 757	u64 extent_flags;
 
 758	int ret;
 759
 
 
 
 
 
 
 
 
 
 760	path = btrfs_alloc_path();
 761	if (!path)
 762		return -ENOMEM;
 763
 764	key.objectid = bytenr;
 765	key.type = BTRFS_EXTENT_ITEM_KEY;
 766	key.offset = num_bytes;
 767	if (!trans) {
 768		path->skip_locking = 1;
 769		path->search_commit_root = 1;
 770	}
 771again:
 772	ret = btrfs_search_slot(trans, root->fs_info->extent_root,
 773				&key, path, 0, 0);
 
 
 
 
 
 
 
 
 774	if (ret < 0)
 775		goto out_free;
 776
 
 
 
 
 
 
 
 
 
 
 
 
 777	if (ret == 0) {
 778		leaf = path->nodes[0];
 779		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
 780		if (item_size >= sizeof(*ei)) {
 781			ei = btrfs_item_ptr(leaf, path->slots[0],
 782					    struct btrfs_extent_item);
 783			num_refs = btrfs_extent_refs(leaf, ei);
 784			extent_flags = btrfs_extent_flags(leaf, ei);
 
 
 785		} else {
 786#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 787			struct btrfs_extent_item_v0 *ei0;
 788			BUG_ON(item_size != sizeof(*ei0));
 789			ei0 = btrfs_item_ptr(leaf, path->slots[0],
 790					     struct btrfs_extent_item_v0);
 791			num_refs = btrfs_extent_refs_v0(leaf, ei0);
 792			/* FIXME: this isn't correct for data */
 793			extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
 794#else
 795			BUG();
 796#endif
 797		}
 
 798		BUG_ON(num_refs == 0);
 799	} else {
 800		num_refs = 0;
 801		extent_flags = 0;
 802		ret = 0;
 803	}
 804
 805	if (!trans)
 806		goto out;
 807
 808	delayed_refs = &trans->transaction->delayed_refs;
 809	spin_lock(&delayed_refs->lock);
 810	head = btrfs_find_delayed_ref_head(trans, bytenr);
 811	if (head) {
 812		if (!mutex_trylock(&head->mutex)) {
 813			atomic_inc(&head->node.refs);
 814			spin_unlock(&delayed_refs->lock);
 815
 816			btrfs_release_path(path);
 817
 818			/*
 819			 * Mutex was contended, block until it's released and try
 820			 * again
 821			 */
 822			mutex_lock(&head->mutex);
 823			mutex_unlock(&head->mutex);
 824			btrfs_put_delayed_ref(&head->node);
 825			goto again;
 826		}
 
 827		if (head->extent_op && head->extent_op->update_flags)
 828			extent_flags |= head->extent_op->flags_to_set;
 829		else
 830			BUG_ON(num_refs == 0);
 831
 832		num_refs += head->node.ref_mod;
 
 833		mutex_unlock(&head->mutex);
 834	}
 835	spin_unlock(&delayed_refs->lock);
 836out:
 837	WARN_ON(num_refs == 0);
 838	if (refs)
 839		*refs = num_refs;
 840	if (flags)
 841		*flags = extent_flags;
 
 
 842out_free:
 843	btrfs_free_path(path);
 844	return ret;
 845}
 846
 847/*
 848 * Back reference rules.  Back refs have three main goals:
 849 *
 850 * 1) differentiate between all holders of references to an extent so that
 851 *    when a reference is dropped we can make sure it was a valid reference
 852 *    before freeing the extent.
 853 *
 854 * 2) Provide enough information to quickly find the holders of an extent
 855 *    if we notice a given block is corrupted or bad.
 856 *
 857 * 3) Make it easy to migrate blocks for FS shrinking or storage pool
 858 *    maintenance.  This is actually the same as #2, but with a slightly
 859 *    different use case.
 860 *
 861 * There are two kinds of back refs. The implicit back refs is optimized
 862 * for pointers in non-shared tree blocks. For a given pointer in a block,
 863 * back refs of this kind provide information about the block's owner tree
 864 * and the pointer's key. These information allow us to find the block by
 865 * b-tree searching. The full back refs is for pointers in tree blocks not
 866 * referenced by their owner trees. The location of tree block is recorded
 867 * in the back refs. Actually the full back refs is generic, and can be
 868 * used in all cases the implicit back refs is used. The major shortcoming
 869 * of the full back refs is its overhead. Every time a tree block gets
 870 * COWed, we have to update back refs entry for all pointers in it.
 871 *
 872 * For a newly allocated tree block, we use implicit back refs for
 873 * pointers in it. This means most tree related operations only involve
 874 * implicit back refs. For a tree block created in old transaction, the
 875 * only way to drop a reference to it is COW it. So we can detect the
 876 * event that tree block loses its owner tree's reference and do the
 877 * back refs conversion.
 878 *
 879 * When a tree block is COW'd through a tree, there are four cases:
 880 *
 881 * The reference count of the block is one and the tree is the block's
 882 * owner tree. Nothing to do in this case.
 883 *
 884 * The reference count of the block is one and the tree is not the
 885 * block's owner tree. In this case, full back refs is used for pointers
 886 * in the block. Remove these full back refs, add implicit back refs for
 887 * every pointers in the new block.
 888 *
 889 * The reference count of the block is greater than one and the tree is
 890 * the block's owner tree. In this case, implicit back refs is used for
 891 * pointers in the block. Add full back refs for every pointers in the
 892 * block, increase lower level extents' reference counts. The original
 893 * implicit back refs are entailed to the new block.
 894 *
 895 * The reference count of the block is greater than one and the tree is
 896 * not the block's owner tree. Add implicit back refs for every pointer in
 897 * the new block, increase lower level extents' reference count.
 898 *
 899 * Back Reference Key composing:
 900 *
 901 * The key objectid corresponds to the first byte in the extent,
 902 * The key type is used to differentiate between types of back refs.
 903 * There are different meanings of the key offset for different types
 904 * of back refs.
 905 *
 906 * File extents can be referenced by:
 907 *
 908 * - multiple snapshots, subvolumes, or different generations in one subvol
 909 * - different files inside a single subvolume
 910 * - different offsets inside a file (bookend extents in file.c)
 911 *
 912 * The extent ref structure for the implicit back refs has fields for:
 913 *
 914 * - Objectid of the subvolume root
 915 * - objectid of the file holding the reference
 916 * - original offset in the file
 917 * - how many bookend extents
 918 *
 919 * The key offset for the implicit back refs is hash of the first
 920 * three fields.
 921 *
 922 * The extent ref structure for the full back refs has field for:
 923 *
 924 * - number of pointers in the tree leaf
 925 *
 926 * The key offset for the implicit back refs is the first byte of
 927 * the tree leaf
 928 *
 929 * When a file extent is allocated, The implicit back refs is used.
 930 * the fields are filled in:
 931 *
 932 *     (root_key.objectid, inode objectid, offset in file, 1)
 933 *
 934 * When a file extent is removed file truncation, we find the
 935 * corresponding implicit back refs and check the following fields:
 936 *
 937 *     (btrfs_header_owner(leaf), inode objectid, offset in file)
 938 *
 939 * Btree extents can be referenced by:
 940 *
 941 * - Different subvolumes
 942 *
 943 * Both the implicit back refs and the full back refs for tree blocks
 944 * only consist of key. The key offset for the implicit back refs is
 945 * objectid of block's owner tree. The key offset for the full back refs
 946 * is the first byte of parent block.
 947 *
 948 * When implicit back refs is used, information about the lowest key and
 949 * level of the tree block are required. These information are stored in
 950 * tree block info structure.
 951 */
 952
 953#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
 954static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
 955				  struct btrfs_root *root,
 956				  struct btrfs_path *path,
 957				  u64 owner, u32 extra_size)
 958{
 959	struct btrfs_extent_item *item;
 960	struct btrfs_extent_item_v0 *ei0;
 961	struct btrfs_extent_ref_v0 *ref0;
 962	struct btrfs_tree_block_info *bi;
 963	struct extent_buffer *leaf;
 964	struct btrfs_key key;
 965	struct btrfs_key found_key;
 966	u32 new_size = sizeof(*item);
 967	u64 refs;
 968	int ret;
 969
 970	leaf = path->nodes[0];
 971	BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));
 972
 973	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 974	ei0 = btrfs_item_ptr(leaf, path->slots[0],
 975			     struct btrfs_extent_item_v0);
 976	refs = btrfs_extent_refs_v0(leaf, ei0);
 977
 978	if (owner == (u64)-1) {
 979		while (1) {
 980			if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 981				ret = btrfs_next_leaf(root, path);
 982				if (ret < 0)
 983					return ret;
 984				BUG_ON(ret > 0); /* Corruption */
 985				leaf = path->nodes[0];
 986			}
 987			btrfs_item_key_to_cpu(leaf, &found_key,
 988					      path->slots[0]);
 989			BUG_ON(key.objectid != found_key.objectid);
 990			if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
 991				path->slots[0]++;
 992				continue;
 
 
 
 
 
 
 993			}
 994			ref0 = btrfs_item_ptr(leaf, path->slots[0],
 995					      struct btrfs_extent_ref_v0);
 996			owner = btrfs_ref_objectid_v0(leaf, ref0);
 997			break;
 998		}
 999	}
1000	btrfs_release_path(path);
1001
1002	if (owner < BTRFS_FIRST_FREE_OBJECTID)
1003		new_size += sizeof(*bi);
1004
1005	new_size -= sizeof(*ei0);
1006	ret = btrfs_search_slot(trans, root, &key, path,
1007				new_size + extra_size, 1);
1008	if (ret < 0)
1009		return ret;
1010	BUG_ON(ret); /* Corruption */
1011
1012	btrfs_extend_item(trans, root, path, new_size);
1013
1014	leaf = path->nodes[0];
1015	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1016	btrfs_set_extent_refs(leaf, item, refs);
1017	/* FIXME: get real generation */
1018	btrfs_set_extent_generation(leaf, item, 0);
1019	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1020		btrfs_set_extent_flags(leaf, item,
1021				       BTRFS_EXTENT_FLAG_TREE_BLOCK |
1022				       BTRFS_BLOCK_FLAG_FULL_BACKREF);
1023		bi = (struct btrfs_tree_block_info *)(item + 1);
1024		/* FIXME: get first key of the block */
1025		memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
1026		btrfs_set_tree_block_level(leaf, bi, (int)owner);
1027	} else {
1028		btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
1029	}
1030	btrfs_mark_buffer_dirty(leaf);
1031	return 0;
1032}
1033#endif
1034
1035static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
1036{
1037	u32 high_crc = ~(u32)0;
1038	u32 low_crc = ~(u32)0;
1039	__le64 lenum;
1040
1041	lenum = cpu_to_le64(root_objectid);
1042	high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
1043	lenum = cpu_to_le64(owner);
1044	low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
1045	lenum = cpu_to_le64(offset);
1046	low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
1047
1048	return ((u64)high_crc << 31) ^ (u64)low_crc;
1049}
1050
1051static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
1052				     struct btrfs_extent_data_ref *ref)
1053{
1054	return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
1055				    btrfs_extent_data_ref_objectid(leaf, ref),
1056				    btrfs_extent_data_ref_offset(leaf, ref));
1057}
1058
1059static int match_extent_data_ref(struct extent_buffer *leaf,
1060				 struct btrfs_extent_data_ref *ref,
1061				 u64 root_objectid, u64 owner, u64 offset)
1062{
1063	if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
1064	    btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
1065	    btrfs_extent_data_ref_offset(leaf, ref) != offset)
1066		return 0;
1067	return 1;
1068}
1069
1070static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
1071					   struct btrfs_root *root,
1072					   struct btrfs_path *path,
1073					   u64 bytenr, u64 parent,
1074					   u64 root_objectid,
1075					   u64 owner, u64 offset)
1076{
 
1077	struct btrfs_key key;
1078	struct btrfs_extent_data_ref *ref;
1079	struct extent_buffer *leaf;
1080	u32 nritems;
1081	int ret;
1082	int recow;
1083	int err = -ENOENT;
1084
1085	key.objectid = bytenr;
1086	if (parent) {
1087		key.type = BTRFS_SHARED_DATA_REF_KEY;
1088		key.offset = parent;
1089	} else {
1090		key.type = BTRFS_EXTENT_DATA_REF_KEY;
1091		key.offset = hash_extent_data_ref(root_objectid,
1092						  owner, offset);
1093	}
1094again:
1095	recow = 0;
1096	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1097	if (ret < 0) {
1098		err = ret;
1099		goto fail;
1100	}
1101
1102	if (parent) {
1103		if (!ret)
1104			return 0;
1105#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1106		key.type = BTRFS_EXTENT_REF_V0_KEY;
1107		btrfs_release_path(path);
1108		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1109		if (ret < 0) {
1110			err = ret;
1111			goto fail;
1112		}
1113		if (!ret)
1114			return 0;
1115#endif
1116		goto fail;
1117	}
1118
1119	leaf = path->nodes[0];
1120	nritems = btrfs_header_nritems(leaf);
1121	while (1) {
1122		if (path->slots[0] >= nritems) {
1123			ret = btrfs_next_leaf(root, path);
1124			if (ret < 0)
1125				err = ret;
1126			if (ret)
1127				goto fail;
1128
1129			leaf = path->nodes[0];
1130			nritems = btrfs_header_nritems(leaf);
1131			recow = 1;
1132		}
1133
1134		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1135		if (key.objectid != bytenr ||
1136		    key.type != BTRFS_EXTENT_DATA_REF_KEY)
1137			goto fail;
1138
1139		ref = btrfs_item_ptr(leaf, path->slots[0],
1140				     struct btrfs_extent_data_ref);
1141
1142		if (match_extent_data_ref(leaf, ref, root_objectid,
1143					  owner, offset)) {
1144			if (recow) {
1145				btrfs_release_path(path);
1146				goto again;
1147			}
1148			err = 0;
1149			break;
1150		}
1151		path->slots[0]++;
1152	}
1153fail:
1154	return err;
1155}
1156
1157static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
1158					   struct btrfs_root *root,
1159					   struct btrfs_path *path,
1160					   u64 bytenr, u64 parent,
1161					   u64 root_objectid, u64 owner,
1162					   u64 offset, int refs_to_add)
1163{
 
1164	struct btrfs_key key;
1165	struct extent_buffer *leaf;
1166	u32 size;
1167	u32 num_refs;
1168	int ret;
1169
1170	key.objectid = bytenr;
1171	if (parent) {
1172		key.type = BTRFS_SHARED_DATA_REF_KEY;
1173		key.offset = parent;
1174		size = sizeof(struct btrfs_shared_data_ref);
1175	} else {
1176		key.type = BTRFS_EXTENT_DATA_REF_KEY;
1177		key.offset = hash_extent_data_ref(root_objectid,
1178						  owner, offset);
1179		size = sizeof(struct btrfs_extent_data_ref);
1180	}
1181
1182	ret = btrfs_insert_empty_item(trans, root, path, &key, size);
1183	if (ret && ret != -EEXIST)
1184		goto fail;
1185
1186	leaf = path->nodes[0];
1187	if (parent) {
1188		struct btrfs_shared_data_ref *ref;
1189		ref = btrfs_item_ptr(leaf, path->slots[0],
1190				     struct btrfs_shared_data_ref);
1191		if (ret == 0) {
1192			btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
1193		} else {
1194			num_refs = btrfs_shared_data_ref_count(leaf, ref);
1195			num_refs += refs_to_add;
1196			btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
1197		}
1198	} else {
1199		struct btrfs_extent_data_ref *ref;
1200		while (ret == -EEXIST) {
1201			ref = btrfs_item_ptr(leaf, path->slots[0],
1202					     struct btrfs_extent_data_ref);
1203			if (match_extent_data_ref(leaf, ref, root_objectid,
1204						  owner, offset))
1205				break;
1206			btrfs_release_path(path);
1207			key.offset++;
1208			ret = btrfs_insert_empty_item(trans, root, path, &key,
1209						      size);
1210			if (ret && ret != -EEXIST)
1211				goto fail;
1212
1213			leaf = path->nodes[0];
1214		}
1215		ref = btrfs_item_ptr(leaf, path->slots[0],
1216				     struct btrfs_extent_data_ref);
1217		if (ret == 0) {
1218			btrfs_set_extent_data_ref_root(leaf, ref,
1219						       root_objectid);
1220			btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
1221			btrfs_set_extent_data_ref_offset(leaf, ref, offset);
1222			btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
1223		} else {
1224			num_refs = btrfs_extent_data_ref_count(leaf, ref);
1225			num_refs += refs_to_add;
1226			btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
1227		}
1228	}
1229	btrfs_mark_buffer_dirty(leaf);
1230	ret = 0;
1231fail:
1232	btrfs_release_path(path);
1233	return ret;
1234}
1235
1236static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
1237					   struct btrfs_root *root,
1238					   struct btrfs_path *path,
1239					   int refs_to_drop)
1240{
1241	struct btrfs_key key;
1242	struct btrfs_extent_data_ref *ref1 = NULL;
1243	struct btrfs_shared_data_ref *ref2 = NULL;
1244	struct extent_buffer *leaf;
1245	u32 num_refs = 0;
1246	int ret = 0;
1247
1248	leaf = path->nodes[0];
1249	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1250
1251	if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1252		ref1 = btrfs_item_ptr(leaf, path->slots[0],
1253				      struct btrfs_extent_data_ref);
1254		num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1255	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1256		ref2 = btrfs_item_ptr(leaf, path->slots[0],
1257				      struct btrfs_shared_data_ref);
1258		num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1259#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1260	} else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1261		struct btrfs_extent_ref_v0 *ref0;
1262		ref0 = btrfs_item_ptr(leaf, path->slots[0],
1263				      struct btrfs_extent_ref_v0);
1264		num_refs = btrfs_ref_count_v0(leaf, ref0);
1265#endif
1266	} else {
1267		BUG();
 
 
 
 
1268	}
1269
1270	BUG_ON(num_refs < refs_to_drop);
1271	num_refs -= refs_to_drop;
1272
1273	if (num_refs == 0) {
1274		ret = btrfs_del_item(trans, root, path);
1275	} else {
1276		if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
1277			btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
1278		else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
1279			btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
1280#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1281		else {
1282			struct btrfs_extent_ref_v0 *ref0;
1283			ref0 = btrfs_item_ptr(leaf, path->slots[0],
1284					struct btrfs_extent_ref_v0);
1285			btrfs_set_ref_count_v0(leaf, ref0, num_refs);
1286		}
1287#endif
1288		btrfs_mark_buffer_dirty(leaf);
1289	}
1290	return ret;
1291}
1292
1293static noinline u32 extent_data_ref_count(struct btrfs_root *root,
1294					  struct btrfs_path *path,
1295					  struct btrfs_extent_inline_ref *iref)
1296{
1297	struct btrfs_key key;
1298	struct extent_buffer *leaf;
1299	struct btrfs_extent_data_ref *ref1;
1300	struct btrfs_shared_data_ref *ref2;
1301	u32 num_refs = 0;
 
1302
1303	leaf = path->nodes[0];
1304	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 
1305	if (iref) {
1306		if (btrfs_extent_inline_ref_type(leaf, iref) ==
1307		    BTRFS_EXTENT_DATA_REF_KEY) {
 
 
 
 
 
1308			ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
1309			num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1310		} else {
1311			ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
1312			num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1313		}
1314	} else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1315		ref1 = btrfs_item_ptr(leaf, path->slots[0],
1316				      struct btrfs_extent_data_ref);
1317		num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1318	} else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1319		ref2 = btrfs_item_ptr(leaf, path->slots[0],
1320				      struct btrfs_shared_data_ref);
1321		num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1322#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1323	} else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1324		struct btrfs_extent_ref_v0 *ref0;
1325		ref0 = btrfs_item_ptr(leaf, path->slots[0],
1326				      struct btrfs_extent_ref_v0);
1327		num_refs = btrfs_ref_count_v0(leaf, ref0);
1328#endif
1329	} else {
1330		WARN_ON(1);
1331	}
1332	return num_refs;
1333}
1334
1335static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
1336					  struct btrfs_root *root,
1337					  struct btrfs_path *path,
1338					  u64 bytenr, u64 parent,
1339					  u64 root_objectid)
1340{
 
1341	struct btrfs_key key;
1342	int ret;
1343
1344	key.objectid = bytenr;
1345	if (parent) {
1346		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1347		key.offset = parent;
1348	} else {
1349		key.type = BTRFS_TREE_BLOCK_REF_KEY;
1350		key.offset = root_objectid;
1351	}
1352
1353	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1354	if (ret > 0)
1355		ret = -ENOENT;
1356#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1357	if (ret == -ENOENT && parent) {
1358		btrfs_release_path(path);
1359		key.type = BTRFS_EXTENT_REF_V0_KEY;
1360		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1361		if (ret > 0)
1362			ret = -ENOENT;
1363	}
1364#endif
1365	return ret;
1366}
1367
1368static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
1369					  struct btrfs_root *root,
1370					  struct btrfs_path *path,
1371					  u64 bytenr, u64 parent,
1372					  u64 root_objectid)
1373{
 
1374	struct btrfs_key key;
1375	int ret;
1376
1377	key.objectid = bytenr;
1378	if (parent) {
1379		key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1380		key.offset = parent;
1381	} else {
1382		key.type = BTRFS_TREE_BLOCK_REF_KEY;
1383		key.offset = root_objectid;
1384	}
1385
1386	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1387	btrfs_release_path(path);
1388	return ret;
1389}
1390
1391static inline int extent_ref_type(u64 parent, u64 owner)
1392{
1393	int type;
1394	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1395		if (parent > 0)
1396			type = BTRFS_SHARED_BLOCK_REF_KEY;
1397		else
1398			type = BTRFS_TREE_BLOCK_REF_KEY;
1399	} else {
1400		if (parent > 0)
1401			type = BTRFS_SHARED_DATA_REF_KEY;
1402		else
1403			type = BTRFS_EXTENT_DATA_REF_KEY;
1404	}
1405	return type;
1406}
1407
1408static int find_next_key(struct btrfs_path *path, int level,
1409			 struct btrfs_key *key)
1410
1411{
1412	for (; level < BTRFS_MAX_LEVEL; level++) {
1413		if (!path->nodes[level])
1414			break;
1415		if (path->slots[level] + 1 >=
1416		    btrfs_header_nritems(path->nodes[level]))
1417			continue;
1418		if (level == 0)
1419			btrfs_item_key_to_cpu(path->nodes[level], key,
1420					      path->slots[level] + 1);
1421		else
1422			btrfs_node_key_to_cpu(path->nodes[level], key,
1423					      path->slots[level] + 1);
1424		return 0;
1425	}
1426	return 1;
1427}
1428
1429/*
1430 * look for inline back ref. if back ref is found, *ref_ret is set
1431 * to the address of inline back ref, and 0 is returned.
1432 *
1433 * if back ref isn't found, *ref_ret is set to the address where it
1434 * should be inserted, and -ENOENT is returned.
1435 *
1436 * if insert is true and there are too many inline back refs, the path
1437 * points to the extent item, and -EAGAIN is returned.
1438 *
1439 * NOTE: inline back refs are ordered in the same way that back ref
1440 *	 items in the tree are ordered.
1441 */
1442static noinline_for_stack
1443int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
1444				 struct btrfs_root *root,
1445				 struct btrfs_path *path,
1446				 struct btrfs_extent_inline_ref **ref_ret,
1447				 u64 bytenr, u64 num_bytes,
1448				 u64 parent, u64 root_objectid,
1449				 u64 owner, u64 offset, int insert)
1450{
 
 
1451	struct btrfs_key key;
1452	struct extent_buffer *leaf;
1453	struct btrfs_extent_item *ei;
1454	struct btrfs_extent_inline_ref *iref;
1455	u64 flags;
1456	u64 item_size;
1457	unsigned long ptr;
1458	unsigned long end;
1459	int extra_size;
1460	int type;
1461	int want;
1462	int ret;
1463	int err = 0;
 
1464
1465	key.objectid = bytenr;
1466	key.type = BTRFS_EXTENT_ITEM_KEY;
1467	key.offset = num_bytes;
1468
1469	want = extent_ref_type(parent, owner);
1470	if (insert) {
1471		extra_size = btrfs_extent_inline_ref_size(want);
 
1472		path->keep_locks = 1;
1473	} else
1474		extra_size = -1;
 
 
 
 
 
 
 
 
 
 
 
1475	ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
1476	if (ret < 0) {
1477		err = ret;
1478		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1479	}
 
1480	if (ret && !insert) {
1481		err = -ENOENT;
 
 
 
 
 
 
 
 
1482		goto out;
1483	}
1484	BUG_ON(ret); /* Corruption */
1485
1486	leaf = path->nodes[0];
1487	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1488#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1489	if (item_size < sizeof(*ei)) {
1490		if (!insert) {
1491			err = -ENOENT;
1492			goto out;
1493		}
1494		ret = convert_extent_item_v0(trans, root, path, owner,
1495					     extra_size);
1496		if (ret < 0) {
1497			err = ret;
1498			goto out;
1499		}
1500		leaf = path->nodes[0];
1501		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1502	}
1503#endif
1504	BUG_ON(item_size < sizeof(*ei));
1505
1506	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1507	flags = btrfs_extent_flags(leaf, ei);
1508
1509	ptr = (unsigned long)(ei + 1);
1510	end = (unsigned long)ei + item_size;
1511
1512	if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1513		ptr += sizeof(struct btrfs_tree_block_info);
1514		BUG_ON(ptr > end);
1515	} else {
1516		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
1517	}
1518
1519	err = -ENOENT;
1520	while (1) {
1521		if (ptr >= end) {
1522			WARN_ON(ptr > end);
1523			break;
 
 
 
 
 
 
 
 
 
 
 
 
1524		}
1525		iref = (struct btrfs_extent_inline_ref *)ptr;
1526		type = btrfs_extent_inline_ref_type(leaf, iref);
1527		if (want < type)
1528			break;
1529		if (want > type) {
1530			ptr += btrfs_extent_inline_ref_size(type);
1531			continue;
1532		}
1533
1534		if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1535			struct btrfs_extent_data_ref *dref;
1536			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1537			if (match_extent_data_ref(leaf, dref, root_objectid,
1538						  owner, offset)) {
1539				err = 0;
1540				break;
1541			}
1542			if (hash_extent_data_ref_item(leaf, dref) <
1543			    hash_extent_data_ref(root_objectid, owner, offset))
1544				break;
1545		} else {
1546			u64 ref_offset;
1547			ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1548			if (parent > 0) {
1549				if (parent == ref_offset) {
1550					err = 0;
1551					break;
1552				}
1553				if (ref_offset < parent)
1554					break;
1555			} else {
1556				if (root_objectid == ref_offset) {
1557					err = 0;
1558					break;
1559				}
1560				if (ref_offset < root_objectid)
1561					break;
1562			}
1563		}
1564		ptr += btrfs_extent_inline_ref_size(type);
1565	}
1566	if (err == -ENOENT && insert) {
 
 
 
 
 
 
 
 
 
 
1567		if (item_size + extra_size >=
1568		    BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
1569			err = -EAGAIN;
1570			goto out;
1571		}
1572		/*
1573		 * To add new inline back ref, we have to make sure
1574		 * there is no corresponding back ref item.
1575		 * For simplicity, we just do not add new inline back
1576		 * ref if there is any kind of item for this block
1577		 */
1578		if (find_next_key(path, 0, &key) == 0 &&
1579		    key.objectid == bytenr &&
1580		    key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
1581			err = -EAGAIN;
1582			goto out;
1583		}
1584	}
1585	*ref_ret = (struct btrfs_extent_inline_ref *)ptr;
1586out:
1587	if (insert) {
1588		path->keep_locks = 0;
 
1589		btrfs_unlock_up_safe(path, 1);
1590	}
1591	return err;
1592}
1593
1594/*
1595 * helper to add new inline back ref
1596 */
1597static noinline_for_stack
1598void setup_inline_extent_backref(struct btrfs_trans_handle *trans,
1599				 struct btrfs_root *root,
1600				 struct btrfs_path *path,
1601				 struct btrfs_extent_inline_ref *iref,
1602				 u64 parent, u64 root_objectid,
1603				 u64 owner, u64 offset, int refs_to_add,
1604				 struct btrfs_delayed_extent_op *extent_op)
1605{
1606	struct extent_buffer *leaf;
1607	struct btrfs_extent_item *ei;
1608	unsigned long ptr;
1609	unsigned long end;
1610	unsigned long item_offset;
1611	u64 refs;
1612	int size;
1613	int type;
1614
1615	leaf = path->nodes[0];
1616	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1617	item_offset = (unsigned long)iref - (unsigned long)ei;
1618
1619	type = extent_ref_type(parent, owner);
1620	size = btrfs_extent_inline_ref_size(type);
1621
1622	btrfs_extend_item(trans, root, path, size);
1623
1624	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1625	refs = btrfs_extent_refs(leaf, ei);
1626	refs += refs_to_add;
1627	btrfs_set_extent_refs(leaf, ei, refs);
1628	if (extent_op)
1629		__run_delayed_extent_op(extent_op, leaf, ei);
1630
1631	ptr = (unsigned long)ei + item_offset;
1632	end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
1633	if (ptr < end - size)
1634		memmove_extent_buffer(leaf, ptr + size, ptr,
1635				      end - size - ptr);
1636
1637	iref = (struct btrfs_extent_inline_ref *)ptr;
1638	btrfs_set_extent_inline_ref_type(leaf, iref, type);
1639	if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1640		struct btrfs_extent_data_ref *dref;
1641		dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1642		btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
1643		btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
1644		btrfs_set_extent_data_ref_offset(leaf, dref, offset);
1645		btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
1646	} else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1647		struct btrfs_shared_data_ref *sref;
1648		sref = (struct btrfs_shared_data_ref *)(iref + 1);
1649		btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
1650		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1651	} else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
1652		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1653	} else {
1654		btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
1655	}
1656	btrfs_mark_buffer_dirty(leaf);
1657}
1658
1659static int lookup_extent_backref(struct btrfs_trans_handle *trans,
1660				 struct btrfs_root *root,
1661				 struct btrfs_path *path,
1662				 struct btrfs_extent_inline_ref **ref_ret,
1663				 u64 bytenr, u64 num_bytes, u64 parent,
1664				 u64 root_objectid, u64 owner, u64 offset)
1665{
1666	int ret;
1667
1668	ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
1669					   bytenr, num_bytes, parent,
1670					   root_objectid, owner, offset, 0);
1671	if (ret != -ENOENT)
1672		return ret;
1673
1674	btrfs_release_path(path);
1675	*ref_ret = NULL;
1676
1677	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1678		ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
1679					    root_objectid);
1680	} else {
1681		ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
1682					     root_objectid, owner, offset);
1683	}
1684	return ret;
1685}
1686
1687/*
1688 * helper to update/remove inline back ref
1689 */
1690static noinline_for_stack
1691void update_inline_extent_backref(struct btrfs_trans_handle *trans,
1692				  struct btrfs_root *root,
1693				  struct btrfs_path *path,
1694				  struct btrfs_extent_inline_ref *iref,
1695				  int refs_to_mod,
1696				  struct btrfs_delayed_extent_op *extent_op)
1697{
1698	struct extent_buffer *leaf;
 
1699	struct btrfs_extent_item *ei;
1700	struct btrfs_extent_data_ref *dref = NULL;
1701	struct btrfs_shared_data_ref *sref = NULL;
1702	unsigned long ptr;
1703	unsigned long end;
1704	u32 item_size;
1705	int size;
1706	int type;
1707	u64 refs;
1708
1709	leaf = path->nodes[0];
1710	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1711	refs = btrfs_extent_refs(leaf, ei);
1712	WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1713	refs += refs_to_mod;
1714	btrfs_set_extent_refs(leaf, ei, refs);
1715	if (extent_op)
1716		__run_delayed_extent_op(extent_op, leaf, ei);
1717
1718	type = btrfs_extent_inline_ref_type(leaf, iref);
 
 
 
 
 
 
1719
1720	if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1721		dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1722		refs = btrfs_extent_data_ref_count(leaf, dref);
1723	} else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1724		sref = (struct btrfs_shared_data_ref *)(iref + 1);
1725		refs = btrfs_shared_data_ref_count(leaf, sref);
1726	} else {
1727		refs = 1;
1728		BUG_ON(refs_to_mod != -1);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1729	}
1730
1731	BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1732	refs += refs_to_mod;
1733
1734	if (refs > 0) {
1735		if (type == BTRFS_EXTENT_DATA_REF_KEY)
1736			btrfs_set_extent_data_ref_count(leaf, dref, refs);
1737		else
1738			btrfs_set_shared_data_ref_count(leaf, sref, refs);
1739	} else {
1740		size =  btrfs_extent_inline_ref_size(type);
1741		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1742		ptr = (unsigned long)iref;
1743		end = (unsigned long)ei + item_size;
1744		if (ptr + size < end)
1745			memmove_extent_buffer(leaf, ptr, ptr + size,
1746					      end - ptr - size);
1747		item_size -= size;
1748		btrfs_truncate_item(trans, root, path, item_size, 1);
1749	}
1750	btrfs_mark_buffer_dirty(leaf);
 
1751}
1752
1753static noinline_for_stack
1754int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
1755				 struct btrfs_root *root,
1756				 struct btrfs_path *path,
1757				 u64 bytenr, u64 num_bytes, u64 parent,
1758				 u64 root_objectid, u64 owner,
1759				 u64 offset, int refs_to_add,
1760				 struct btrfs_delayed_extent_op *extent_op)
1761{
1762	struct btrfs_extent_inline_ref *iref;
1763	int ret;
1764
1765	ret = lookup_inline_extent_backref(trans, root, path, &iref,
1766					   bytenr, num_bytes, parent,
1767					   root_objectid, owner, offset, 1);
1768	if (ret == 0) {
1769		BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
1770		update_inline_extent_backref(trans, root, path, iref,
1771					     refs_to_add, extent_op);
 
 
 
 
 
 
 
 
 
 
1772	} else if (ret == -ENOENT) {
1773		setup_inline_extent_backref(trans, root, path, iref, parent,
1774					    root_objectid, owner, offset,
1775					    refs_to_add, extent_op);
1776		ret = 0;
1777	}
1778	return ret;
1779}
1780
1781static int insert_extent_backref(struct btrfs_trans_handle *trans,
1782				 struct btrfs_root *root,
1783				 struct btrfs_path *path,
1784				 u64 bytenr, u64 parent, u64 root_objectid,
1785				 u64 owner, u64 offset, int refs_to_add)
1786{
1787	int ret;
1788	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1789		BUG_ON(refs_to_add != 1);
1790		ret = insert_tree_block_ref(trans, root, path, bytenr,
1791					    parent, root_objectid);
1792	} else {
1793		ret = insert_extent_data_ref(trans, root, path, bytenr,
1794					     parent, root_objectid,
1795					     owner, offset, refs_to_add);
1796	}
1797	return ret;
1798}
1799
1800static int remove_extent_backref(struct btrfs_trans_handle *trans,
1801				 struct btrfs_root *root,
1802				 struct btrfs_path *path,
1803				 struct btrfs_extent_inline_ref *iref,
1804				 int refs_to_drop, int is_data)
1805{
1806	int ret = 0;
1807
1808	BUG_ON(!is_data && refs_to_drop != 1);
1809	if (iref) {
1810		update_inline_extent_backref(trans, root, path, iref,
1811					     -refs_to_drop, NULL);
1812	} else if (is_data) {
1813		ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
1814	} else {
1815		ret = btrfs_del_item(trans, root, path);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1816	}
1817	return ret;
1818}
1819
1820static int btrfs_issue_discard(struct block_device *bdev,
1821				u64 start, u64 len)
1822{
1823	return blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_NOFS, 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1824}
1825
1826static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
1827				u64 num_bytes, u64 *actual_bytes)
1828{
1829	int ret;
1830	u64 discarded_bytes = 0;
1831	struct btrfs_bio *bbio = NULL;
 
1832
 
 
 
 
 
 
 
 
 
1833
1834	/* Tell the block device(s) that the sectors can be discarded */
1835	ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD,
1836			      bytenr, &num_bytes, &bbio, 0);
1837	/* Error condition is -ENOMEM */
1838	if (!ret) {
1839		struct btrfs_bio_stripe *stripe = bbio->stripes;
1840		int i;
 
1841
 
 
 
1842
1843		for (i = 0; i < bbio->num_stripes; i++, stripe++) {
1844			if (!stripe->dev->can_discard)
1845				continue;
 
1846
1847			ret = btrfs_issue_discard(stripe->dev->bdev,
1848						  stripe->physical,
1849						  stripe->length);
1850			if (!ret)
1851				discarded_bytes += stripe->length;
1852			else if (ret != -EOPNOTSUPP)
1853				break; /* Logic errors or -ENOMEM, or -EIO but I don't know how that could happen JDM */
1854
1855			/*
1856			 * Just in case we get back EOPNOTSUPP for some reason,
1857			 * just ignore the return value so we don't screw up
1858			 * people calling discard_extent.
1859			 */
1860			ret = 0;
 
 
 
 
 
 
1861		}
1862		kfree(bbio);
 
 
 
1863	}
1864
1865	if (actual_bytes)
1866		*actual_bytes = discarded_bytes;
1867
1868
1869	return ret;
1870}
1871
1872/* Can return -ENOMEM */
1873int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1874			 struct btrfs_root *root,
1875			 u64 bytenr, u64 num_bytes, u64 parent,
1876			 u64 root_objectid, u64 owner, u64 offset, int for_cow)
1877{
 
1878	int ret;
1879	struct btrfs_fs_info *fs_info = root->fs_info;
1880
1881	BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
1882	       root_objectid == BTRFS_TREE_LOG_OBJECTID);
 
 
 
 
 
 
 
 
 
1883
1884	if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1885		ret = btrfs_add_delayed_tree_ref(fs_info, trans, bytenr,
1886					num_bytes,
1887					parent, root_objectid, (int)owner,
1888					BTRFS_ADD_DELAYED_REF, NULL, for_cow);
1889	} else {
1890		ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr,
1891					num_bytes,
1892					parent, root_objectid, owner, offset,
1893					BTRFS_ADD_DELAYED_REF, NULL, for_cow);
1894	}
1895	return ret;
1896}
1897
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1898static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1899				  struct btrfs_root *root,
1900				  u64 bytenr, u64 num_bytes,
1901				  u64 parent, u64 root_objectid,
1902				  u64 owner, u64 offset, int refs_to_add,
1903				  struct btrfs_delayed_extent_op *extent_op)
1904{
1905	struct btrfs_path *path;
1906	struct extent_buffer *leaf;
1907	struct btrfs_extent_item *item;
 
 
 
1908	u64 refs;
 
1909	int ret;
1910	int err = 0;
1911
1912	path = btrfs_alloc_path();
1913	if (!path)
1914		return -ENOMEM;
1915
1916	path->reada = 1;
1917	path->leave_spinning = 1;
1918	/* this will setup the path even if it fails to insert the back ref */
1919	ret = insert_inline_extent_backref(trans, root->fs_info->extent_root,
1920					   path, bytenr, num_bytes, parent,
1921					   root_objectid, owner, offset,
1922					   refs_to_add, extent_op);
1923	if (ret == 0)
1924		goto out;
1925
1926	if (ret != -EAGAIN) {
1927		err = ret;
1928		goto out;
1929	}
1930
1931	leaf = path->nodes[0];
 
1932	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1933	refs = btrfs_extent_refs(leaf, item);
1934	btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
1935	if (extent_op)
1936		__run_delayed_extent_op(extent_op, leaf, item);
1937
1938	btrfs_mark_buffer_dirty(leaf);
1939	btrfs_release_path(path);
1940
1941	path->reada = 1;
1942	path->leave_spinning = 1;
 
 
 
 
 
 
1943
1944	/* now insert the actual backref */
1945	ret = insert_extent_backref(trans, root->fs_info->extent_root,
1946				    path, bytenr, parent, root_objectid,
1947				    owner, offset, refs_to_add);
1948	if (ret)
1949		btrfs_abort_transaction(trans, root, ret);
1950out:
1951	btrfs_free_path(path);
1952	return err;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1953}
1954
1955static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
1956				struct btrfs_root *root,
1957				struct btrfs_delayed_ref_node *node,
1958				struct btrfs_delayed_extent_op *extent_op,
1959				int insert_reserved)
1960{
1961	int ret = 0;
1962	struct btrfs_delayed_data_ref *ref;
1963	struct btrfs_key ins;
1964	u64 parent = 0;
1965	u64 ref_root = 0;
1966	u64 flags = 0;
1967
1968	ins.objectid = node->bytenr;
1969	ins.offset = node->num_bytes;
1970	ins.type = BTRFS_EXTENT_ITEM_KEY;
1971
1972	ref = btrfs_delayed_node_to_data_ref(node);
1973	if (node->type == BTRFS_SHARED_DATA_REF_KEY)
1974		parent = ref->parent;
1975	else
1976		ref_root = ref->root;
1977
1978	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1979		if (extent_op) {
1980			BUG_ON(extent_op->update_key);
 
 
 
 
 
 
 
 
1981			flags |= extent_op->flags_to_set;
1982		}
1983		ret = alloc_reserved_file_extent(trans, root,
1984						 parent, ref_root, flags,
1985						 ref->objectid, ref->offset,
1986						 &ins, node->ref_mod);
 
 
 
 
 
 
 
1987	} else if (node->action == BTRFS_ADD_DELAYED_REF) {
1988		ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
1989					     node->num_bytes, parent,
1990					     ref_root, ref->objectid,
1991					     ref->offset, node->ref_mod,
1992					     extent_op);
1993	} else if (node->action == BTRFS_DROP_DELAYED_REF) {
1994		ret = __btrfs_free_extent(trans, root, node->bytenr,
1995					  node->num_bytes, parent,
1996					  ref_root, ref->objectid,
1997					  ref->offset, node->ref_mod,
1998					  extent_op);
1999	} else {
2000		BUG();
2001	}
2002	return ret;
2003}
2004
2005static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
2006				    struct extent_buffer *leaf,
2007				    struct btrfs_extent_item *ei)
2008{
2009	u64 flags = btrfs_extent_flags(leaf, ei);
2010	if (extent_op->update_flags) {
2011		flags |= extent_op->flags_to_set;
2012		btrfs_set_extent_flags(leaf, ei, flags);
2013	}
2014
2015	if (extent_op->update_key) {
2016		struct btrfs_tree_block_info *bi;
2017		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
2018		bi = (struct btrfs_tree_block_info *)(ei + 1);
2019		btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
2020	}
2021}
2022
2023static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
2024				 struct btrfs_root *root,
2025				 struct btrfs_delayed_ref_node *node,
2026				 struct btrfs_delayed_extent_op *extent_op)
2027{
 
 
2028	struct btrfs_key key;
2029	struct btrfs_path *path;
2030	struct btrfs_extent_item *ei;
2031	struct extent_buffer *leaf;
2032	u32 item_size;
2033	int ret;
2034	int err = 0;
2035
2036	if (trans->aborted)
2037		return 0;
2038
 
 
 
2039	path = btrfs_alloc_path();
2040	if (!path)
2041		return -ENOMEM;
2042
2043	key.objectid = node->bytenr;
2044	key.type = BTRFS_EXTENT_ITEM_KEY;
2045	key.offset = node->num_bytes;
 
 
 
 
 
 
2046
2047	path->reada = 1;
2048	path->leave_spinning = 1;
2049	ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key,
2050				path, 0, 1);
2051	if (ret < 0) {
2052		err = ret;
2053		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2054	}
2055	if (ret > 0) {
2056		err = -EIO;
 
 
 
 
 
 
 
 
2057		goto out;
2058	}
2059
2060	leaf = path->nodes[0];
2061	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2062#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2063	if (item_size < sizeof(*ei)) {
2064		ret = convert_extent_item_v0(trans, root->fs_info->extent_root,
2065					     path, (u64)-1, 0);
2066		if (ret < 0) {
2067			err = ret;
2068			goto out;
2069		}
2070		leaf = path->nodes[0];
2071		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2072	}
2073#endif
2074	BUG_ON(item_size < sizeof(*ei));
2075	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2076	__run_delayed_extent_op(extent_op, leaf, ei);
2077
2078	btrfs_mark_buffer_dirty(leaf);
2079out:
2080	btrfs_free_path(path);
2081	return err;
2082}
2083
2084static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
2085				struct btrfs_root *root,
2086				struct btrfs_delayed_ref_node *node,
2087				struct btrfs_delayed_extent_op *extent_op,
2088				int insert_reserved)
2089{
2090	int ret = 0;
 
2091	struct btrfs_delayed_tree_ref *ref;
2092	struct btrfs_key ins;
2093	u64 parent = 0;
2094	u64 ref_root = 0;
2095
2096	ins.objectid = node->bytenr;
2097	ins.offset = node->num_bytes;
2098	ins.type = BTRFS_EXTENT_ITEM_KEY;
2099
2100	ref = btrfs_delayed_node_to_tree_ref(node);
2101	if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2102		parent = ref->parent;
2103	else
2104		ref_root = ref->root;
2105
2106	BUG_ON(node->ref_mod != 1);
 
 
 
 
 
 
2107	if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
2108		BUG_ON(!extent_op || !extent_op->update_flags ||
2109		       !extent_op->update_key);
2110		ret = alloc_reserved_tree_block(trans, root,
2111						parent, ref_root,
2112						extent_op->flags_to_set,
2113						&extent_op->key,
2114						ref->level, &ins);
 
 
 
 
 
2115	} else if (node->action == BTRFS_ADD_DELAYED_REF) {
2116		ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
2117					     node->num_bytes, parent, ref_root,
2118					     ref->level, 0, 1, extent_op);
2119	} else if (node->action == BTRFS_DROP_DELAYED_REF) {
2120		ret = __btrfs_free_extent(trans, root, node->bytenr,
2121					  node->num_bytes, parent, ref_root,
2122					  ref->level, 0, 1, extent_op);
2123	} else {
2124		BUG();
2125	}
2126	return ret;
2127}
2128
2129/* helper function to actually process a single delayed ref entry */
2130static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
2131			       struct btrfs_root *root,
2132			       struct btrfs_delayed_ref_node *node,
2133			       struct btrfs_delayed_extent_op *extent_op,
2134			       int insert_reserved)
2135{
2136	int ret = 0;
2137
2138	if (trans->aborted)
2139		return 0;
2140
2141	if (btrfs_delayed_ref_is_head(node)) {
2142		struct btrfs_delayed_ref_head *head;
2143		/*
2144		 * we've hit the end of the chain and we were supposed
2145		 * to insert this extent into the tree.  But, it got
2146		 * deleted before we ever needed to insert it, so all
2147		 * we have to do is clean up the accounting
2148		 */
2149		BUG_ON(extent_op);
2150		head = btrfs_delayed_node_to_head(node);
2151		if (insert_reserved) {
2152			btrfs_pin_extent(root, node->bytenr,
2153					 node->num_bytes, 1);
2154			if (head->is_data) {
2155				ret = btrfs_del_csums(trans, root,
2156						      node->bytenr,
2157						      node->num_bytes);
2158			}
2159		}
2160		mutex_unlock(&head->mutex);
2161		return ret;
2162	}
2163
2164	if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
2165	    node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2166		ret = run_delayed_tree_ref(trans, root, node, extent_op,
2167					   insert_reserved);
2168	else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
2169		 node->type == BTRFS_SHARED_DATA_REF_KEY)
2170		ret = run_delayed_data_ref(trans, root, node, extent_op,
2171					   insert_reserved);
 
 
2172	else
2173		BUG();
 
 
 
 
 
 
 
2174	return ret;
2175}
2176
2177static noinline struct btrfs_delayed_ref_node *
2178select_delayed_ref(struct btrfs_delayed_ref_head *head)
2179{
2180	struct rb_node *node;
2181	struct btrfs_delayed_ref_node *ref;
2182	int action = BTRFS_ADD_DELAYED_REF;
2183again:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2184	/*
2185	 * select delayed ref of type BTRFS_ADD_DELAYED_REF first.
2186	 * this prevents ref count from going down to zero when
2187	 * there still are pending delayed ref.
2188	 */
2189	node = rb_prev(&head->node.rb_node);
2190	while (1) {
2191		if (!node)
2192			break;
2193		ref = rb_entry(node, struct btrfs_delayed_ref_node,
2194				rb_node);
2195		if (ref->bytenr != head->node.bytenr)
2196			break;
2197		if (ref->action == action)
2198			return ref;
2199		node = rb_prev(node);
2200	}
2201	if (action == BTRFS_ADD_DELAYED_REF) {
2202		action = BTRFS_DROP_DELAYED_REF;
2203		goto again;
2204	}
2205	return NULL;
2206}
2207
2208/*
2209 * Returns 0 on success or if called with an already aborted transaction.
2210 * Returns -ENOMEM or -EIO on failure and will abort the transaction.
2211 */
2212static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
2213				       struct btrfs_root *root,
2214				       struct list_head *cluster)
2215{
 
 
2216	struct btrfs_delayed_ref_root *delayed_refs;
2217	struct btrfs_delayed_ref_node *ref;
2218	struct btrfs_delayed_ref_head *locked_ref = NULL;
2219	struct btrfs_delayed_extent_op *extent_op;
2220	int ret;
2221	int count = 0;
2222	int must_insert_reserved = 0;
2223
2224	delayed_refs = &trans->transaction->delayed_refs;
2225	while (1) {
2226		if (!locked_ref) {
2227			/* pick a new head ref from the cluster list */
2228			if (list_empty(cluster))
2229				break;
2230
2231			locked_ref = list_entry(cluster->next,
2232				     struct btrfs_delayed_ref_head, cluster);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2233
2234			/* grab the lock that says we are going to process
2235			 * all the refs for this head */
2236			ret = btrfs_delayed_ref_lock(trans, locked_ref);
 
2237
2238			/*
2239			 * we may have dropped the spin lock to get the head
2240			 * mutex lock, and that might have given someone else
2241			 * time to free the head.  If that's true, it has been
2242			 * removed from our list and we can move on.
2243			 */
2244			if (ret == -EAGAIN) {
2245				locked_ref = NULL;
2246				count++;
2247				continue;
2248			}
2249		}
 
 
 
2250
2251		/*
2252		 * locked_ref is the head node, so we have to go one
2253		 * node back for any delayed ref updates
2254		 */
2255		ref = select_delayed_ref(locked_ref);
2256
2257		if (ref && ref->seq &&
2258		    btrfs_check_delayed_seq(delayed_refs, ref->seq)) {
2259			/*
2260			 * there are still refs with lower seq numbers in the
2261			 * process of being added. Don't run this ref yet.
2262			 */
2263			list_del_init(&locked_ref->cluster);
2264			mutex_unlock(&locked_ref->mutex);
2265			locked_ref = NULL;
2266			delayed_refs->num_heads_ready++;
2267			spin_unlock(&delayed_refs->lock);
2268			cond_resched();
2269			spin_lock(&delayed_refs->lock);
2270			continue;
2271		}
2272
2273		/*
2274		 * record the must insert reserved flag before we
2275		 * drop the spin lock.
2276		 */
2277		must_insert_reserved = locked_ref->must_insert_reserved;
2278		locked_ref->must_insert_reserved = 0;
2279
2280		extent_op = locked_ref->extent_op;
2281		locked_ref->extent_op = NULL;
 
 
 
 
2282
2283		if (!ref) {
2284			/* All delayed refs have been processed, Go ahead
2285			 * and send the head node to run_one_delayed_ref,
2286			 * so that any accounting fixes can happen
2287			 */
2288			ref = &locked_ref->node;
 
2289
2290			if (extent_op && must_insert_reserved) {
2291				kfree(extent_op);
2292				extent_op = NULL;
2293			}
2294
2295			if (extent_op) {
2296				spin_unlock(&delayed_refs->lock);
 
 
 
 
 
 
 
 
2297
2298				ret = run_delayed_extent_op(trans, root,
2299							    ref, extent_op);
2300				kfree(extent_op);
2301
2302				if (ret) {
2303					printk(KERN_DEBUG "btrfs: run_delayed_extent_op returned %d\n", ret);
2304					spin_lock(&delayed_refs->lock);
2305					return ret;
2306				}
2307
2308				goto next;
2309			}
 
 
 
 
 
2310
2311			list_del_init(&locked_ref->cluster);
2312			locked_ref = NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2313		}
 
2314
2315		ref->in_tree = 0;
2316		rb_erase(&ref->rb_node, &delayed_refs->root);
2317		delayed_refs->num_entries--;
2318		/*
2319		 * we modified num_entries, but as we're currently running
2320		 * delayed refs, skip
2321		 *     wake_up(&delayed_refs->seq_wait);
2322		 * here.
2323		 */
2324		spin_unlock(&delayed_refs->lock);
 
 
 
 
 
 
 
 
 
 
 
2325
2326		ret = run_one_delayed_ref(trans, root, ref, extent_op,
2327					  must_insert_reserved);
 
 
2328
2329		btrfs_put_delayed_ref(ref);
2330		kfree(extent_op);
2331		count++;
2332
2333		if (ret) {
2334			printk(KERN_DEBUG "btrfs: run_one_delayed_ref returned %d\n", ret);
2335			spin_lock(&delayed_refs->lock);
2336			return ret;
2337		}
2338
2339next:
2340		do_chunk_alloc(trans, root->fs_info->extent_root,
2341			       2 * 1024 * 1024,
2342			       btrfs_get_alloc_profile(root, 0),
2343			       CHUNK_ALLOC_NO_FORCE);
2344		cond_resched();
2345		spin_lock(&delayed_refs->lock);
 
 
2346	}
2347	return count;
2348}
2349
2350static void wait_for_more_refs(struct btrfs_delayed_ref_root *delayed_refs,
2351			       unsigned long num_refs,
2352			       struct list_head *first_seq)
2353{
2354	spin_unlock(&delayed_refs->lock);
2355	pr_debug("waiting for more refs (num %ld, first %p)\n",
2356		 num_refs, first_seq);
2357	wait_event(delayed_refs->seq_wait,
2358		   num_refs != delayed_refs->num_entries ||
2359		   delayed_refs->seq_head.next != first_seq);
2360	pr_debug("done waiting for more refs (num %ld, first %p)\n",
2361		 delayed_refs->num_entries, delayed_refs->seq_head.next);
2362	spin_lock(&delayed_refs->lock);
2363}
2364
2365/*
2366 * this starts processing the delayed reference count updates and
2367 * extent insertions we have queued up so far.  count can be
2368 * 0, which means to process everything in the tree at the start
2369 * of the run (but not newly added entries), or it can be some target
2370 * number you'd like to process.
2371 *
2372 * Returns 0 on success or if called with an aborted transaction
2373 * Returns <0 on error and aborts the transaction
2374 */
2375int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2376			   struct btrfs_root *root, unsigned long count)
2377{
2378	struct rb_node *node;
2379	struct btrfs_delayed_ref_root *delayed_refs;
2380	struct btrfs_delayed_ref_node *ref;
2381	struct list_head cluster;
2382	struct list_head *first_seq = NULL;
2383	int ret;
2384	u64 delayed_start;
2385	int run_all = count == (unsigned long)-1;
2386	int run_most = 0;
2387	unsigned long num_refs = 0;
2388	int consider_waiting;
2389
2390	/* We'll clean this up in btrfs_cleanup_transaction */
2391	if (trans->aborted)
2392		return 0;
2393
2394	if (root == root->fs_info->extent_root)
2395		root = root->fs_info->tree_root;
2396
2397	do_chunk_alloc(trans, root->fs_info->extent_root,
2398		       2 * 1024 * 1024, btrfs_get_alloc_profile(root, 0),
2399		       CHUNK_ALLOC_NO_FORCE);
2400
2401	delayed_refs = &trans->transaction->delayed_refs;
2402	INIT_LIST_HEAD(&cluster);
2403again:
2404	consider_waiting = 0;
2405	spin_lock(&delayed_refs->lock);
2406	if (count == 0) {
2407		count = delayed_refs->num_entries * 2;
2408		run_most = 1;
2409	}
2410	while (1) {
2411		if (!(run_all || run_most) &&
2412		    delayed_refs->num_heads_ready < 64)
2413			break;
2414
 
 
 
 
 
 
 
 
 
 
 
 
2415		/*
2416		 * go find something we can process in the rbtree.  We start at
2417		 * the beginning of the tree, and then build a cluster
2418		 * of refs to process starting at the first one we are able to
2419		 * lock
 
 
 
 
 
 
2420		 */
2421		delayed_start = delayed_refs->run_delayed_start;
2422		ret = btrfs_find_ref_cluster(trans, &cluster,
2423					     delayed_refs->run_delayed_start);
2424		if (ret)
2425			break;
2426
2427		if (delayed_start >= delayed_refs->run_delayed_start) {
2428			if (consider_waiting == 0) {
2429				/*
2430				 * btrfs_find_ref_cluster looped. let's do one
2431				 * more cycle. if we don't run any delayed ref
2432				 * during that cycle (because we can't because
2433				 * all of them are blocked) and if the number of
2434				 * refs doesn't change, we avoid busy waiting.
2435				 */
2436				consider_waiting = 1;
2437				num_refs = delayed_refs->num_entries;
2438				first_seq = root->fs_info->tree_mod_seq_list.next;
2439			} else {
2440				wait_for_more_refs(delayed_refs,
2441						   num_refs, first_seq);
2442				/*
2443				 * after waiting, things have changed. we
2444				 * dropped the lock and someone else might have
2445				 * run some refs, built new clusters and so on.
2446				 * therefore, we restart staleness detection.
2447				 */
2448				consider_waiting = 0;
2449			}
2450		}
2451
2452		ret = run_clustered_refs(trans, root, &cluster);
2453		if (ret < 0) {
2454			spin_unlock(&delayed_refs->lock);
2455			btrfs_abort_transaction(trans, root, ret);
2456			return ret;
2457		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2458
2459		count -= min_t(unsigned long, ret, count);
2460
2461		if (count == 0)
2462			break;
 
 
2463
2464		if (ret || delayed_refs->run_delayed_start == 0) {
2465			/* refs were run, let's reset staleness detection */
2466			consider_waiting = 0;
2467		}
2468	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2469
2470	if (run_all) {
2471		node = rb_first(&delayed_refs->root);
2472		if (!node)
2473			goto out;
2474		count = (unsigned long)-1;
2475
2476		while (node) {
2477			ref = rb_entry(node, struct btrfs_delayed_ref_node,
2478				       rb_node);
2479			if (btrfs_delayed_ref_is_head(ref)) {
2480				struct btrfs_delayed_ref_head *head;
2481
2482				head = btrfs_delayed_node_to_head(ref);
2483				atomic_inc(&ref->refs);
 
 
 
 
 
 
 
 
2484
2485				spin_unlock(&delayed_refs->lock);
2486				/*
2487				 * Mutex was contended, block until it's
2488				 * released and try again
2489				 */
2490				mutex_lock(&head->mutex);
2491				mutex_unlock(&head->mutex);
2492
2493				btrfs_put_delayed_ref(ref);
2494				cond_resched();
2495				goto again;
2496			}
2497			node = rb_next(node);
2498		}
2499		spin_unlock(&delayed_refs->lock);
2500		schedule_timeout(1);
 
2501		goto again;
2502	}
2503out:
2504	spin_unlock(&delayed_refs->lock);
2505	return 0;
2506}
2507
2508int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2509				struct btrfs_root *root,
2510				u64 bytenr, u64 num_bytes, u64 flags,
2511				int is_data)
2512{
2513	struct btrfs_delayed_extent_op *extent_op;
 
2514	int ret;
2515
2516	extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
2517	if (!extent_op)
2518		return -ENOMEM;
2519
2520	extent_op->flags_to_set = flags;
2521	extent_op->update_flags = 1;
2522	extent_op->update_key = 0;
2523	extent_op->is_data = is_data ? 1 : 0;
2524
2525	ret = btrfs_add_delayed_extent_op(root->fs_info, trans, bytenr,
2526					  num_bytes, extent_op);
2527	if (ret)
2528		kfree(extent_op);
2529	return ret;
2530}
2531
2532static noinline int check_delayed_ref(struct btrfs_trans_handle *trans,
2533				      struct btrfs_root *root,
2534				      struct btrfs_path *path,
2535				      u64 objectid, u64 offset, u64 bytenr)
2536{
2537	struct btrfs_delayed_ref_head *head;
2538	struct btrfs_delayed_ref_node *ref;
2539	struct btrfs_delayed_data_ref *data_ref;
2540	struct btrfs_delayed_ref_root *delayed_refs;
 
2541	struct rb_node *node;
2542	int ret = 0;
2543
2544	ret = -ENOENT;
2545	delayed_refs = &trans->transaction->delayed_refs;
 
 
 
 
 
 
 
2546	spin_lock(&delayed_refs->lock);
2547	head = btrfs_find_delayed_ref_head(trans, bytenr);
2548	if (!head)
2549		goto out;
 
 
 
2550
2551	if (!mutex_trylock(&head->mutex)) {
2552		atomic_inc(&head->node.refs);
 
 
 
 
 
 
2553		spin_unlock(&delayed_refs->lock);
2554
2555		btrfs_release_path(path);
2556
2557		/*
2558		 * Mutex was contended, block until it's released and let
2559		 * caller try again
2560		 */
2561		mutex_lock(&head->mutex);
2562		mutex_unlock(&head->mutex);
2563		btrfs_put_delayed_ref(&head->node);
 
2564		return -EAGAIN;
2565	}
 
2566
2567	node = rb_prev(&head->node.rb_node);
2568	if (!node)
2569		goto out_unlock;
 
 
 
 
 
 
 
 
 
 
2570
2571	ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2572
2573	if (ref->bytenr != bytenr)
2574		goto out_unlock;
2575
2576	ret = 1;
2577	if (ref->type != BTRFS_EXTENT_DATA_REF_KEY)
2578		goto out_unlock;
2579
2580	data_ref = btrfs_delayed_node_to_data_ref(ref);
2581
2582	node = rb_prev(node);
2583	if (node) {
2584		ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2585		if (ref->bytenr == bytenr)
2586			goto out_unlock;
2587	}
2588
2589	if (data_ref->root != root->root_key.objectid ||
2590	    data_ref->objectid != objectid || data_ref->offset != offset)
2591		goto out_unlock;
2592
2593	ret = 0;
2594out_unlock:
2595	mutex_unlock(&head->mutex);
2596out:
2597	spin_unlock(&delayed_refs->lock);
2598	return ret;
2599}
2600
2601static noinline int check_committed_ref(struct btrfs_trans_handle *trans,
2602					struct btrfs_root *root,
2603					struct btrfs_path *path,
2604					u64 objectid, u64 offset, u64 bytenr)
 
2605{
2606	struct btrfs_root *extent_root = root->fs_info->extent_root;
 
2607	struct extent_buffer *leaf;
2608	struct btrfs_extent_data_ref *ref;
2609	struct btrfs_extent_inline_ref *iref;
2610	struct btrfs_extent_item *ei;
2611	struct btrfs_key key;
2612	u32 item_size;
 
 
2613	int ret;
2614
2615	key.objectid = bytenr;
2616	key.offset = (u64)-1;
2617	key.type = BTRFS_EXTENT_ITEM_KEY;
2618
2619	ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2620	if (ret < 0)
2621		goto out;
2622	BUG_ON(ret == 0); /* Corruption */
2623
2624	ret = -ENOENT;
2625	if (path->slots[0] == 0)
2626		goto out;
2627
2628	path->slots[0]--;
2629	leaf = path->nodes[0];
2630	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2631
2632	if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
2633		goto out;
2634
2635	ret = 1;
2636	item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2637#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2638	if (item_size < sizeof(*ei)) {
2639		WARN_ON(item_size != sizeof(struct btrfs_extent_item_v0));
 
 
2640		goto out;
 
 
 
 
 
 
 
2641	}
2642#endif
2643	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2644
2645	if (item_size != sizeof(*ei) +
2646	    btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY))
2647		goto out;
2648
2649	if (btrfs_extent_generation(leaf, ei) <=
2650	    btrfs_root_last_snapshot(&root->root_item))
 
 
 
 
 
2651		goto out;
2652
2653	iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2654	if (btrfs_extent_inline_ref_type(leaf, iref) !=
2655	    BTRFS_EXTENT_DATA_REF_KEY)
2656		goto out;
2657
2658	ref = (struct btrfs_extent_data_ref *)(&iref->offset);
2659	if (btrfs_extent_refs(leaf, ei) !=
2660	    btrfs_extent_data_ref_count(leaf, ref) ||
2661	    btrfs_extent_data_ref_root(leaf, ref) !=
2662	    root->root_key.objectid ||
2663	    btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
2664	    btrfs_extent_data_ref_offset(leaf, ref) != offset)
2665		goto out;
2666
2667	ret = 0;
2668out:
2669	return ret;
2670}
2671
2672int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
2673			  struct btrfs_root *root,
2674			  u64 objectid, u64 offset, u64 bytenr)
2675{
2676	struct btrfs_path *path;
2677	int ret;
2678	int ret2;
2679
2680	path = btrfs_alloc_path();
2681	if (!path)
2682		return -ENOENT;
2683
2684	do {
2685		ret = check_committed_ref(trans, root, path, objectid,
2686					  offset, bytenr);
2687		if (ret && ret != -ENOENT)
2688			goto out;
2689
2690		ret2 = check_delayed_ref(trans, root, path, objectid,
2691					 offset, bytenr);
2692	} while (ret2 == -EAGAIN);
2693
2694	if (ret2 && ret2 != -ENOENT) {
2695		ret = ret2;
2696		goto out;
2697	}
2698
2699	if (ret != -ENOENT || ret2 != -ENOENT)
2700		ret = 0;
2701out:
2702	btrfs_free_path(path);
2703	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
2704		WARN_ON(ret > 0);
2705	return ret;
2706}
2707
2708static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
2709			   struct btrfs_root *root,
2710			   struct extent_buffer *buf,
2711			   int full_backref, int inc, int for_cow)
2712{
 
2713	u64 bytenr;
2714	u64 num_bytes;
2715	u64 parent;
2716	u64 ref_root;
2717	u32 nritems;
2718	struct btrfs_key key;
2719	struct btrfs_file_extent_item *fi;
 
 
2720	int i;
 
2721	int level;
2722	int ret = 0;
2723	int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
2724			    u64, u64, u64, u64, u64, u64, int);
 
2725
2726	ref_root = btrfs_header_owner(buf);
2727	nritems = btrfs_header_nritems(buf);
2728	level = btrfs_header_level(buf);
2729
2730	if (!root->ref_cows && level == 0)
2731		return 0;
2732
2733	if (inc)
2734		process_func = btrfs_inc_extent_ref;
2735	else
2736		process_func = btrfs_free_extent;
2737
2738	if (full_backref)
2739		parent = buf->start;
2740	else
2741		parent = 0;
 
 
 
 
2742
2743	for (i = 0; i < nritems; i++) {
2744		if (level == 0) {
2745			btrfs_item_key_to_cpu(buf, &key, i);
2746			if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2747				continue;
2748			fi = btrfs_item_ptr(buf, i,
2749					    struct btrfs_file_extent_item);
2750			if (btrfs_file_extent_type(buf, fi) ==
2751			    BTRFS_FILE_EXTENT_INLINE)
2752				continue;
2753			bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2754			if (bytenr == 0)
2755				continue;
2756
2757			num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
2758			key.offset -= btrfs_file_extent_offset(buf, fi);
2759			ret = process_func(trans, root, bytenr, num_bytes,
2760					   parent, ref_root, key.objectid,
2761					   key.offset, for_cow);
 
 
 
 
 
 
2762			if (ret)
2763				goto fail;
2764		} else {
2765			bytenr = btrfs_node_blockptr(buf, i);
2766			num_bytes = btrfs_level_size(root, level - 1);
2767			ret = process_func(trans, root, bytenr, num_bytes,
2768					   parent, ref_root, level - 1, 0,
2769					   for_cow);
 
 
 
 
 
 
2770			if (ret)
2771				goto fail;
2772		}
2773	}
2774	return 0;
2775fail:
2776	return ret;
2777}
2778
2779int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2780		  struct extent_buffer *buf, int full_backref, int for_cow)
2781{
2782	return __btrfs_mod_ref(trans, root, buf, full_backref, 1, for_cow);
2783}
2784
2785int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2786		  struct extent_buffer *buf, int full_backref, int for_cow)
2787{
2788	return __btrfs_mod_ref(trans, root, buf, full_backref, 0, for_cow);
2789}
2790
2791static int write_one_cache_group(struct btrfs_trans_handle *trans,
2792				 struct btrfs_root *root,
2793				 struct btrfs_path *path,
2794				 struct btrfs_block_group_cache *cache)
2795{
2796	int ret;
2797	struct btrfs_root *extent_root = root->fs_info->extent_root;
2798	unsigned long bi;
2799	struct extent_buffer *leaf;
2800
2801	ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
2802	if (ret < 0)
2803		goto fail;
2804	BUG_ON(ret); /* Corruption */
2805
2806	leaf = path->nodes[0];
2807	bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
2808	write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
2809	btrfs_mark_buffer_dirty(leaf);
2810	btrfs_release_path(path);
2811fail:
2812	if (ret) {
2813		btrfs_abort_transaction(trans, root, ret);
2814		return ret;
2815	}
2816	return 0;
2817
 
 
2818}
2819
2820static struct btrfs_block_group_cache *
2821next_block_group(struct btrfs_root *root,
2822		 struct btrfs_block_group_cache *cache)
2823{
2824	struct rb_node *node;
2825	spin_lock(&root->fs_info->block_group_cache_lock);
2826	node = rb_next(&cache->cache_node);
2827	btrfs_put_block_group(cache);
2828	if (node) {
2829		cache = rb_entry(node, struct btrfs_block_group_cache,
2830				 cache_node);
2831		btrfs_get_block_group(cache);
2832	} else
2833		cache = NULL;
2834	spin_unlock(&root->fs_info->block_group_cache_lock);
2835	return cache;
2836}
2837
2838static int cache_save_setup(struct btrfs_block_group_cache *block_group,
2839			    struct btrfs_trans_handle *trans,
2840			    struct btrfs_path *path)
2841{
2842	struct btrfs_root *root = block_group->fs_info->tree_root;
2843	struct inode *inode = NULL;
2844	u64 alloc_hint = 0;
2845	int dcs = BTRFS_DC_ERROR;
2846	int num_pages = 0;
2847	int retries = 0;
2848	int ret = 0;
2849
2850	/*
2851	 * If this block group is smaller than 100 megs don't bother caching the
2852	 * block group.
2853	 */
2854	if (block_group->key.offset < (100 * 1024 * 1024)) {
2855		spin_lock(&block_group->lock);
2856		block_group->disk_cache_state = BTRFS_DC_WRITTEN;
2857		spin_unlock(&block_group->lock);
2858		return 0;
2859	}
 
 
 
 
 
 
 
 
 
 
2860
2861again:
2862	inode = lookup_free_space_inode(root, block_group, path);
2863	if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) {
2864		ret = PTR_ERR(inode);
2865		btrfs_release_path(path);
2866		goto out;
 
 
2867	}
 
 
2868
2869	if (IS_ERR(inode)) {
2870		BUG_ON(retries);
2871		retries++;
 
2872
2873		if (block_group->ro)
2874			goto out_free;
 
 
2875
2876		ret = create_free_space_inode(root, trans, block_group, path);
2877		if (ret)
2878			goto out_free;
2879		goto again;
2880	}
2881
2882	/* We've already setup this transaction, go ahead and exit */
2883	if (block_group->cache_generation == trans->transid &&
2884	    i_size_read(inode)) {
2885		dcs = BTRFS_DC_SETUP;
2886		goto out_put;
2887	}
2888
2889	/*
2890	 * We want to set the generation to 0, that way if anything goes wrong
2891	 * from here on out we know not to trust this cache when we load up next
2892	 * time.
2893	 */
2894	BTRFS_I(inode)->generation = 0;
2895	ret = btrfs_update_inode(trans, root, inode);
2896	WARN_ON(ret);
2897
2898	if (i_size_read(inode) > 0) {
2899		ret = btrfs_truncate_free_space_cache(root, trans, path,
2900						      inode);
2901		if (ret)
2902			goto out_put;
2903	}
2904
2905	spin_lock(&block_group->lock);
2906	if (block_group->cached != BTRFS_CACHE_FINISHED) {
2907		/* We're not cached, don't bother trying to write stuff out */
2908		dcs = BTRFS_DC_WRITTEN;
2909		spin_unlock(&block_group->lock);
2910		goto out_put;
2911	}
2912	spin_unlock(&block_group->lock);
2913
2914	num_pages = (int)div64_u64(block_group->key.offset, 1024 * 1024 * 1024);
2915	if (!num_pages)
2916		num_pages = 1;
2917
2918	/*
2919	 * Just to make absolutely sure we have enough space, we're going to
2920	 * preallocate 12 pages worth of space for each block group.  In
2921	 * practice we ought to use at most 8, but we need extra space so we can
2922	 * add our header and have a terminator between the extents and the
2923	 * bitmaps.
2924	 */
2925	num_pages *= 16;
2926	num_pages *= PAGE_CACHE_SIZE;
2927
2928	ret = btrfs_check_data_free_space(inode, num_pages);
2929	if (ret)
2930		goto out_put;
2931
2932	ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, num_pages,
2933					      num_pages, num_pages,
2934					      &alloc_hint);
2935	if (!ret)
2936		dcs = BTRFS_DC_SETUP;
2937	btrfs_free_reserved_data_space(inode, num_pages);
2938
2939out_put:
2940	iput(inode);
2941out_free:
2942	btrfs_release_path(path);
2943out:
2944	spin_lock(&block_group->lock);
2945	if (!ret && dcs == BTRFS_DC_SETUP)
2946		block_group->cache_generation = trans->transid;
2947	block_group->disk_cache_state = dcs;
2948	spin_unlock(&block_group->lock);
2949
2950	return ret;
2951}
2952
2953int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2954				   struct btrfs_root *root)
2955{
2956	struct btrfs_block_group_cache *cache;
2957	int err = 0;
2958	struct btrfs_path *path;
2959	u64 last = 0;
2960
2961	path = btrfs_alloc_path();
2962	if (!path)
2963		return -ENOMEM;
2964
2965again:
2966	while (1) {
2967		cache = btrfs_lookup_first_block_group(root->fs_info, last);
2968		while (cache) {
2969			if (cache->disk_cache_state == BTRFS_DC_CLEAR)
2970				break;
2971			cache = next_block_group(root, cache);
2972		}
2973		if (!cache) {
2974			if (last == 0)
2975				break;
2976			last = 0;
2977			continue;
2978		}
2979		err = cache_save_setup(cache, trans, path);
2980		last = cache->key.objectid + cache->key.offset;
2981		btrfs_put_block_group(cache);
2982	}
2983
2984	while (1) {
2985		if (last == 0) {
2986			err = btrfs_run_delayed_refs(trans, root,
2987						     (unsigned long)-1);
2988			if (err) /* File system offline */
2989				goto out;
2990		}
2991
2992		cache = btrfs_lookup_first_block_group(root->fs_info, last);
2993		while (cache) {
2994			if (cache->disk_cache_state == BTRFS_DC_CLEAR) {
2995				btrfs_put_block_group(cache);
2996				goto again;
2997			}
2998
2999			if (cache->dirty)
3000				break;
3001			cache = next_block_group(root, cache);
3002		}
3003		if (!cache) {
3004			if (last == 0)
3005				break;
3006			last = 0;
3007			continue;
3008		}
3009
3010		if (cache->disk_cache_state == BTRFS_DC_SETUP)
3011			cache->disk_cache_state = BTRFS_DC_NEED_WRITE;
3012		cache->dirty = 0;
3013		last = cache->key.objectid + cache->key.offset;
3014
3015		err = write_one_cache_group(trans, root, path, cache);
3016		if (err) /* File system offline */
3017			goto out;
3018
3019		btrfs_put_block_group(cache);
3020	}
3021
3022	while (1) {
3023		/*
3024		 * I don't think this is needed since we're just marking our
3025		 * preallocated extent as written, but just in case it can't
3026		 * hurt.
3027		 */
3028		if (last == 0) {
3029			err = btrfs_run_delayed_refs(trans, root,
3030						     (unsigned long)-1);
3031			if (err) /* File system offline */
3032				goto out;
3033		}
3034
3035		cache = btrfs_lookup_first_block_group(root->fs_info, last);
3036		while (cache) {
3037			/*
3038			 * Really this shouldn't happen, but it could if we
3039			 * couldn't write the entire preallocated extent and
3040			 * splitting the extent resulted in a new block.
3041			 */
3042			if (cache->dirty) {
3043				btrfs_put_block_group(cache);
3044				goto again;
3045			}
3046			if (cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
3047				break;
3048			cache = next_block_group(root, cache);
3049		}
3050		if (!cache) {
3051			if (last == 0)
3052				break;
3053			last = 0;
3054			continue;
3055		}
3056
3057		err = btrfs_write_out_cache(root, trans, cache, path);
3058
3059		/*
3060		 * If we didn't have an error then the cache state is still
3061		 * NEED_WRITE, so we can set it to WRITTEN.
3062		 */
3063		if (!err && cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
3064			cache->disk_cache_state = BTRFS_DC_WRITTEN;
3065		last = cache->key.objectid + cache->key.offset;
3066		btrfs_put_block_group(cache);
3067	}
3068out:
3069
3070	btrfs_free_path(path);
3071	return err;
3072}
3073
3074int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
3075{
3076	struct btrfs_block_group_cache *block_group;
3077	int readonly = 0;
3078
3079	block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
3080	if (!block_group || block_group->ro)
3081		readonly = 1;
3082	if (block_group)
3083		btrfs_put_block_group(block_group);
3084	return readonly;
3085}
3086
3087static int update_space_info(struct btrfs_fs_info *info, u64 flags,
3088			     u64 total_bytes, u64 bytes_used,
3089			     struct btrfs_space_info **space_info)
3090{
3091	struct btrfs_space_info *found;
3092	int i;
3093	int factor;
3094
3095	if (flags & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
3096		     BTRFS_BLOCK_GROUP_RAID10))
3097		factor = 2;
3098	else
3099		factor = 1;
3100
3101	found = __find_space_info(info, flags);
3102	if (found) {
3103		spin_lock(&found->lock);
3104		found->total_bytes += total_bytes;
3105		found->disk_total += total_bytes * factor;
3106		found->bytes_used += bytes_used;
3107		found->disk_used += bytes_used * factor;
3108		found->full = 0;
3109		spin_unlock(&found->lock);
3110		*space_info = found;
3111		return 0;
 
 
 
 
3112	}
3113	found = kzalloc(sizeof(*found), GFP_NOFS);
3114	if (!found)
3115		return -ENOMEM;
3116
3117	for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
3118		INIT_LIST_HEAD(&found->block_groups[i]);
3119	init_rwsem(&found->groups_sem);
3120	spin_lock_init(&found->lock);
3121	found->flags = flags & BTRFS_BLOCK_GROUP_TYPE_MASK;
3122	found->total_bytes = total_bytes;
3123	found->disk_total = total_bytes * factor;
3124	found->bytes_used = bytes_used;
3125	found->disk_used = bytes_used * factor;
3126	found->bytes_pinned = 0;
3127	found->bytes_reserved = 0;
3128	found->bytes_readonly = 0;
3129	found->bytes_may_use = 0;
3130	found->full = 0;
3131	found->force_alloc = CHUNK_ALLOC_NO_FORCE;
3132	found->chunk_alloc = 0;
3133	found->flush = 0;
3134	init_waitqueue_head(&found->wait);
3135	*space_info = found;
3136	list_add_rcu(&found->list, &info->space_info);
3137	return 0;
3138}
3139
3140static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
 
3141{
3142	u64 extra_flags = chunk_to_extended(flags) &
3143				BTRFS_EXTENDED_PROFILE_MASK;
3144
3145	if (flags & BTRFS_BLOCK_GROUP_DATA)
3146		fs_info->avail_data_alloc_bits |= extra_flags;
3147	if (flags & BTRFS_BLOCK_GROUP_METADATA)
3148		fs_info->avail_metadata_alloc_bits |= extra_flags;
3149	if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3150		fs_info->avail_system_alloc_bits |= extra_flags;
3151}
3152
3153/*
3154 * returns target flags in extended format or 0 if restripe for this
3155 * chunk_type is not in progress
3156 *
3157 * should be called with either volume_mutex or balance_lock held
3158 */
3159static u64 get_restripe_target(struct btrfs_fs_info *fs_info, u64 flags)
 
 
3160{
3161	struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3162	u64 target = 0;
3163
3164	if (!bctl)
3165		return 0;
 
3166
3167	if (flags & BTRFS_BLOCK_GROUP_DATA &&
3168	    bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3169		target = BTRFS_BLOCK_GROUP_DATA | bctl->data.target;
3170	} else if (flags & BTRFS_BLOCK_GROUP_SYSTEM &&
3171		   bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3172		target = BTRFS_BLOCK_GROUP_SYSTEM | bctl->sys.target;
3173	} else if (flags & BTRFS_BLOCK_GROUP_METADATA &&
3174		   bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3175		target = BTRFS_BLOCK_GROUP_METADATA | bctl->meta.target;
 
3176	}
3177
3178	return target;
3179}
3180
3181/*
3182 * @flags: available profiles in extended format (see ctree.h)
3183 *
3184 * Returns reduced profile in chunk format.  If profile changing is in
3185 * progress (either running or paused) picks the target profile (if it's
3186 * already available), otherwise falls back to plain reducing.
3187 */
3188u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
3189{
3190	/*
3191	 * we add in the count of missing devices because we want
3192	 * to make sure that any RAID levels on a degraded FS
3193	 * continue to be honored.
3194	 */
3195	u64 num_devices = root->fs_info->fs_devices->rw_devices +
3196		root->fs_info->fs_devices->missing_devices;
3197	u64 target;
 
 
 
 
 
 
 
 
 
 
3198
3199	/*
3200	 * see if restripe for this chunk_type is in progress, if so
3201	 * try to reduce to the target profile
3202	 */
3203	spin_lock(&root->fs_info->balance_lock);
3204	target = get_restripe_target(root->fs_info, flags);
3205	if (target) {
3206		/* pick target profile only if it's already available */
3207		if ((flags & target) & BTRFS_EXTENDED_PROFILE_MASK) {
3208			spin_unlock(&root->fs_info->balance_lock);
3209			return extended_to_chunk(target);
3210		}
3211	}
3212	spin_unlock(&root->fs_info->balance_lock);
3213
3214	if (num_devices == 1)
3215		flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0);
3216	if (num_devices < 4)
3217		flags &= ~BTRFS_BLOCK_GROUP_RAID10;
3218
3219	if ((flags & BTRFS_BLOCK_GROUP_DUP) &&
3220	    (flags & (BTRFS_BLOCK_GROUP_RAID1 |
3221		      BTRFS_BLOCK_GROUP_RAID10))) {
3222		flags &= ~BTRFS_BLOCK_GROUP_DUP;
3223	}
3224
3225	if ((flags & BTRFS_BLOCK_GROUP_RAID1) &&
3226	    (flags & BTRFS_BLOCK_GROUP_RAID10)) {
3227		flags &= ~BTRFS_BLOCK_GROUP_RAID1;
3228	}
3229
3230	if ((flags & BTRFS_BLOCK_GROUP_RAID0) &&
3231	    ((flags & BTRFS_BLOCK_GROUP_RAID1) |
3232	     (flags & BTRFS_BLOCK_GROUP_RAID10) |
3233	     (flags & BTRFS_BLOCK_GROUP_DUP))) {
3234		flags &= ~BTRFS_BLOCK_GROUP_RAID0;
3235	}
3236
3237	return extended_to_chunk(flags);
3238}
3239
3240static u64 get_alloc_profile(struct btrfs_root *root, u64 flags)
3241{
3242	if (flags & BTRFS_BLOCK_GROUP_DATA)
3243		flags |= root->fs_info->avail_data_alloc_bits;
3244	else if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3245		flags |= root->fs_info->avail_system_alloc_bits;
3246	else if (flags & BTRFS_BLOCK_GROUP_METADATA)
3247		flags |= root->fs_info->avail_metadata_alloc_bits;
3248
3249	return btrfs_reduce_alloc_profile(root, flags);
3250}
3251
3252u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data)
3253{
3254	u64 flags;
3255
3256	if (data)
3257		flags = BTRFS_BLOCK_GROUP_DATA;
3258	else if (root == root->fs_info->chunk_root)
3259		flags = BTRFS_BLOCK_GROUP_SYSTEM;
3260	else
3261		flags = BTRFS_BLOCK_GROUP_METADATA;
3262
3263	return get_alloc_profile(root, flags);
3264}
3265
3266void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *inode)
3267{
3268	BTRFS_I(inode)->space_info = __find_space_info(root->fs_info,
3269						       BTRFS_BLOCK_GROUP_DATA);
3270}
3271
3272/*
3273 * This will check the space that the inode allocates from to make sure we have
3274 * enough space for bytes.
3275 */
3276int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
3277{
3278	struct btrfs_space_info *data_sinfo;
3279	struct btrfs_root *root = BTRFS_I(inode)->root;
3280	u64 used;
3281	int ret = 0, committed = 0, alloc_chunk = 1;
3282
3283	/* make sure bytes are sectorsize aligned */
3284	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
3285
3286	if (root == root->fs_info->tree_root ||
3287	    BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID) {
3288		alloc_chunk = 0;
3289		committed = 1;
3290	}
3291
3292	data_sinfo = BTRFS_I(inode)->space_info;
3293	if (!data_sinfo)
3294		goto alloc;
3295
3296again:
3297	/* make sure we have enough space to handle the data first */
3298	spin_lock(&data_sinfo->lock);
3299	used = data_sinfo->bytes_used + data_sinfo->bytes_reserved +
3300		data_sinfo->bytes_pinned + data_sinfo->bytes_readonly +
3301		data_sinfo->bytes_may_use;
3302
3303	if (used + bytes > data_sinfo->total_bytes) {
3304		struct btrfs_trans_handle *trans;
3305
3306		/*
3307		 * if we don't have enough free bytes in this space then we need
3308		 * to alloc a new chunk.
 
 
3309		 */
3310		if (!data_sinfo->full && alloc_chunk) {
3311			u64 alloc_target;
3312
3313			data_sinfo->force_alloc = CHUNK_ALLOC_FORCE;
3314			spin_unlock(&data_sinfo->lock);
3315alloc:
3316			alloc_target = btrfs_get_alloc_profile(root, 1);
3317			trans = btrfs_join_transaction(root);
3318			if (IS_ERR(trans))
3319				return PTR_ERR(trans);
3320
3321			ret = do_chunk_alloc(trans, root->fs_info->extent_root,
3322					     bytes + 2 * 1024 * 1024,
3323					     alloc_target,
3324					     CHUNK_ALLOC_NO_FORCE);
3325			btrfs_end_transaction(trans, root);
3326			if (ret < 0) {
3327				if (ret != -ENOSPC)
3328					return ret;
3329				else
3330					goto commit_trans;
3331			}
3332
3333			if (!data_sinfo) {
3334				btrfs_set_inode_space_info(root, inode);
3335				data_sinfo = BTRFS_I(inode)->space_info;
3336			}
3337			goto again;
3338		}
3339
3340		/*
3341		 * If we have less pinned bytes than we want to allocate then
3342		 * don't bother committing the transaction, it won't help us.
3343		 */
3344		if (data_sinfo->bytes_pinned < bytes)
3345			committed = 1;
3346		spin_unlock(&data_sinfo->lock);
3347
3348		/* commit the current transaction and try again */
3349commit_trans:
3350		if (!committed &&
3351		    !atomic_read(&root->fs_info->open_ioctl_trans)) {
3352			committed = 1;
3353			trans = btrfs_join_transaction(root);
3354			if (IS_ERR(trans))
3355				return PTR_ERR(trans);
3356			ret = btrfs_commit_transaction(trans, root);
3357			if (ret)
3358				return ret;
3359			goto again;
3360		}
3361
3362		return -ENOSPC;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3363	}
3364	data_sinfo->bytes_may_use += bytes;
3365	trace_btrfs_space_reservation(root->fs_info, "space_info",
3366				      data_sinfo->flags, bytes, 1);
3367	spin_unlock(&data_sinfo->lock);
3368
 
 
3369	return 0;
3370}
3371
3372/*
3373 * Called if we need to clear a data reservation for this inode.
3374 */
3375void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)
3376{
3377	struct btrfs_root *root = BTRFS_I(inode)->root;
3378	struct btrfs_space_info *data_sinfo;
 
 
 
 
 
3379
3380	/* make sure bytes are sectorsize aligned */
3381	bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
3382
3383	data_sinfo = BTRFS_I(inode)->space_info;
3384	spin_lock(&data_sinfo->lock);
3385	data_sinfo->bytes_may_use -= bytes;
3386	trace_btrfs_space_reservation(root->fs_info, "space_info",
3387				      data_sinfo->flags, bytes, 0);
3388	spin_unlock(&data_sinfo->lock);
3389}
 
 
3390
3391static void force_metadata_allocation(struct btrfs_fs_info *info)
3392{
3393	struct list_head *head = &info->space_info;
3394	struct btrfs_space_info *found;
3395
3396	rcu_read_lock();
3397	list_for_each_entry_rcu(found, head, list) {
3398		if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
3399			found->force_alloc = CHUNK_ALLOC_FORCE;
 
3400	}
3401	rcu_read_unlock();
3402}
3403
3404static int should_alloc_chunk(struct btrfs_root *root,
3405			      struct btrfs_space_info *sinfo, u64 alloc_bytes,
3406			      int force)
3407{
3408	struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
3409	u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
3410	u64 num_allocated = sinfo->bytes_used + sinfo->bytes_reserved;
3411	u64 thresh;
3412
3413	if (force == CHUNK_ALLOC_FORCE)
3414		return 1;
3415
3416	/*
3417	 * We need to take into account the global rsv because for all intents
3418	 * and purposes it's used space.  Don't worry about locking the
3419	 * global_rsv, it doesn't change except when the transaction commits.
3420	 */
3421	num_allocated += global_rsv->size;
 
 
 
 
 
 
 
 
 
3422
3423	/*
3424	 * in limited mode, we want to have some free space up to
3425	 * about 1% of the FS size.
3426	 */
3427	if (force == CHUNK_ALLOC_LIMITED) {
3428		thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
3429		thresh = max_t(u64, 64 * 1024 * 1024,
3430			       div_factor_fine(thresh, 1));
3431
3432		if (num_bytes - num_allocated < thresh)
3433			return 1;
 
 
 
 
3434	}
3435	thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
3436
3437	/* 256MB or 2% of the FS */
3438	thresh = max_t(u64, 256 * 1024 * 1024, div_factor_fine(thresh, 2));
3439	/* system chunks need a much small threshold */
3440	if (sinfo->flags & BTRFS_BLOCK_GROUP_SYSTEM)
3441		thresh = 32 * 1024 * 1024;
3442
3443	if (num_bytes > thresh && sinfo->bytes_used < div_factor(num_bytes, 8))
3444		return 0;
3445	return 1;
3446}
3447
3448static u64 get_system_chunk_thresh(struct btrfs_root *root, u64 type)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3449{
3450	u64 num_dev;
 
 
 
 
 
3451
3452	if (type & BTRFS_BLOCK_GROUP_RAID10 ||
3453	    type & BTRFS_BLOCK_GROUP_RAID0)
3454		num_dev = root->fs_info->fs_devices->rw_devices;
3455	else if (type & BTRFS_BLOCK_GROUP_RAID1)
3456		num_dev = 2;
3457	else
3458		num_dev = 1;	/* DUP or single */
3459
3460	/* metadata for updaing devices and chunk tree */
3461	return btrfs_calc_trans_metadata_size(root, num_dev + 1);
3462}
3463
3464static void check_system_chunk(struct btrfs_trans_handle *trans,
3465			       struct btrfs_root *root, u64 type)
3466{
3467	struct btrfs_space_info *info;
3468	u64 left;
3469	u64 thresh;
3470
3471	info = __find_space_info(root->fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
3472	spin_lock(&info->lock);
3473	left = info->total_bytes - info->bytes_used - info->bytes_pinned -
3474		info->bytes_reserved - info->bytes_readonly;
3475	spin_unlock(&info->lock);
3476
3477	thresh = get_system_chunk_thresh(root, type);
3478	if (left < thresh && btrfs_test_opt(root, ENOSPC_DEBUG)) {
3479		printk(KERN_INFO "left=%llu, need=%llu, flags=%llu\n",
3480		       left, thresh, type);
3481		dump_space_info(info, 0, 0);
3482	}
3483
3484	if (left < thresh) {
3485		u64 flags;
3486
3487		flags = btrfs_get_alloc_profile(root->fs_info->chunk_root, 0);
3488		btrfs_alloc_chunk(trans, root, flags);
3489	}
3490}
3491
3492static int do_chunk_alloc(struct btrfs_trans_handle *trans,
3493			  struct btrfs_root *extent_root, u64 alloc_bytes,
3494			  u64 flags, int force)
3495{
3496	struct btrfs_space_info *space_info;
3497	struct btrfs_fs_info *fs_info = extent_root->fs_info;
3498	int wait_for_alloc = 0;
3499	int ret = 0;
3500
3501	space_info = __find_space_info(extent_root->fs_info, flags);
3502	if (!space_info) {
3503		ret = update_space_info(extent_root->fs_info, flags,
3504					0, 0, &space_info);
3505		BUG_ON(ret); /* -ENOMEM */
3506	}
3507	BUG_ON(!space_info); /* Logic error */
3508
3509again:
3510	spin_lock(&space_info->lock);
3511	if (force < space_info->force_alloc)
3512		force = space_info->force_alloc;
3513	if (space_info->full) {
3514		spin_unlock(&space_info->lock);
3515		return 0;
3516	}
3517
3518	if (!should_alloc_chunk(extent_root, space_info, alloc_bytes, force)) {
3519		spin_unlock(&space_info->lock);
3520		return 0;
3521	} else if (space_info->chunk_alloc) {
3522		wait_for_alloc = 1;
3523	} else {
3524		space_info->chunk_alloc = 1;
3525	}
3526
3527	spin_unlock(&space_info->lock);
3528
3529	mutex_lock(&fs_info->chunk_mutex);
3530
3531	/*
3532	 * The chunk_mutex is held throughout the entirety of a chunk
3533	 * allocation, so once we've acquired the chunk_mutex we know that the
3534	 * other guy is done and we need to recheck and see if we should
3535	 * allocate.
3536	 */
3537	if (wait_for_alloc) {
3538		mutex_unlock(&fs_info->chunk_mutex);
3539		wait_for_alloc = 0;
3540		goto again;
3541	}
3542
3543	/*
3544	 * If we have mixed data/metadata chunks we want to make sure we keep
3545	 * allocating mixed chunks instead of individual chunks.
3546	 */
3547	if (btrfs_mixed_space_info(space_info))
3548		flags |= (BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA);
3549
3550	/*
3551	 * if we're doing a data chunk, go ahead and make sure that
3552	 * we keep a reasonable number of metadata chunks allocated in the
3553	 * FS as well.
3554	 */
3555	if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {
3556		fs_info->data_chunk_allocations++;
3557		if (!(fs_info->data_chunk_allocations %
3558		      fs_info->metadata_ratio))
3559			force_metadata_allocation(fs_info);
3560	}
3561
3562	/*
3563	 * Check if we have enough space in SYSTEM chunk because we may need
3564	 * to update devices.
3565	 */
3566	check_system_chunk(trans, extent_root, flags);
3567
3568	ret = btrfs_alloc_chunk(trans, extent_root, flags);
3569	if (ret < 0 && ret != -ENOSPC)
3570		goto out;
3571
3572	spin_lock(&space_info->lock);
3573	if (ret)
3574		space_info->full = 1;
3575	else
3576		ret = 1;
3577
3578	space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
3579	space_info->chunk_alloc = 0;
3580	spin_unlock(&space_info->lock);
3581out:
3582	mutex_unlock(&fs_info->chunk_mutex);
3583	return ret;
3584}
3585
 
 
 
 
 
 
 
3586/*
3587 * shrink metadata reservation for delalloc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3588 */
3589static int shrink_delalloc(struct btrfs_root *root, u64 to_reclaim,
3590			   bool wait_ordered)
 
 
 
 
3591{
3592	struct btrfs_block_rsv *block_rsv;
3593	struct btrfs_space_info *space_info;
3594	struct btrfs_trans_handle *trans;
3595	u64 reserved;
3596	u64 max_reclaim;
3597	u64 reclaimed = 0;
3598	long time_left;
3599	unsigned long nr_pages = (2 * 1024 * 1024) >> PAGE_CACHE_SHIFT;
3600	int loops = 0;
3601	unsigned long progress;
3602
3603	trans = (struct btrfs_trans_handle *)current->journal_info;
3604	block_rsv = &root->fs_info->delalloc_block_rsv;
3605	space_info = block_rsv->space_info;
3606
3607	smp_mb();
3608	reserved = space_info->bytes_may_use;
3609	progress = space_info->reservation_progress;
 
3610
3611	if (reserved == 0)
3612		return 0;
3613
3614	smp_mb();
3615	if (root->fs_info->delalloc_bytes == 0) {
3616		if (trans)
3617			return 0;
3618		btrfs_wait_ordered_extents(root, 0, 0);
3619		return 0;
3620	}
3621
3622	max_reclaim = min(reserved, to_reclaim);
3623	nr_pages = max_t(unsigned long, nr_pages,
3624			 max_reclaim >> PAGE_CACHE_SHIFT);
3625	while (loops < 1024) {
3626		/* have the flusher threads jump in and do some IO */
3627		smp_mb();
3628		nr_pages = min_t(unsigned long, nr_pages,
3629		       root->fs_info->delalloc_bytes >> PAGE_CACHE_SHIFT);
3630		writeback_inodes_sb_nr_if_idle(root->fs_info->sb, nr_pages,
3631						WB_REASON_FS_FREE_SPACE);
3632
3633		spin_lock(&space_info->lock);
3634		if (reserved > space_info->bytes_may_use)
3635			reclaimed += reserved - space_info->bytes_may_use;
3636		reserved = space_info->bytes_may_use;
3637		spin_unlock(&space_info->lock);
 
 
 
3638
3639		loops++;
 
3640
3641		if (reserved == 0 || reclaimed >= max_reclaim)
3642			break;
3643
3644		if (trans && trans->transaction->blocked)
3645			return -EAGAIN;
3646
3647		if (wait_ordered && !trans) {
3648			btrfs_wait_ordered_extents(root, 0, 0);
3649		} else {
3650			time_left = schedule_timeout_interruptible(1);
3651
3652			/* We were interrupted, exit */
3653			if (time_left)
 
 
 
 
 
 
 
 
 
 
 
 
3654				break;
3655		}
3656
3657		/* we've kicked the IO a few times, if anything has been freed,
3658		 * exit.  There is no sense in looping here for a long time
3659		 * when we really need to commit the transaction, or there are
3660		 * just too many writers without enough free space
3661		 */
3662
3663		if (loops > 3) {
3664			smp_mb();
3665			if (progress != space_info->reservation_progress)
3666				break;
 
3667		}
3668
3669	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3670
3671	return reclaimed >= to_reclaim;
3672}
 
 
3673
3674/**
3675 * maybe_commit_transaction - possibly commit the transaction if its ok to
3676 * @root - the root we're allocating for
3677 * @bytes - the number of bytes we want to reserve
3678 * @force - force the commit
3679 *
3680 * This will check to make sure that committing the transaction will actually
3681 * get us somewhere and then commit the transaction if it does.  Otherwise it
3682 * will return -ENOSPC.
3683 */
3684static int may_commit_transaction(struct btrfs_root *root,
3685				  struct btrfs_space_info *space_info,
3686				  u64 bytes, int force)
3687{
3688	struct btrfs_block_rsv *delayed_rsv = &root->fs_info->delayed_block_rsv;
3689	struct btrfs_trans_handle *trans;
3690
3691	trans = (struct btrfs_trans_handle *)current->journal_info;
3692	if (trans)
3693		return -EAGAIN;
 
 
 
 
 
 
 
 
 
 
 
 
3694
3695	if (force)
3696		goto commit;
 
 
 
 
 
 
 
3697
3698	/* See if there is enough pinned space to make this reservation */
3699	spin_lock(&space_info->lock);
3700	if (space_info->bytes_pinned >= bytes) {
3701		spin_unlock(&space_info->lock);
3702		goto commit;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3703	}
3704	spin_unlock(&space_info->lock);
3705
3706	/*
3707	 * See if there is some space in the delayed insertion reservation for
3708	 * this reservation.
3709	 */
3710	if (space_info != delayed_rsv->space_info)
3711		return -ENOSPC;
 
 
 
 
 
 
 
 
 
3712
3713	spin_lock(&space_info->lock);
3714	spin_lock(&delayed_rsv->lock);
3715	if (space_info->bytes_pinned + delayed_rsv->size < bytes) {
3716		spin_unlock(&delayed_rsv->lock);
3717		spin_unlock(&space_info->lock);
3718		return -ENOSPC;
 
 
 
 
 
3719	}
3720	spin_unlock(&delayed_rsv->lock);
3721	spin_unlock(&space_info->lock);
3722
3723commit:
3724	trans = btrfs_join_transaction(root);
3725	if (IS_ERR(trans))
3726		return -ENOSPC;
 
 
 
 
 
3727
3728	return btrfs_commit_transaction(trans, root);
3729}
3730
3731/**
3732 * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
3733 * @root - the root we're allocating for
3734 * @block_rsv - the block_rsv we're allocating for
3735 * @orig_bytes - the number of bytes we want
3736 * @flush - wether or not we can flush to make our reservation
3737 *
3738 * This will reserve orgi_bytes number of bytes from the space info associated
3739 * with the block_rsv.  If there is not enough space it will make an attempt to
3740 * flush out space to make room.  It will do this by flushing delalloc if
3741 * possible or committing the transaction.  If flush is 0 then no attempts to
3742 * regain reservations will be made and this will fail if there is not enough
3743 * space already.
3744 */
3745static int reserve_metadata_bytes(struct btrfs_root *root,
3746				  struct btrfs_block_rsv *block_rsv,
3747				  u64 orig_bytes, int flush)
3748{
3749	struct btrfs_space_info *space_info = block_rsv->space_info;
3750	u64 used;
3751	u64 num_bytes = orig_bytes;
3752	int retries = 0;
3753	int ret = 0;
3754	bool committed = false;
3755	bool flushing = false;
3756	bool wait_ordered = false;
3757
3758again:
3759	ret = 0;
3760	spin_lock(&space_info->lock);
3761	/*
3762	 * We only want to wait if somebody other than us is flushing and we are
3763	 * actually alloed to flush.
3764	 */
3765	while (flush && !flushing && space_info->flush) {
3766		spin_unlock(&space_info->lock);
3767		/*
3768		 * If we have a trans handle we can't wait because the flusher
3769		 * may have to commit the transaction, which would mean we would
3770		 * deadlock since we are waiting for the flusher to finish, but
3771		 * hold the current transaction open.
3772		 */
3773		if (current->journal_info)
3774			return -EAGAIN;
3775		ret = wait_event_killable(space_info->wait, !space_info->flush);
3776		/* Must have been killed, return */
3777		if (ret)
3778			return -EINTR;
3779
3780		spin_lock(&space_info->lock);
3781	}
3782
3783	ret = -ENOSPC;
3784	used = space_info->bytes_used + space_info->bytes_reserved +
3785		space_info->bytes_pinned + space_info->bytes_readonly +
3786		space_info->bytes_may_use;
3787
3788	/*
3789	 * The idea here is that we've not already over-reserved the block group
3790	 * then we can go ahead and save our reservation first and then start
3791	 * flushing if we need to.  Otherwise if we've already overcommitted
3792	 * lets start flushing stuff first and then come back and try to make
3793	 * our reservation.
3794	 */
3795	if (used <= space_info->total_bytes) {
3796		if (used + orig_bytes <= space_info->total_bytes) {
3797			space_info->bytes_may_use += orig_bytes;
3798			trace_btrfs_space_reservation(root->fs_info,
3799				"space_info", space_info->flags, orig_bytes, 1);
3800			ret = 0;
3801		} else {
3802			/*
3803			 * Ok set num_bytes to orig_bytes since we aren't
3804			 * overocmmitted, this way we only try and reclaim what
3805			 * we need.
3806			 */
3807			num_bytes = orig_bytes;
 
 
 
 
3808		}
3809	} else {
3810		/*
3811		 * Ok we're over committed, set num_bytes to the overcommitted
3812		 * amount plus the amount of bytes that we need for this
3813		 * reservation.
3814		 */
3815		wait_ordered = true;
3816		num_bytes = used - space_info->total_bytes +
3817			(orig_bytes * (retries + 1));
3818	}
3819
3820	if (ret) {
3821		u64 profile = btrfs_get_alloc_profile(root, 0);
3822		u64 avail;
3823
3824		/*
3825		 * If we have a lot of space that's pinned, don't bother doing
3826		 * the overcommit dance yet and just commit the transaction.
3827		 */
3828		avail = (space_info->total_bytes - space_info->bytes_used) * 8;
3829		do_div(avail, 10);
3830		if (space_info->bytes_pinned >= avail && flush && !committed) {
3831			space_info->flush = 1;
3832			flushing = true;
3833			spin_unlock(&space_info->lock);
3834			ret = may_commit_transaction(root, space_info,
3835						     orig_bytes, 1);
3836			if (ret)
3837				goto out;
3838			committed = true;
3839			goto again;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3840		}
3841
3842		spin_lock(&root->fs_info->free_chunk_lock);
3843		avail = root->fs_info->free_chunk_space;
3844
3845		/*
3846		 * If we have dup, raid1 or raid10 then only half of the free
3847		 * space is actually useable.
 
 
 
3848		 */
3849		if (profile & (BTRFS_BLOCK_GROUP_DUP |
3850			       BTRFS_BLOCK_GROUP_RAID1 |
3851			       BTRFS_BLOCK_GROUP_RAID10))
3852			avail >>= 1;
3853
3854		/*
3855		 * If we aren't flushing don't let us overcommit too much, say
3856		 * 1/8th of the space.  If we can flush, let it overcommit up to
3857		 * 1/2 of the space.
3858		 */
3859		if (flush)
3860			avail >>= 3;
3861		else
3862			avail >>= 1;
3863		 spin_unlock(&root->fs_info->free_chunk_lock);
3864
3865		if (used + num_bytes < space_info->total_bytes + avail) {
3866			space_info->bytes_may_use += orig_bytes;
3867			trace_btrfs_space_reservation(root->fs_info,
3868				"space_info", space_info->flags, orig_bytes, 1);
3869			ret = 0;
3870		} else {
3871			wait_ordered = true;
3872		}
3873	}
 
 
 
 
 
 
3874
3875	/*
3876	 * Couldn't make our reservation, save our place so while we're trying
3877	 * to reclaim space we can actually use it instead of somebody else
3878	 * stealing it from us.
3879	 */
3880	if (ret && flush) {
3881		flushing = true;
3882		space_info->flush = 1;
3883	}
 
 
 
 
 
 
 
 
 
3884
3885	spin_unlock(&space_info->lock);
 
 
3886
3887	if (!ret || !flush)
3888		goto out;
3889
3890	/*
3891	 * We do synchronous shrinking since we don't actually unreserve
3892	 * metadata until after the IO is completed.
3893	 */
3894	ret = shrink_delalloc(root, num_bytes, wait_ordered);
3895	if (ret < 0)
3896		goto out;
3897
3898	ret = 0;
 
3899
3900	/*
3901	 * So if we were overcommitted it's possible that somebody else flushed
3902	 * out enough space and we simply didn't have enough space to reclaim,
3903	 * so go back around and try again.
3904	 */
3905	if (retries < 2) {
3906		wait_ordered = true;
3907		retries++;
3908		goto again;
3909	}
3910
3911	ret = -ENOSPC;
3912	if (committed)
3913		goto out;
3914
3915	ret = may_commit_transaction(root, space_info, orig_bytes, 0);
3916	if (!ret) {
3917		committed = true;
3918		goto again;
3919	}
 
3920
3921out:
3922	if (flushing) {
3923		spin_lock(&space_info->lock);
3924		space_info->flush = 0;
3925		wake_up_all(&space_info->wait);
3926		spin_unlock(&space_info->lock);
3927	}
3928	return ret;
3929}
3930
3931static struct btrfs_block_rsv *get_block_rsv(
3932					const struct btrfs_trans_handle *trans,
3933					const struct btrfs_root *root)
 
3934{
3935	struct btrfs_block_rsv *block_rsv = NULL;
 
 
 
3936
3937	if (root->ref_cows || root == root->fs_info->csum_root)
3938		block_rsv = trans->block_rsv;
 
 
 
 
 
 
 
 
3939
3940	if (!block_rsv)
3941		block_rsv = root->block_rsv;
3942
3943	if (!block_rsv)
3944		block_rsv = &root->fs_info->empty_block_rsv;
3945
3946	return block_rsv;
3947}
3948
3949static int block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,
3950			       u64 num_bytes)
3951{
3952	int ret = -ENOSPC;
3953	spin_lock(&block_rsv->lock);
3954	if (block_rsv->reserved >= num_bytes) {
3955		block_rsv->reserved -= num_bytes;
3956		if (block_rsv->reserved < block_rsv->size)
3957			block_rsv->full = 0;
3958		ret = 0;
3959	}
3960	spin_unlock(&block_rsv->lock);
3961	return ret;
3962}
3963
3964static void block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
3965				u64 num_bytes, int update_size)
3966{
3967	spin_lock(&block_rsv->lock);
3968	block_rsv->reserved += num_bytes;
3969	if (update_size)
3970		block_rsv->size += num_bytes;
3971	else if (block_rsv->reserved >= block_rsv->size)
3972		block_rsv->full = 1;
3973	spin_unlock(&block_rsv->lock);
3974}
3975
3976static void block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
3977				    struct btrfs_block_rsv *block_rsv,
3978				    struct btrfs_block_rsv *dest, u64 num_bytes)
3979{
3980	struct btrfs_space_info *space_info = block_rsv->space_info;
3981
3982	spin_lock(&block_rsv->lock);
3983	if (num_bytes == (u64)-1)
3984		num_bytes = block_rsv->size;
3985	block_rsv->size -= num_bytes;
3986	if (block_rsv->reserved >= block_rsv->size) {
3987		num_bytes = block_rsv->reserved - block_rsv->size;
3988		block_rsv->reserved = block_rsv->size;
3989		block_rsv->full = 1;
3990	} else {
3991		num_bytes = 0;
3992	}
3993	spin_unlock(&block_rsv->lock);
 
 
 
 
3994
3995	if (num_bytes > 0) {
3996		if (dest) {
3997			spin_lock(&dest->lock);
3998			if (!dest->full) {
3999				u64 bytes_to_add;
4000
4001				bytes_to_add = dest->size - dest->reserved;
4002				bytes_to_add = min(num_bytes, bytes_to_add);
4003				dest->reserved += bytes_to_add;
4004				if (dest->reserved >= dest->size)
4005					dest->full = 1;
4006				num_bytes -= bytes_to_add;
4007			}
4008			spin_unlock(&dest->lock);
4009		}
4010		if (num_bytes) {
4011			spin_lock(&space_info->lock);
4012			space_info->bytes_may_use -= num_bytes;
4013			trace_btrfs_space_reservation(fs_info, "space_info",
4014					space_info->flags, num_bytes, 0);
4015			space_info->reservation_progress++;
4016			spin_unlock(&space_info->lock);
4017		}
4018	}
4019}
4020
4021static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
4022				   struct btrfs_block_rsv *dst, u64 num_bytes)
4023{
4024	int ret;
4025
4026	ret = block_rsv_use_bytes(src, num_bytes);
4027	if (ret)
4028		return ret;
 
4029
4030	block_rsv_add_bytes(dst, num_bytes, 1);
4031	return 0;
4032}
4033
4034void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv)
4035{
4036	memset(rsv, 0, sizeof(*rsv));
4037	spin_lock_init(&rsv->lock);
 
4038}
4039
4040struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
4041{
4042	struct btrfs_block_rsv *block_rsv;
4043	struct btrfs_fs_info *fs_info = root->fs_info;
4044
4045	block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
4046	if (!block_rsv)
4047		return NULL;
4048
4049	btrfs_init_block_rsv(block_rsv);
4050	block_rsv->space_info = __find_space_info(fs_info,
4051						  BTRFS_BLOCK_GROUP_METADATA);
4052	return block_rsv;
4053}
4054
4055void btrfs_free_block_rsv(struct btrfs_root *root,
4056			  struct btrfs_block_rsv *rsv)
4057{
4058	btrfs_block_rsv_release(root, rsv, (u64)-1);
4059	kfree(rsv);
4060}
4061
4062static inline int __block_rsv_add(struct btrfs_root *root,
4063				  struct btrfs_block_rsv *block_rsv,
4064				  u64 num_bytes, int flush)
4065{
 
4066	int ret;
4067
4068	if (num_bytes == 0)
4069		return 0;
4070
4071	ret = reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
4072	if (!ret) {
4073		block_rsv_add_bytes(block_rsv, num_bytes, 1);
4074		return 0;
 
 
 
 
 
 
 
 
 
 
4075	}
4076
4077	return ret;
4078}
4079
4080int btrfs_block_rsv_add(struct btrfs_root *root,
4081			struct btrfs_block_rsv *block_rsv,
4082			u64 num_bytes)
4083{
4084	return __block_rsv_add(root, block_rsv, num_bytes, 1);
4085}
4086
4087int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
4088				struct btrfs_block_rsv *block_rsv,
4089				u64 num_bytes)
4090{
4091	return __block_rsv_add(root, block_rsv, num_bytes, 0);
4092}
4093
4094int btrfs_block_rsv_check(struct btrfs_root *root,
4095			  struct btrfs_block_rsv *block_rsv, int min_factor)
4096{
4097	u64 num_bytes = 0;
4098	int ret = -ENOSPC;
4099
4100	if (!block_rsv)
4101		return 0;
4102
4103	spin_lock(&block_rsv->lock);
4104	num_bytes = div_factor(block_rsv->size, min_factor);
4105	if (block_rsv->reserved >= num_bytes)
4106		ret = 0;
4107	spin_unlock(&block_rsv->lock);
4108
4109	return ret;
4110}
4111
4112static inline int __btrfs_block_rsv_refill(struct btrfs_root *root,
4113					   struct btrfs_block_rsv *block_rsv,
4114					   u64 min_reserved, int flush)
4115{
4116	u64 num_bytes = 0;
4117	int ret = -ENOSPC;
4118
4119	if (!block_rsv)
4120		return 0;
 
 
 
4121
4122	spin_lock(&block_rsv->lock);
4123	num_bytes = min_reserved;
4124	if (block_rsv->reserved >= num_bytes)
4125		ret = 0;
4126	else
4127		num_bytes -= block_rsv->reserved;
4128	spin_unlock(&block_rsv->lock);
4129
4130	if (!ret)
4131		return 0;
 
 
4132
4133	ret = reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
4134	if (!ret) {
4135		block_rsv_add_bytes(block_rsv, num_bytes, 0);
4136		return 0;
4137	}
4138
4139	return ret;
4140}
 
 
 
 
4141
4142int btrfs_block_rsv_refill(struct btrfs_root *root,
4143			   struct btrfs_block_rsv *block_rsv,
4144			   u64 min_reserved)
4145{
4146	return __btrfs_block_rsv_refill(root, block_rsv, min_reserved, 1);
 
4147}
4148
4149int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
4150				   struct btrfs_block_rsv *block_rsv,
4151				   u64 min_reserved)
4152{
4153	return __btrfs_block_rsv_refill(root, block_rsv, min_reserved, 0);
 
 
4154}
4155
4156int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
4157			    struct btrfs_block_rsv *dst_rsv,
4158			    u64 num_bytes)
 
 
4159{
4160	return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
4161}
4162
4163void btrfs_block_rsv_release(struct btrfs_root *root,
4164			     struct btrfs_block_rsv *block_rsv,
4165			     u64 num_bytes)
4166{
4167	struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
4168	if (global_rsv->full || global_rsv == block_rsv ||
4169	    block_rsv->space_info != global_rsv->space_info)
4170		global_rsv = NULL;
4171	block_rsv_release_bytes(root->fs_info, block_rsv, global_rsv,
4172				num_bytes);
4173}
4174
4175/*
4176 * helper to calculate size of global block reservation.
4177 * the desired value is sum of space used by extent tree,
4178 * checksum tree and root tree
4179 */
4180static u64 calc_global_metadata_size(struct btrfs_fs_info *fs_info)
4181{
4182	struct btrfs_space_info *sinfo;
4183	u64 num_bytes;
4184	u64 meta_used;
4185	u64 data_used;
4186	int csum_size = btrfs_super_csum_size(fs_info->super_copy);
4187
4188	sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);
4189	spin_lock(&sinfo->lock);
4190	data_used = sinfo->bytes_used;
4191	spin_unlock(&sinfo->lock);
4192
4193	sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
4194	spin_lock(&sinfo->lock);
4195	if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA)
4196		data_used = 0;
4197	meta_used = sinfo->bytes_used;
4198	spin_unlock(&sinfo->lock);
4199
4200	num_bytes = (data_used >> fs_info->sb->s_blocksize_bits) *
4201		    csum_size * 2;
4202	num_bytes += div64_u64(data_used + meta_used, 50);
4203
4204	if (num_bytes * 3 > meta_used)
4205		num_bytes = div64_u64(meta_used, 3);
4206
4207	return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10);
4208}
4209
4210static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
4211{
4212	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
4213	struct btrfs_space_info *sinfo = block_rsv->space_info;
4214	u64 num_bytes;
4215
4216	num_bytes = calc_global_metadata_size(fs_info);
 
4217
4218	spin_lock(&sinfo->lock);
4219	spin_lock(&block_rsv->lock);
4220
4221	block_rsv->size = num_bytes;
 
4222
4223	num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +
4224		    sinfo->bytes_reserved + sinfo->bytes_readonly +
4225		    sinfo->bytes_may_use;
4226
4227	if (sinfo->total_bytes > num_bytes) {
4228		num_bytes = sinfo->total_bytes - num_bytes;
4229		block_rsv->reserved += num_bytes;
4230		sinfo->bytes_may_use += num_bytes;
4231		trace_btrfs_space_reservation(fs_info, "space_info",
4232				      sinfo->flags, num_bytes, 1);
4233	}
4234
4235	if (block_rsv->reserved >= block_rsv->size) {
4236		num_bytes = block_rsv->reserved - block_rsv->size;
4237		sinfo->bytes_may_use -= num_bytes;
4238		trace_btrfs_space_reservation(fs_info, "space_info",
4239				      sinfo->flags, num_bytes, 0);
4240		sinfo->reservation_progress++;
4241		block_rsv->reserved = block_rsv->size;
4242		block_rsv->full = 1;
4243	}
4244
4245	spin_unlock(&block_rsv->lock);
4246	spin_unlock(&sinfo->lock);
4247}
4248
4249static void init_global_block_rsv(struct btrfs_fs_info *fs_info)
 
 
4250{
4251	struct btrfs_space_info *space_info;
4252
4253	space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
4254	fs_info->chunk_block_rsv.space_info = space_info;
4255
4256	space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
4257	fs_info->global_block_rsv.space_info = space_info;
4258	fs_info->delalloc_block_rsv.space_info = space_info;
4259	fs_info->trans_block_rsv.space_info = space_info;
4260	fs_info->empty_block_rsv.space_info = space_info;
4261	fs_info->delayed_block_rsv.space_info = space_info;
4262
4263	fs_info->extent_root->block_rsv = &fs_info->global_block_rsv;
4264	fs_info->csum_root->block_rsv = &fs_info->global_block_rsv;
4265	fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
4266	fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
4267	fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
4268
4269	update_global_block_rsv(fs_info);
4270}
4271
4272static void release_global_block_rsv(struct btrfs_fs_info *fs_info)
4273{
4274	block_rsv_release_bytes(fs_info, &fs_info->global_block_rsv, NULL,
4275				(u64)-1);
4276	WARN_ON(fs_info->delalloc_block_rsv.size > 0);
4277	WARN_ON(fs_info->delalloc_block_rsv.reserved > 0);
4278	WARN_ON(fs_info->trans_block_rsv.size > 0);
4279	WARN_ON(fs_info->trans_block_rsv.reserved > 0);
4280	WARN_ON(fs_info->chunk_block_rsv.size > 0);
4281	WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
4282	WARN_ON(fs_info->delayed_block_rsv.size > 0);
4283	WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
4284}
4285
4286void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
4287				  struct btrfs_root *root)
4288{
4289	if (!trans->bytes_reserved)
4290		return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4291
4292	trace_btrfs_space_reservation(root->fs_info, "transaction",
4293				      trans->transid, trans->bytes_reserved, 0);
4294	btrfs_block_rsv_release(root, trans->block_rsv, trans->bytes_reserved);
4295	trans->bytes_reserved = 0;
4296}
 
 
 
 
 
 
 
 
 
 
 
 
4297
4298/* Can only return 0 or -ENOSPC */
4299int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
4300				  struct inode *inode)
4301{
4302	struct btrfs_root *root = BTRFS_I(inode)->root;
4303	struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
4304	struct btrfs_block_rsv *dst_rsv = root->orphan_block_rsv;
4305
4306	/*
4307	 * We need to hold space in order to delete our orphan item once we've
4308	 * added it, so this takes the reservation so we can release it later
4309	 * when we are truly done with the orphan item.
4310	 */
4311	u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
4312	trace_btrfs_space_reservation(root->fs_info, "orphan",
4313				      btrfs_ino(inode), num_bytes, 1);
4314	return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
4315}
4316
4317void btrfs_orphan_release_metadata(struct inode *inode)
4318{
4319	struct btrfs_root *root = BTRFS_I(inode)->root;
4320	u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
4321	trace_btrfs_space_reservation(root->fs_info, "orphan",
4322				      btrfs_ino(inode), num_bytes, 0);
4323	btrfs_block_rsv_release(root, root->orphan_block_rsv, num_bytes);
4324}
4325
4326int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
4327				struct btrfs_pending_snapshot *pending)
4328{
4329	struct btrfs_root *root = pending->root;
4330	struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
4331	struct btrfs_block_rsv *dst_rsv = &pending->block_rsv;
 
 
 
 
 
 
 
 
 
 
 
 
4332	/*
4333	 * two for root back/forward refs, two for directory entries
4334	 * and one for root of the snapshot.
 
4335	 */
4336	u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5);
4337	dst_rsv->space_info = src_rsv->space_info;
4338	return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
4339}
4340
4341/**
4342 * drop_outstanding_extent - drop an outstanding extent
4343 * @inode: the inode we're dropping the extent for
4344 *
4345 * This is called when we are freeing up an outstanding extent, either called
4346 * after an error or after an extent is written.  This will return the number of
4347 * reserved extents that need to be freed.  This must be called with
4348 * BTRFS_I(inode)->lock held.
4349 */
4350static unsigned drop_outstanding_extent(struct inode *inode)
4351{
4352	unsigned drop_inode_space = 0;
4353	unsigned dropped_extents = 0;
4354
4355	BUG_ON(!BTRFS_I(inode)->outstanding_extents);
4356	BTRFS_I(inode)->outstanding_extents--;
4357
4358	if (BTRFS_I(inode)->outstanding_extents == 0 &&
4359	    test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4360			       &BTRFS_I(inode)->runtime_flags))
4361		drop_inode_space = 1;
4362
4363	/*
4364	 * If we have more or the same amount of outsanding extents than we have
4365	 * reserved then we need to leave the reserved extents count alone.
4366	 */
4367	if (BTRFS_I(inode)->outstanding_extents >=
4368	    BTRFS_I(inode)->reserved_extents)
4369		return drop_inode_space;
4370
4371	dropped_extents = BTRFS_I(inode)->reserved_extents -
4372		BTRFS_I(inode)->outstanding_extents;
4373	BTRFS_I(inode)->reserved_extents -= dropped_extents;
4374	return dropped_extents + drop_inode_space;
4375}
4376
4377/**
4378 * calc_csum_metadata_size - return the amount of metada space that must be
4379 *	reserved/free'd for the given bytes.
4380 * @inode: the inode we're manipulating
4381 * @num_bytes: the number of bytes in question
4382 * @reserve: 1 if we are reserving space, 0 if we are freeing space
4383 *
4384 * This adjusts the number of csum_bytes in the inode and then returns the
4385 * correct amount of metadata that must either be reserved or freed.  We
4386 * calculate how many checksums we can fit into one leaf and then divide the
4387 * number of bytes that will need to be checksumed by this value to figure out
4388 * how many checksums will be required.  If we are adding bytes then the number
4389 * may go up and we will return the number of additional bytes that must be
4390 * reserved.  If it is going down we will return the number of bytes that must
4391 * be freed.
4392 *
4393 * This must be called with BTRFS_I(inode)->lock held.
4394 */
4395static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes,
4396				   int reserve)
4397{
4398	struct btrfs_root *root = BTRFS_I(inode)->root;
4399	u64 csum_size;
4400	int num_csums_per_leaf;
4401	int num_csums;
4402	int old_csums;
4403
4404	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM &&
4405	    BTRFS_I(inode)->csum_bytes == 0)
4406		return 0;
4407
4408	old_csums = (int)div64_u64(BTRFS_I(inode)->csum_bytes, root->sectorsize);
4409	if (reserve)
4410		BTRFS_I(inode)->csum_bytes += num_bytes;
4411	else
4412		BTRFS_I(inode)->csum_bytes -= num_bytes;
4413	csum_size = BTRFS_LEAF_DATA_SIZE(root) - sizeof(struct btrfs_item);
4414	num_csums_per_leaf = (int)div64_u64(csum_size,
4415					    sizeof(struct btrfs_csum_item) +
4416					    sizeof(struct btrfs_disk_key));
4417	num_csums = (int)div64_u64(BTRFS_I(inode)->csum_bytes, root->sectorsize);
4418	num_csums = num_csums + num_csums_per_leaf - 1;
4419	num_csums = num_csums / num_csums_per_leaf;
4420
4421	old_csums = old_csums + num_csums_per_leaf - 1;
4422	old_csums = old_csums / num_csums_per_leaf;
4423
4424	/* No change, no need to reserve more */
4425	if (old_csums == num_csums)
4426		return 0;
4427
4428	if (reserve)
4429		return btrfs_calc_trans_metadata_size(root,
4430						      num_csums - old_csums);
4431
4432	return btrfs_calc_trans_metadata_size(root, old_csums - num_csums);
4433}
4434
4435int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
4436{
4437	struct btrfs_root *root = BTRFS_I(inode)->root;
4438	struct btrfs_block_rsv *block_rsv = &root->fs_info->delalloc_block_rsv;
4439	u64 to_reserve = 0;
4440	u64 csum_bytes;
4441	unsigned nr_extents = 0;
4442	int extra_reserve = 0;
4443	int flush = 1;
4444	int ret;
4445
4446	/* Need to be holding the i_mutex here if we aren't free space cache */
4447	if (btrfs_is_free_space_inode(root, inode))
4448		flush = 0;
4449
4450	if (flush && btrfs_transaction_in_commit(root->fs_info))
4451		schedule_timeout(1);
4452
4453	mutex_lock(&BTRFS_I(inode)->delalloc_mutex);
4454	num_bytes = ALIGN(num_bytes, root->sectorsize);
4455
4456	spin_lock(&BTRFS_I(inode)->lock);
4457	BTRFS_I(inode)->outstanding_extents++;
4458
4459	if (BTRFS_I(inode)->outstanding_extents >
4460	    BTRFS_I(inode)->reserved_extents)
4461		nr_extents = BTRFS_I(inode)->outstanding_extents -
4462			BTRFS_I(inode)->reserved_extents;
4463
4464	/*
4465	 * Add an item to reserve for updating the inode when we complete the
4466	 * delalloc io.
 
4467	 */
4468	if (!test_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4469		      &BTRFS_I(inode)->runtime_flags)) {
4470		nr_extents++;
4471		extra_reserve = 1;
4472	}
 
 
4473
4474	to_reserve = btrfs_calc_trans_metadata_size(root, nr_extents);
4475	to_reserve += calc_csum_metadata_size(inode, num_bytes, 1);
4476	csum_bytes = BTRFS_I(inode)->csum_bytes;
4477	spin_unlock(&BTRFS_I(inode)->lock);
4478
4479	ret = reserve_metadata_bytes(root, block_rsv, to_reserve, flush);
4480	if (ret) {
4481		u64 to_free = 0;
4482		unsigned dropped;
4483
4484		spin_lock(&BTRFS_I(inode)->lock);
4485		dropped = drop_outstanding_extent(inode);
4486		/*
4487		 * If the inodes csum_bytes is the same as the original
4488		 * csum_bytes then we know we haven't raced with any free()ers
4489		 * so we can just reduce our inodes csum bytes and carry on.
4490		 * Otherwise we have to do the normal free thing to account for
4491		 * the case that the free side didn't free up its reserve
4492		 * because of this outstanding reservation.
4493		 */
4494		if (BTRFS_I(inode)->csum_bytes == csum_bytes)
4495			calc_csum_metadata_size(inode, num_bytes, 0);
4496		else
4497			to_free = calc_csum_metadata_size(inode, num_bytes, 0);
4498		spin_unlock(&BTRFS_I(inode)->lock);
4499		if (dropped)
4500			to_free += btrfs_calc_trans_metadata_size(root, dropped);
4501
4502		if (to_free) {
4503			btrfs_block_rsv_release(root, block_rsv, to_free);
4504			trace_btrfs_space_reservation(root->fs_info,
4505						      "delalloc",
4506						      btrfs_ino(inode),
4507						      to_free, 0);
4508		}
4509		mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
4510		return ret;
4511	}
4512
4513	spin_lock(&BTRFS_I(inode)->lock);
4514	if (extra_reserve) {
4515		set_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
4516			&BTRFS_I(inode)->runtime_flags);
4517		nr_extents--;
4518	}
4519	BTRFS_I(inode)->reserved_extents += nr_extents;
4520	spin_unlock(&BTRFS_I(inode)->lock);
4521	mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
4522
4523	if (to_reserve)
4524		trace_btrfs_space_reservation(root->fs_info,"delalloc",
4525					      btrfs_ino(inode), to_reserve, 1);
4526	block_rsv_add_bytes(block_rsv, to_reserve, 1);
4527
4528	return 0;
4529}
4530
4531/**
4532 * btrfs_delalloc_release_metadata - release a metadata reservation for an inode
4533 * @inode: the inode to release the reservation for
4534 * @num_bytes: the number of bytes we're releasing
4535 *
4536 * This will release the metadata reservation for an inode.  This can be called
4537 * once we complete IO for a given set of bytes to release their metadata
4538 * reservations.
4539 */
4540void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
4541{
4542	struct btrfs_root *root = BTRFS_I(inode)->root;
4543	u64 to_free = 0;
4544	unsigned dropped;
4545
4546	num_bytes = ALIGN(num_bytes, root->sectorsize);
4547	spin_lock(&BTRFS_I(inode)->lock);
4548	dropped = drop_outstanding_extent(inode);
 
 
 
 
4549
4550	to_free = calc_csum_metadata_size(inode, num_bytes, 0);
4551	spin_unlock(&BTRFS_I(inode)->lock);
4552	if (dropped > 0)
4553		to_free += btrfs_calc_trans_metadata_size(root, dropped);
4554
4555	trace_btrfs_space_reservation(root->fs_info, "delalloc",
4556				      btrfs_ino(inode), to_free, 0);
4557	btrfs_block_rsv_release(root, &root->fs_info->delalloc_block_rsv,
4558				to_free);
4559}
4560
4561/**
4562 * btrfs_delalloc_reserve_space - reserve data and metadata space for delalloc
4563 * @inode: inode we're writing to
4564 * @num_bytes: the number of bytes we want to allocate
4565 *
4566 * This will do the following things
4567 *
4568 * o reserve space in the data space info for num_bytes
4569 * o reserve space in the metadata space info based on number of outstanding
4570 *   extents and how much csums will be needed
4571 * o add to the inodes ->delalloc_bytes
4572 * o add it to the fs_info's delalloc inodes list.
4573 *
4574 * This will return 0 for success and -ENOSPC if there is no space left.
 
 
 
4575 */
4576int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes)
4577{
4578	int ret;
4579
4580	ret = btrfs_check_data_free_space(inode, num_bytes);
4581	if (ret)
4582		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4583
4584	ret = btrfs_delalloc_reserve_metadata(inode, num_bytes);
4585	if (ret) {
4586		btrfs_free_reserved_data_space(inode, num_bytes);
4587		return ret;
4588	}
4589
4590	return 0;
4591}
 
 
 
 
 
 
 
 
 
 
4592
4593/**
4594 * btrfs_delalloc_release_space - release data and metadata space for delalloc
4595 * @inode: inode we're releasing space for
4596 * @num_bytes: the number of bytes we want to free up
4597 *
4598 * This must be matched with a call to btrfs_delalloc_reserve_space.  This is
4599 * called in the case that we don't need the metadata AND data reservations
4600 * anymore.  So if there is an error or we insert an inline extent.
4601 *
4602 * This function will release the metadata space that was not used and will
4603 * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes
4604 * list if there are no delalloc bytes left.
4605 */
4606void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes)
4607{
4608	btrfs_delalloc_release_metadata(inode, num_bytes);
4609	btrfs_free_reserved_data_space(inode, num_bytes);
4610}
4611
4612static int update_block_group(struct btrfs_trans_handle *trans,
4613			      struct btrfs_root *root,
4614			      u64 bytenr, u64 num_bytes, int alloc)
4615{
4616	struct btrfs_block_group_cache *cache = NULL;
4617	struct btrfs_fs_info *info = root->fs_info;
4618	u64 total = num_bytes;
4619	u64 old_val;
4620	u64 byte_in_group;
4621	int factor;
4622
4623	/* block accounting for super block */
4624	spin_lock(&info->delalloc_lock);
4625	old_val = btrfs_super_bytes_used(info->super_copy);
4626	if (alloc)
4627		old_val += num_bytes;
4628	else
4629		old_val -= num_bytes;
4630	btrfs_set_super_bytes_used(info->super_copy, old_val);
4631	spin_unlock(&info->delalloc_lock);
4632
4633	while (total) {
4634		cache = btrfs_lookup_block_group(info, bytenr);
4635		if (!cache)
4636			return -ENOENT;
4637		if (cache->flags & (BTRFS_BLOCK_GROUP_DUP |
4638				    BTRFS_BLOCK_GROUP_RAID1 |
4639				    BTRFS_BLOCK_GROUP_RAID10))
4640			factor = 2;
4641		else
4642			factor = 1;
4643		/*
4644		 * If this block group has free space cache written out, we
4645		 * need to make sure to load it if we are removing space.  This
4646		 * is because we need the unpinning stage to actually add the
4647		 * space back to the block group, otherwise we will leak space.
4648		 */
4649		if (!alloc && cache->cached == BTRFS_CACHE_NO)
4650			cache_block_group(cache, trans, NULL, 1);
4651
4652		byte_in_group = bytenr - cache->key.objectid;
4653		WARN_ON(byte_in_group > cache->key.offset);
4654
4655		spin_lock(&cache->space_info->lock);
4656		spin_lock(&cache->lock);
4657
4658		if (btrfs_test_opt(root, SPACE_CACHE) &&
4659		    cache->disk_cache_state < BTRFS_DC_CLEAR)
4660			cache->disk_cache_state = BTRFS_DC_CLEAR;
4661
4662		cache->dirty = 1;
4663		old_val = btrfs_block_group_used(&cache->item);
4664		num_bytes = min(total, cache->key.offset - byte_in_group);
4665		if (alloc) {
4666			old_val += num_bytes;
4667			btrfs_set_block_group_used(&cache->item, old_val);
4668			cache->reserved -= num_bytes;
4669			cache->space_info->bytes_reserved -= num_bytes;
4670			cache->space_info->bytes_used += num_bytes;
4671			cache->space_info->disk_used += num_bytes * factor;
4672			spin_unlock(&cache->lock);
4673			spin_unlock(&cache->space_info->lock);
4674		} else {
4675			old_val -= num_bytes;
4676			btrfs_set_block_group_used(&cache->item, old_val);
4677			cache->pinned += num_bytes;
4678			cache->space_info->bytes_pinned += num_bytes;
4679			cache->space_info->bytes_used -= num_bytes;
4680			cache->space_info->disk_used -= num_bytes * factor;
4681			spin_unlock(&cache->lock);
4682			spin_unlock(&cache->space_info->lock);
4683
4684			set_extent_dirty(info->pinned_extents,
4685					 bytenr, bytenr + num_bytes - 1,
4686					 GFP_NOFS | __GFP_NOFAIL);
4687		}
4688		btrfs_put_block_group(cache);
4689		total -= num_bytes;
4690		bytenr += num_bytes;
4691	}
4692	return 0;
4693}
4694
4695static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
4696{
4697	struct btrfs_block_group_cache *cache;
4698	u64 bytenr;
4699
4700	cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
4701	if (!cache)
4702		return 0;
4703
4704	bytenr = cache->key.objectid;
4705	btrfs_put_block_group(cache);
 
 
 
 
 
 
 
 
 
 
 
4706
4707	return bytenr;
4708}
 
 
 
 
 
 
 
4709
4710static int pin_down_extent(struct btrfs_root *root,
4711			   struct btrfs_block_group_cache *cache,
4712			   u64 bytenr, u64 num_bytes, int reserved)
4713{
4714	spin_lock(&cache->space_info->lock);
4715	spin_lock(&cache->lock);
4716	cache->pinned += num_bytes;
4717	cache->space_info->bytes_pinned += num_bytes;
4718	if (reserved) {
4719		cache->reserved -= num_bytes;
4720		cache->space_info->bytes_reserved -= num_bytes;
4721	}
4722	spin_unlock(&cache->lock);
4723	spin_unlock(&cache->space_info->lock);
4724
4725	set_extent_dirty(root->fs_info->pinned_extents, bytenr,
4726			 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);
4727	return 0;
4728}
 
 
 
 
 
 
 
 
 
 
4729
4730/*
4731 * this function must be called within transaction
4732 */
4733int btrfs_pin_extent(struct btrfs_root *root,
4734		     u64 bytenr, u64 num_bytes, int reserved)
4735{
4736	struct btrfs_block_group_cache *cache;
4737
4738	cache = btrfs_lookup_block_group(root->fs_info, bytenr);
4739	BUG_ON(!cache); /* Logic error */
4740
4741	pin_down_extent(root, cache, bytenr, num_bytes, reserved);
4742
4743	btrfs_put_block_group(cache);
4744	return 0;
4745}
 
 
 
 
 
 
 
 
 
 
 
 
4746
4747/*
4748 * this function must be called within transaction
4749 */
4750int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
4751				    struct btrfs_root *root,
4752				    u64 bytenr, u64 num_bytes)
4753{
4754	struct btrfs_block_group_cache *cache;
4755
4756	cache = btrfs_lookup_block_group(root->fs_info, bytenr);
4757	BUG_ON(!cache); /* Logic error */
4758
4759	/*
4760	 * pull in the free space cache (if any) so that our pin
4761	 * removes the free space from the cache.  We have load_only set
4762	 * to one because the slow code to read in the free extents does check
4763	 * the pinned extents.
4764	 */
4765	cache_block_group(cache, trans, root, 1);
4766
4767	pin_down_extent(root, cache, bytenr, num_bytes, 0);
4768
4769	/* remove us from the free space cache (if we're there at all) */
4770	btrfs_remove_free_space(cache, bytenr, num_bytes);
4771	btrfs_put_block_group(cache);
4772	return 0;
4773}
4774
4775/**
4776 * btrfs_update_reserved_bytes - update the block_group and space info counters
4777 * @cache:	The cache we are manipulating
4778 * @num_bytes:	The number of bytes in question
4779 * @reserve:	One of the reservation enums
4780 *
4781 * This is called by the allocator when it reserves space, or by somebody who is
4782 * freeing space that was never actually used on disk.  For example if you
4783 * reserve some space for a new leaf in transaction A and before transaction A
4784 * commits you free that leaf, you call this with reserve set to 0 in order to
4785 * clear the reservation.
4786 *
4787 * Metadata reservations should be called with RESERVE_ALLOC so we do the proper
4788 * ENOSPC accounting.  For data we handle the reservation through clearing the
4789 * delalloc bits in the io_tree.  We have to do this since we could end up
4790 * allocating less disk space for the amount of data we have reserved in the
4791 * case of compression.
4792 *
4793 * If this is a reservation and the block group has become read only we cannot
4794 * make the reservation and return -EAGAIN, otherwise this function always
4795 * succeeds.
4796 */
4797static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
4798				       u64 num_bytes, int reserve)
4799{
4800	struct btrfs_space_info *space_info = cache->space_info;
4801	int ret = 0;
4802
4803	spin_lock(&space_info->lock);
4804	spin_lock(&cache->lock);
4805	if (reserve != RESERVE_FREE) {
4806		if (cache->ro) {
4807			ret = -EAGAIN;
4808		} else {
4809			cache->reserved += num_bytes;
4810			space_info->bytes_reserved += num_bytes;
4811			if (reserve == RESERVE_ALLOC) {
4812				trace_btrfs_space_reservation(cache->fs_info,
4813						"space_info", space_info->flags,
4814						num_bytes, 0);
4815				space_info->bytes_may_use -= num_bytes;
4816			}
4817		}
4818	} else {
4819		if (cache->ro)
4820			space_info->bytes_readonly += num_bytes;
4821		cache->reserved -= num_bytes;
4822		space_info->bytes_reserved -= num_bytes;
4823		space_info->reservation_progress++;
4824	}
4825	spin_unlock(&cache->lock);
4826	spin_unlock(&space_info->lock);
4827	return ret;
4828}
4829
4830void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
4831				struct btrfs_root *root)
4832{
4833	struct btrfs_fs_info *fs_info = root->fs_info;
4834	struct btrfs_caching_control *next;
4835	struct btrfs_caching_control *caching_ctl;
4836	struct btrfs_block_group_cache *cache;
4837
4838	down_write(&fs_info->extent_commit_sem);
4839
4840	list_for_each_entry_safe(caching_ctl, next,
4841				 &fs_info->caching_block_groups, list) {
4842		cache = caching_ctl->block_group;
4843		if (block_group_cache_done(cache)) {
4844			cache->last_byte_to_unpin = (u64)-1;
4845			list_del_init(&caching_ctl->list);
4846			put_caching_control(caching_ctl);
4847		} else {
4848			cache->last_byte_to_unpin = caching_ctl->progress;
4849		}
4850	}
4851
4852	if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4853		fs_info->pinned_extents = &fs_info->freed_extents[1];
4854	else
4855		fs_info->pinned_extents = &fs_info->freed_extents[0];
4856
4857	up_write(&fs_info->extent_commit_sem);
4858
4859	update_global_block_rsv(fs_info);
4860}
4861
4862static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
4863{
4864	struct btrfs_fs_info *fs_info = root->fs_info;
4865	struct btrfs_block_group_cache *cache = NULL;
4866	u64 len;
4867
4868	while (start <= end) {
4869		if (!cache ||
4870		    start >= cache->key.objectid + cache->key.offset) {
4871			if (cache)
4872				btrfs_put_block_group(cache);
4873			cache = btrfs_lookup_block_group(fs_info, start);
4874			BUG_ON(!cache); /* Logic error */
4875		}
4876
4877		len = cache->key.objectid + cache->key.offset - start;
4878		len = min(len, end + 1 - start);
4879
4880		if (start < cache->last_byte_to_unpin) {
4881			len = min(len, cache->last_byte_to_unpin - start);
4882			btrfs_add_free_space(cache, start, len);
4883		}
4884
4885		start += len;
4886
4887		spin_lock(&cache->space_info->lock);
4888		spin_lock(&cache->lock);
4889		cache->pinned -= len;
4890		cache->space_info->bytes_pinned -= len;
4891		if (cache->ro)
4892			cache->space_info->bytes_readonly += len;
4893		spin_unlock(&cache->lock);
4894		spin_unlock(&cache->space_info->lock);
4895	}
4896
4897	if (cache)
4898		btrfs_put_block_group(cache);
4899	return 0;
4900}
4901
4902int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
4903			       struct btrfs_root *root)
4904{
4905	struct btrfs_fs_info *fs_info = root->fs_info;
4906	struct extent_io_tree *unpin;
4907	u64 start;
4908	u64 end;
4909	int ret;
4910
4911	if (trans->aborted)
4912		return 0;
4913
4914	if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4915		unpin = &fs_info->freed_extents[1];
4916	else
4917		unpin = &fs_info->freed_extents[0];
4918
4919	while (1) {
4920		ret = find_first_extent_bit(unpin, 0, &start, &end,
4921					    EXTENT_DIRTY);
4922		if (ret)
4923			break;
4924
4925		if (btrfs_test_opt(root, DISCARD))
4926			ret = btrfs_discard_extent(root, start,
4927						   end + 1 - start, NULL);
4928
4929		clear_extent_dirty(unpin, start, end, GFP_NOFS);
4930		unpin_extent_range(root, start, end);
4931		cond_resched();
4932	}
4933
4934	return 0;
4935}
4936
4937static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
4938				struct btrfs_root *root,
4939				u64 bytenr, u64 num_bytes, u64 parent,
4940				u64 root_objectid, u64 owner_objectid,
4941				u64 owner_offset, int refs_to_drop,
4942				struct btrfs_delayed_extent_op *extent_op)
4943{
4944	struct btrfs_key key;
4945	struct btrfs_path *path;
4946	struct btrfs_fs_info *info = root->fs_info;
4947	struct btrfs_root *extent_root = info->extent_root;
4948	struct extent_buffer *leaf;
4949	struct btrfs_extent_item *ei;
4950	struct btrfs_extent_inline_ref *iref;
4951	int ret;
4952	int is_data;
4953	int extent_slot = 0;
4954	int found_extent = 0;
4955	int num_to_del = 1;
4956	u32 item_size;
4957	u64 refs;
4958
4959	path = btrfs_alloc_path();
4960	if (!path)
4961		return -ENOMEM;
4962
4963	path->reada = 1;
4964	path->leave_spinning = 1;
4965
4966	is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
4967	BUG_ON(!is_data && refs_to_drop != 1);
4968
4969	ret = lookup_extent_backref(trans, extent_root, path, &iref,
4970				    bytenr, num_bytes, parent,
4971				    root_objectid, owner_objectid,
4972				    owner_offset);
4973	if (ret == 0) {
4974		extent_slot = path->slots[0];
4975		while (extent_slot >= 0) {
4976			btrfs_item_key_to_cpu(path->nodes[0], &key,
4977					      extent_slot);
4978			if (key.objectid != bytenr)
4979				break;
4980			if (key.type == BTRFS_EXTENT_ITEM_KEY &&
4981			    key.offset == num_bytes) {
4982				found_extent = 1;
4983				break;
4984			}
4985			if (path->slots[0] - extent_slot > 5)
4986				break;
4987			extent_slot--;
4988		}
4989#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
4990		item_size = btrfs_item_size_nr(path->nodes[0], extent_slot);
4991		if (found_extent && item_size < sizeof(*ei))
4992			found_extent = 0;
4993#endif
4994		if (!found_extent) {
4995			BUG_ON(iref);
4996			ret = remove_extent_backref(trans, extent_root, path,
4997						    NULL, refs_to_drop,
4998						    is_data);
4999			if (ret)
5000				goto abort;
5001			btrfs_release_path(path);
5002			path->leave_spinning = 1;
5003
5004			key.objectid = bytenr;
5005			key.type = BTRFS_EXTENT_ITEM_KEY;
5006			key.offset = num_bytes;
5007
5008			ret = btrfs_search_slot(trans, extent_root,
5009						&key, path, -1, 1);
5010			if (ret) {
5011				printk(KERN_ERR "umm, got %d back from search"
5012				       ", was looking for %llu\n", ret,
5013				       (unsigned long long)bytenr);
5014				if (ret > 0)
5015					btrfs_print_leaf(extent_root,
5016							 path->nodes[0]);
5017			}
5018			if (ret < 0)
5019				goto abort;
5020			extent_slot = path->slots[0];
5021		}
5022	} else if (ret == -ENOENT) {
5023		btrfs_print_leaf(extent_root, path->nodes[0]);
5024		WARN_ON(1);
5025		printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
5026		       "parent %llu root %llu  owner %llu offset %llu\n",
5027		       (unsigned long long)bytenr,
5028		       (unsigned long long)parent,
5029		       (unsigned long long)root_objectid,
5030		       (unsigned long long)owner_objectid,
5031		       (unsigned long long)owner_offset);
5032	} else {
5033		goto abort;
5034	}
5035
5036	leaf = path->nodes[0];
5037	item_size = btrfs_item_size_nr(leaf, extent_slot);
5038#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5039	if (item_size < sizeof(*ei)) {
5040		BUG_ON(found_extent || extent_slot != path->slots[0]);
5041		ret = convert_extent_item_v0(trans, extent_root, path,
5042					     owner_objectid, 0);
5043		if (ret < 0)
5044			goto abort;
5045
5046		btrfs_release_path(path);
5047		path->leave_spinning = 1;
5048
5049		key.objectid = bytenr;
5050		key.type = BTRFS_EXTENT_ITEM_KEY;
5051		key.offset = num_bytes;
5052
5053		ret = btrfs_search_slot(trans, extent_root, &key, path,
5054					-1, 1);
5055		if (ret) {
5056			printk(KERN_ERR "umm, got %d back from search"
5057			       ", was looking for %llu\n", ret,
5058			       (unsigned long long)bytenr);
5059			btrfs_print_leaf(extent_root, path->nodes[0]);
5060		}
5061		if (ret < 0)
5062			goto abort;
5063		extent_slot = path->slots[0];
5064		leaf = path->nodes[0];
5065		item_size = btrfs_item_size_nr(leaf, extent_slot);
5066	}
5067#endif
5068	BUG_ON(item_size < sizeof(*ei));
5069	ei = btrfs_item_ptr(leaf, extent_slot,
5070			    struct btrfs_extent_item);
5071	if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID) {
5072		struct btrfs_tree_block_info *bi;
5073		BUG_ON(item_size < sizeof(*ei) + sizeof(*bi));
5074		bi = (struct btrfs_tree_block_info *)(ei + 1);
5075		WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
5076	}
5077
5078	refs = btrfs_extent_refs(leaf, ei);
5079	BUG_ON(refs < refs_to_drop);
5080	refs -= refs_to_drop;
5081
5082	if (refs > 0) {
5083		if (extent_op)
5084			__run_delayed_extent_op(extent_op, leaf, ei);
5085		/*
5086		 * In the case of inline back ref, reference count will
5087		 * be updated by remove_extent_backref
5088		 */
5089		if (iref) {
5090			BUG_ON(!found_extent);
5091		} else {
5092			btrfs_set_extent_refs(leaf, ei, refs);
5093			btrfs_mark_buffer_dirty(leaf);
5094		}
5095		if (found_extent) {
5096			ret = remove_extent_backref(trans, extent_root, path,
5097						    iref, refs_to_drop,
5098						    is_data);
5099			if (ret)
5100				goto abort;
5101		}
5102	} else {
5103		if (found_extent) {
5104			BUG_ON(is_data && refs_to_drop !=
5105			       extent_data_ref_count(root, path, iref));
5106			if (iref) {
5107				BUG_ON(path->slots[0] != extent_slot);
5108			} else {
5109				BUG_ON(path->slots[0] != extent_slot + 1);
5110				path->slots[0] = extent_slot;
5111				num_to_del = 2;
5112			}
5113		}
5114
5115		ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
5116				      num_to_del);
5117		if (ret)
5118			goto abort;
5119		btrfs_release_path(path);
5120
5121		if (is_data) {
5122			ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
5123			if (ret)
5124				goto abort;
5125		}
5126
5127		ret = update_block_group(trans, root, bytenr, num_bytes, 0);
5128		if (ret)
5129			goto abort;
5130	}
5131out:
5132	btrfs_free_path(path);
5133	return ret;
5134
5135abort:
5136	btrfs_abort_transaction(trans, extent_root, ret);
5137	goto out;
5138}
5139
5140/*
5141 * when we free an block, it is possible (and likely) that we free the last
5142 * delayed ref for that extent as well.  This searches the delayed ref tree for
5143 * a given extent, and if there are no other delayed refs to be processed, it
5144 * removes it from the tree.
5145 */
5146static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
5147				      struct btrfs_root *root, u64 bytenr)
5148{
5149	struct btrfs_delayed_ref_head *head;
5150	struct btrfs_delayed_ref_root *delayed_refs;
5151	struct btrfs_delayed_ref_node *ref;
5152	struct rb_node *node;
5153	int ret = 0;
5154
5155	delayed_refs = &trans->transaction->delayed_refs;
5156	spin_lock(&delayed_refs->lock);
5157	head = btrfs_find_delayed_ref_head(trans, bytenr);
5158	if (!head)
5159		goto out;
5160
5161	node = rb_prev(&head->node.rb_node);
5162	if (!node)
5163		goto out;
 
 
 
 
 
 
5164
5165	ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
5166
5167	/* there are still entries for this ref, we can't drop it */
5168	if (ref->bytenr == bytenr)
5169		goto out;
5170
5171	if (head->extent_op) {
5172		if (!head->must_insert_reserved)
5173			goto out;
5174		kfree(head->extent_op);
5175		head->extent_op = NULL;
5176	}
5177
5178	/*
5179	 * waiting for the lock here would deadlock.  If someone else has it
5180	 * locked they are already in the process of dropping it anyway
 
5181	 */
5182	if (!mutex_trylock(&head->mutex))
5183		goto out;
5184
5185	/*
5186	 * at this point we have a head with no other entries.  Go
5187	 * ahead and process it.
 
 
 
5188	 */
5189	head->node.in_tree = 0;
5190	rb_erase(&head->node.rb_node, &delayed_refs->root);
5191
5192	delayed_refs->num_entries--;
5193	if (waitqueue_active(&delayed_refs->seq_wait))
5194		wake_up(&delayed_refs->seq_wait);
5195
5196	/*
5197	 * we don't take a ref on the node because we're removing it from the
5198	 * tree, so we just steal the ref the tree was holding.
 
5199	 */
5200	delayed_refs->num_heads--;
5201	if (list_empty(&head->cluster))
5202		delayed_refs->num_heads_ready--;
5203
5204	list_del_init(&head->cluster);
5205	spin_unlock(&delayed_refs->lock);
5206
5207	BUG_ON(head->extent_op);
5208	if (head->must_insert_reserved)
5209		ret = 1;
5210
5211	mutex_unlock(&head->mutex);
5212	btrfs_put_delayed_ref(&head->node);
5213	return ret;
5214out:
5215	spin_unlock(&delayed_refs->lock);
5216	return 0;
5217}
5218
5219void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
5220			   struct btrfs_root *root,
5221			   struct extent_buffer *buf,
5222			   u64 parent, int last_ref)
 
 
 
 
 
5223{
5224	struct btrfs_block_group_cache *cache = NULL;
5225	int ret;
5226
5227	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
5228		ret = btrfs_add_delayed_tree_ref(root->fs_info, trans,
5229					buf->start, buf->len,
5230					parent, root->root_key.objectid,
5231					btrfs_header_level(buf),
5232					BTRFS_DROP_DELAYED_REF, NULL, 0);
5233		BUG_ON(ret); /* -ENOMEM */
5234	}
5235
5236	if (!last_ref)
5237		return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5238
5239	cache = btrfs_lookup_block_group(root->fs_info, buf->start);
 
 
 
 
5240
5241	if (btrfs_header_generation(buf) == trans->transid) {
5242		if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
5243			ret = check_ref_cleanup(trans, root, buf->start);
5244			if (!ret)
5245				goto out;
5246		}
 
5247
5248		if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
5249			pin_down_extent(root, cache, buf->start, buf->len, 1);
5250			goto out;
 
 
 
 
 
 
 
 
 
 
5251		}
5252
5253		WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
 
 
5254
5255		btrfs_add_free_space(cache, buf->start, buf->len);
5256		btrfs_update_reserved_bytes(cache, buf->len, RESERVE_FREE);
 
 
 
 
 
 
 
 
 
5257	}
5258out:
5259	/*
5260	 * Deleting the buffer, clear the corrupt flag since it doesn't matter
5261	 * anymore.
5262	 */
5263	clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);
5264	btrfs_put_block_group(cache);
5265}
5266
5267/* Can return -ENOMEM */
5268int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root,
5269		      u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
5270		      u64 owner, u64 offset, int for_cow)
5271{
5272	int ret;
5273	struct btrfs_fs_info *fs_info = root->fs_info;
5274
5275	/*
5276	 * tree log blocks never actually go into the extent allocation
5277	 * tree, just update pinning info and exit early.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5278	 */
5279	if (root_objectid == BTRFS_TREE_LOG_OBJECTID) {
5280		WARN_ON(owner >= BTRFS_FIRST_FREE_OBJECTID);
5281		/* unlocks the pinned mutex */
5282		btrfs_pin_extent(root, bytenr, num_bytes, 1);
5283		ret = 0;
5284	} else if (owner < BTRFS_FIRST_FREE_OBJECTID) {
5285		ret = btrfs_add_delayed_tree_ref(fs_info, trans, bytenr,
5286					num_bytes,
5287					parent, root_objectid, (int)owner,
5288					BTRFS_DROP_DELAYED_REF, NULL, for_cow);
5289	} else {
5290		ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr,
5291						num_bytes,
5292						parent, root_objectid, owner,
5293						offset, BTRFS_DROP_DELAYED_REF,
5294						NULL, for_cow);
5295	}
5296	return ret;
5297}
5298
5299static u64 stripe_align(struct btrfs_root *root, u64 val)
5300{
5301	u64 mask = ((u64)root->stripesize - 1);
5302	u64 ret = (val + mask) & ~mask;
5303	return ret;
5304}
5305
5306/*
5307 * when we wait for progress in the block group caching, its because
5308 * our allocation attempt failed at least once.  So, we must sleep
5309 * and let some progress happen before we try again.
5310 *
5311 * This function will sleep at least once waiting for new free space to
5312 * show up, and then it will check the block group free space numbers
5313 * for our min num_bytes.  Another option is to have it go ahead
5314 * and look in the rbtree for a free extent of a given size, but this
5315 * is a good start.
5316 */
5317static noinline int
5318wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
5319				u64 num_bytes)
5320{
5321	struct btrfs_caching_control *caching_ctl;
5322	DEFINE_WAIT(wait);
5323
5324	caching_ctl = get_caching_control(cache);
5325	if (!caching_ctl)
5326		return 0;
5327
5328	wait_event(caching_ctl->wait, block_group_cache_done(cache) ||
5329		   (cache->free_space_ctl->free_space >= num_bytes));
5330
5331	put_caching_control(caching_ctl);
5332	return 0;
5333}
5334
5335static noinline int
5336wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
5337{
5338	struct btrfs_caching_control *caching_ctl;
5339	DEFINE_WAIT(wait);
 
 
 
 
 
 
 
 
 
 
5340
5341	caching_ctl = get_caching_control(cache);
5342	if (!caching_ctl)
5343		return 0;
 
 
 
 
5344
5345	wait_event(caching_ctl->wait, block_group_cache_done(cache));
 
 
 
 
 
 
 
5346
5347	put_caching_control(caching_ctl);
5348	return 0;
5349}
5350
5351static int __get_block_group_index(u64 flags)
5352{
5353	int index;
5354
5355	if (flags & BTRFS_BLOCK_GROUP_RAID10)
5356		index = 0;
5357	else if (flags & BTRFS_BLOCK_GROUP_RAID1)
5358		index = 1;
5359	else if (flags & BTRFS_BLOCK_GROUP_DUP)
5360		index = 2;
5361	else if (flags & BTRFS_BLOCK_GROUP_RAID0)
5362		index = 3;
5363	else
5364		index = 4;
5365
5366	return index;
5367}
5368
5369static int get_block_group_index(struct btrfs_block_group_cache *cache)
5370{
5371	return __get_block_group_index(cache->flags);
5372}
5373
5374enum btrfs_loop_type {
5375	LOOP_CACHING_NOWAIT = 0,
5376	LOOP_CACHING_WAIT = 1,
5377	LOOP_ALLOC_CHUNK = 2,
5378	LOOP_NO_EMPTY_SIZE = 3,
5379};
5380
5381/*
5382 * walks the btree of allocated extents and find a hole of a given size.
5383 * The key ins is changed to record the hole:
5384 * ins->objectid == block start
5385 * ins->flags = BTRFS_EXTENT_ITEM_KEY
5386 * ins->offset == number of blocks
5387 * Any available blocks before search_start are skipped.
5388 */
5389static noinline int find_free_extent(struct btrfs_trans_handle *trans,
5390				     struct btrfs_root *orig_root,
5391				     u64 num_bytes, u64 empty_size,
5392				     u64 hint_byte, struct btrfs_key *ins,
5393				     u64 data)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5394{
 
5395	int ret = 0;
5396	struct btrfs_root *root = orig_root->fs_info->extent_root;
5397	struct btrfs_free_cluster *last_ptr = NULL;
5398	struct btrfs_block_group_cache *block_group = NULL;
5399	struct btrfs_block_group_cache *used_block_group;
5400	u64 search_start = 0;
5401	int empty_cluster = 2 * 1024 * 1024;
5402	int allowed_chunk_alloc = 0;
5403	int done_chunk_alloc = 0;
5404	struct btrfs_space_info *space_info;
5405	int loop = 0;
5406	int index = 0;
5407	int alloc_type = (data & BTRFS_BLOCK_GROUP_DATA) ?
5408		RESERVE_ALLOC_NO_ACCOUNT : RESERVE_ALLOC;
5409	bool found_uncached_bg = false;
5410	bool failed_cluster_refill = false;
5411	bool failed_alloc = false;
5412	bool use_cluster = true;
5413	bool have_caching_bg = false;
 
 
 
 
 
 
 
 
 
 
 
5414
5415	WARN_ON(num_bytes < root->sectorsize);
5416	btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
 
 
5417	ins->objectid = 0;
5418	ins->offset = 0;
5419
5420	trace_find_free_extent(orig_root, num_bytes, empty_size, data);
5421
5422	space_info = __find_space_info(root->fs_info, data);
5423	if (!space_info) {
5424		printk(KERN_ERR "No space info for %llu\n", data);
5425		return -ENOSPC;
5426	}
5427
5428	/*
5429	 * If the space info is for both data and metadata it means we have a
5430	 * small filesystem and we can't use the clustering stuff.
5431	 */
5432	if (btrfs_mixed_space_info(space_info))
5433		use_cluster = false;
5434
5435	if (orig_root->ref_cows || empty_size)
5436		allowed_chunk_alloc = 1;
5437
5438	if (data & BTRFS_BLOCK_GROUP_METADATA && use_cluster) {
5439		last_ptr = &root->fs_info->meta_alloc_cluster;
5440		if (!btrfs_test_opt(root, SSD))
5441			empty_cluster = 64 * 1024;
5442	}
5443
5444	if ((data & BTRFS_BLOCK_GROUP_DATA) && use_cluster &&
5445	    btrfs_test_opt(root, SSD)) {
5446		last_ptr = &root->fs_info->data_alloc_cluster;
5447	}
5448
5449	if (last_ptr) {
5450		spin_lock(&last_ptr->lock);
5451		if (last_ptr->block_group)
5452			hint_byte = last_ptr->window_start;
5453		spin_unlock(&last_ptr->lock);
5454	}
5455
5456	search_start = max(search_start, first_logical_byte(root, 0));
5457	search_start = max(search_start, hint_byte);
5458
5459	if (!last_ptr)
5460		empty_cluster = 0;
5461
5462	if (search_start == hint_byte) {
5463		block_group = btrfs_lookup_block_group(root->fs_info,
5464						       search_start);
5465		used_block_group = block_group;
5466		/*
5467		 * we don't want to use the block group if it doesn't match our
5468		 * allocation bits, or if its not cached.
5469		 *
5470		 * However if we are re-searching with an ideal block group
5471		 * picked out then we don't care that the block group is cached.
5472		 */
5473		if (block_group && block_group_bits(block_group, data) &&
5474		    block_group->cached != BTRFS_CACHE_NO) {
5475			down_read(&space_info->groups_sem);
5476			if (list_empty(&block_group->list) ||
5477			    block_group->ro) {
5478				/*
5479				 * someone is removing this block group,
5480				 * we can't jump into the have_block_group
5481				 * target because our list pointers are not
5482				 * valid
5483				 */
5484				btrfs_put_block_group(block_group);
5485				up_read(&space_info->groups_sem);
5486			} else {
5487				index = get_block_group_index(block_group);
 
 
 
 
5488				goto have_block_group;
5489			}
5490		} else if (block_group) {
5491			btrfs_put_block_group(block_group);
5492		}
5493	}
5494search:
5495	have_caching_bg = false;
 
 
 
 
5496	down_read(&space_info->groups_sem);
5497	list_for_each_entry(block_group, &space_info->block_groups[index],
5498			    list) {
5499		u64 offset;
5500		int cached;
5501
5502		used_block_group = block_group;
5503		btrfs_get_block_group(block_group);
5504		search_start = block_group->key.objectid;
 
 
 
 
 
 
 
 
5505
5506		/*
5507		 * this can happen if we end up cycling through all the
5508		 * raid types, but we want to make sure we only allocate
5509		 * for the proper type.
5510		 */
5511		if (!block_group_bits(block_group, data)) {
5512		    u64 extra = BTRFS_BLOCK_GROUP_DUP |
5513				BTRFS_BLOCK_GROUP_RAID1 |
 
5514				BTRFS_BLOCK_GROUP_RAID10;
5515
5516			/*
5517			 * if they asked for extra copies and this block group
5518			 * doesn't provide them, bail.  This does allow us to
5519			 * fill raid0 from raid1.
5520			 */
5521			if ((data & extra) && !(block_group->flags & extra))
5522				goto loop;
 
 
 
 
 
 
 
 
5523		}
5524
5525have_block_group:
5526		cached = block_group_cache_done(block_group);
5527		if (unlikely(!cached)) {
5528			found_uncached_bg = true;
5529			ret = cache_block_group(block_group, trans,
5530						orig_root, 0);
5531			BUG_ON(ret < 0);
5532			ret = 0;
5533		}
5534
5535		if (unlikely(block_group->ro))
5536			goto loop;
5537
5538		/*
5539		 * Ok we want to try and use the cluster allocator, so
5540		 * lets look there
5541		 */
5542		if (last_ptr) {
5543			/*
5544			 * the refill lock keeps out other
5545			 * people trying to start a new cluster
 
 
 
5546			 */
5547			spin_lock(&last_ptr->refill_lock);
5548			used_block_group = last_ptr->block_group;
5549			if (used_block_group != block_group &&
5550			    (!used_block_group ||
5551			     used_block_group->ro ||
5552			     !block_group_bits(used_block_group, data))) {
5553				used_block_group = block_group;
5554				goto refill_cluster;
5555			}
5556
5557			if (used_block_group != block_group)
5558				btrfs_get_block_group(used_block_group);
5559
5560			offset = btrfs_alloc_from_cluster(used_block_group,
5561			  last_ptr, num_bytes, used_block_group->key.objectid);
5562			if (offset) {
5563				/* we have a block, we're done */
5564				spin_unlock(&last_ptr->refill_lock);
5565				trace_btrfs_reserve_extent_cluster(root,
5566					block_group, search_start, num_bytes);
5567				goto checks;
5568			}
5569
5570			WARN_ON(last_ptr->block_group != used_block_group);
5571			if (used_block_group != block_group) {
5572				btrfs_put_block_group(used_block_group);
5573				used_block_group = block_group;
5574			}
5575refill_cluster:
5576			BUG_ON(used_block_group != block_group);
5577			/* If we are on LOOP_NO_EMPTY_SIZE, we can't
5578			 * set up a new clusters, so lets just skip it
5579			 * and let the allocator find whatever block
5580			 * it can find.  If we reach this point, we
5581			 * will have tried the cluster allocator
5582			 * plenty of times and not have found
5583			 * anything, so we are likely way too
5584			 * fragmented for the clustering stuff to find
5585			 * anything.
5586			 *
5587			 * However, if the cluster is taken from the
5588			 * current block group, release the cluster
5589			 * first, so that we stand a better chance of
5590			 * succeeding in the unclustered
5591			 * allocation.  */
5592			if (loop >= LOOP_NO_EMPTY_SIZE &&
5593			    last_ptr->block_group != block_group) {
5594				spin_unlock(&last_ptr->refill_lock);
5595				goto unclustered_alloc;
5596			}
5597
5598			/*
5599			 * this cluster didn't work out, free it and
5600			 * start over
5601			 */
5602			btrfs_return_cluster_to_free_space(NULL, last_ptr);
5603
5604			if (loop >= LOOP_NO_EMPTY_SIZE) {
5605				spin_unlock(&last_ptr->refill_lock);
5606				goto unclustered_alloc;
5607			}
 
 
5608
5609			/* allocate a cluster in this block group */
5610			ret = btrfs_find_space_cluster(trans, root,
5611					       block_group, last_ptr,
5612					       search_start, num_bytes,
5613					       empty_cluster + empty_size);
5614			if (ret == 0) {
5615				/*
5616				 * now pull our allocation out of this
5617				 * cluster
5618				 */
5619				offset = btrfs_alloc_from_cluster(block_group,
5620						  last_ptr, num_bytes,
5621						  search_start);
5622				if (offset) {
5623					/* we found one, proceed */
5624					spin_unlock(&last_ptr->refill_lock);
5625					trace_btrfs_reserve_extent_cluster(root,
5626						block_group, search_start,
5627						num_bytes);
5628					goto checks;
5629				}
5630			} else if (!cached && loop > LOOP_CACHING_NOWAIT
5631				   && !failed_cluster_refill) {
5632				spin_unlock(&last_ptr->refill_lock);
5633
5634				failed_cluster_refill = true;
5635				wait_block_group_cache_progress(block_group,
5636				       num_bytes + empty_cluster + empty_size);
5637				goto have_block_group;
5638			}
5639
5640			/*
5641			 * at this point we either didn't find a cluster
5642			 * or we weren't able to allocate a block from our
5643			 * cluster.  Free the cluster we've been trying
5644			 * to use, and go to the next block group
5645			 */
5646			btrfs_return_cluster_to_free_space(NULL, last_ptr);
5647			spin_unlock(&last_ptr->refill_lock);
5648			goto loop;
5649		}
5650
5651unclustered_alloc:
5652		spin_lock(&block_group->free_space_ctl->tree_lock);
5653		if (cached &&
5654		    block_group->free_space_ctl->free_space <
5655		    num_bytes + empty_cluster + empty_size) {
5656			spin_unlock(&block_group->free_space_ctl->tree_lock);
5657			goto loop;
5658		}
5659		spin_unlock(&block_group->free_space_ctl->tree_lock);
5660
5661		offset = btrfs_find_space_for_alloc(block_group, search_start,
5662						    num_bytes, empty_size);
5663		/*
5664		 * If we didn't find a chunk, and we haven't failed on this
5665		 * block group before, and this block group is in the middle of
5666		 * caching and we are ok with waiting, then go ahead and wait
5667		 * for progress to be made, and set failed_alloc to true.
5668		 *
5669		 * If failed_alloc is true then we've already waited on this
5670		 * block group once and should move on to the next block group.
5671		 */
5672		if (!offset && !failed_alloc && !cached &&
5673		    loop > LOOP_CACHING_NOWAIT) {
5674			wait_block_group_cache_progress(block_group,
5675						num_bytes + empty_size);
5676			failed_alloc = true;
5677			goto have_block_group;
5678		} else if (!offset) {
5679			if (!cached)
5680				have_caching_bg = true;
5681			goto loop;
 
 
 
 
5682		}
5683checks:
5684		search_start = stripe_align(root, offset);
 
 
5685
5686		/* move on to the next group */
5687		if (search_start + num_bytes >
5688		    used_block_group->key.objectid + used_block_group->key.offset) {
5689			btrfs_add_free_space(used_block_group, offset, num_bytes);
 
 
5690			goto loop;
5691		}
5692
5693		if (offset < search_start)
5694			btrfs_add_free_space(used_block_group, offset,
5695					     search_start - offset);
5696		BUG_ON(offset > search_start);
5697
5698		ret = btrfs_update_reserved_bytes(used_block_group, num_bytes,
5699						  alloc_type);
 
 
5700		if (ret == -EAGAIN) {
5701			btrfs_add_free_space(used_block_group, offset, num_bytes);
 
 
5702			goto loop;
5703		}
 
5704
5705		/* we are all good, lets return */
5706		ins->objectid = search_start;
5707		ins->offset = num_bytes;
5708
5709		trace_btrfs_reserve_extent(orig_root, block_group,
5710					   search_start, num_bytes);
5711		if (offset < search_start)
5712			btrfs_add_free_space(used_block_group, offset,
5713					     search_start - offset);
5714		BUG_ON(offset > search_start);
5715		if (used_block_group != block_group)
5716			btrfs_put_block_group(used_block_group);
5717		btrfs_put_block_group(block_group);
5718		break;
5719loop:
5720		failed_cluster_refill = false;
5721		failed_alloc = false;
5722		BUG_ON(index != get_block_group_index(block_group));
5723		if (used_block_group != block_group)
5724			btrfs_put_block_group(used_block_group);
5725		btrfs_put_block_group(block_group);
 
 
 
 
 
5726	}
5727	up_read(&space_info->groups_sem);
5728
5729	if (!ins->objectid && loop >= LOOP_CACHING_WAIT && have_caching_bg)
 
5730		goto search;
5731
5732	if (!ins->objectid && ++index < BTRFS_NR_RAID_TYPES)
5733		goto search;
5734
5735	/*
5736	 * LOOP_CACHING_NOWAIT, search partially cached block groups, kicking
5737	 *			caching kthreads as we move along
5738	 * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching
5739	 * LOOP_ALLOC_CHUNK, force a chunk allocation and try again
5740	 * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try
5741	 *			again
5742	 */
5743	if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE) {
5744		index = 0;
5745		loop++;
5746		if (loop == LOOP_ALLOC_CHUNK) {
5747		       if (allowed_chunk_alloc) {
5748				ret = do_chunk_alloc(trans, root, num_bytes +
5749						     2 * 1024 * 1024, data,
5750						     CHUNK_ALLOC_LIMITED);
5751				if (ret < 0) {
5752					btrfs_abort_transaction(trans,
5753								root, ret);
5754					goto out;
5755				}
5756				allowed_chunk_alloc = 0;
5757				if (ret == 1)
5758					done_chunk_alloc = 1;
5759			} else if (!done_chunk_alloc &&
5760				   space_info->force_alloc ==
5761				   CHUNK_ALLOC_NO_FORCE) {
5762				space_info->force_alloc = CHUNK_ALLOC_LIMITED;
5763			}
5764
5765		       /*
5766			* We didn't allocate a chunk, go ahead and drop the
5767			* empty size and loop again.
5768			*/
5769		       if (!done_chunk_alloc)
5770			       loop = LOOP_NO_EMPTY_SIZE;
5771		}
5772
5773		if (loop == LOOP_NO_EMPTY_SIZE) {
5774			empty_size = 0;
5775			empty_cluster = 0;
5776		}
5777
5778		goto search;
5779	} else if (!ins->objectid) {
5780		ret = -ENOSPC;
5781	} else if (ins->objectid) {
5782		ret = 0;
5783	}
5784out:
5785
5786	return ret;
5787}
5788
5789static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
5790			    int dump_block_groups)
5791{
5792	struct btrfs_block_group_cache *cache;
5793	int index = 0;
5794
5795	spin_lock(&info->lock);
5796	printk(KERN_INFO "space_info %llu has %llu free, is %sfull\n",
5797	       (unsigned long long)info->flags,
5798	       (unsigned long long)(info->total_bytes - info->bytes_used -
5799				    info->bytes_pinned - info->bytes_reserved -
5800				    info->bytes_readonly),
5801	       (info->full) ? "" : "not ");
5802	printk(KERN_INFO "space_info total=%llu, used=%llu, pinned=%llu, "
5803	       "reserved=%llu, may_use=%llu, readonly=%llu\n",
5804	       (unsigned long long)info->total_bytes,
5805	       (unsigned long long)info->bytes_used,
5806	       (unsigned long long)info->bytes_pinned,
5807	       (unsigned long long)info->bytes_reserved,
5808	       (unsigned long long)info->bytes_may_use,
5809	       (unsigned long long)info->bytes_readonly);
5810	spin_unlock(&info->lock);
5811
5812	if (!dump_block_groups)
5813		return;
5814
5815	down_read(&info->groups_sem);
5816again:
5817	list_for_each_entry(cache, &info->block_groups[index], list) {
5818		spin_lock(&cache->lock);
5819		printk(KERN_INFO "block group %llu has %llu bytes, %llu used "
5820		       "%llu pinned %llu reserved\n",
5821		       (unsigned long long)cache->key.objectid,
5822		       (unsigned long long)cache->key.offset,
5823		       (unsigned long long)btrfs_block_group_used(&cache->item),
5824		       (unsigned long long)cache->pinned,
5825		       (unsigned long long)cache->reserved);
5826		btrfs_dump_free_space(cache, bytes);
5827		spin_unlock(&cache->lock);
5828	}
5829	if (++index < BTRFS_NR_RAID_TYPES)
5830		goto again;
5831	up_read(&info->groups_sem);
5832}
5833
5834int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
5835			 struct btrfs_root *root,
5836			 u64 num_bytes, u64 min_alloc_size,
5837			 u64 empty_size, u64 hint_byte,
5838			 struct btrfs_key *ins, u64 data)
5839{
5840	bool final_tried = false;
 
 
 
5841	int ret;
 
 
5842
5843	data = btrfs_get_alloc_profile(root, data);
5844again:
5845	/*
5846	 * the only place that sets empty_size is btrfs_realloc_node, which
5847	 * is not called recursively on allocations
5848	 */
5849	if (empty_size || root->ref_cows) {
5850		ret = do_chunk_alloc(trans, root->fs_info->extent_root,
5851				     num_bytes + 2 * 1024 * 1024, data,
5852				     CHUNK_ALLOC_NO_FORCE);
5853		if (ret < 0 && ret != -ENOSPC) {
5854			btrfs_abort_transaction(trans, root, ret);
5855			return ret;
5856		}
5857	}
5858
5859	WARN_ON(num_bytes < root->sectorsize);
5860	ret = find_free_extent(trans, root, num_bytes, empty_size,
5861			       hint_byte, ins, data);
5862
5863	if (ret == -ENOSPC) {
5864		if (!final_tried) {
5865			num_bytes = num_bytes >> 1;
5866			num_bytes = num_bytes & ~(root->sectorsize - 1);
 
 
 
 
 
 
 
 
 
 
5867			num_bytes = max(num_bytes, min_alloc_size);
5868			ret = do_chunk_alloc(trans, root->fs_info->extent_root,
5869				       num_bytes, data, CHUNK_ALLOC_FORCE);
5870			if (ret < 0 && ret != -ENOSPC) {
5871				btrfs_abort_transaction(trans, root, ret);
5872				return ret;
5873			}
5874			if (num_bytes == min_alloc_size)
5875				final_tried = true;
5876			goto again;
5877		} else if (btrfs_test_opt(root, ENOSPC_DEBUG)) {
5878			struct btrfs_space_info *sinfo;
5879
5880			sinfo = __find_space_info(root->fs_info, data);
5881			printk(KERN_ERR "btrfs allocation failed flags %llu, "
5882			       "wanted %llu\n", (unsigned long long)data,
5883			       (unsigned long long)num_bytes);
5884			if (sinfo)
5885				dump_space_info(sinfo, num_bytes, 1);
 
5886		}
5887	}
5888
5889	trace_btrfs_reserved_extent_alloc(root, ins->objectid, ins->offset);
5890
5891	return ret;
5892}
5893
5894static int __btrfs_free_reserved_extent(struct btrfs_root *root,
5895					u64 start, u64 len, int pin)
5896{
5897	struct btrfs_block_group_cache *cache;
5898	int ret = 0;
5899
5900	cache = btrfs_lookup_block_group(root->fs_info, start);
5901	if (!cache) {
5902		printk(KERN_ERR "Unable to find block group for %llu\n",
5903		       (unsigned long long)start);
5904		return -ENOSPC;
5905	}
5906
5907	if (btrfs_test_opt(root, DISCARD))
5908		ret = btrfs_discard_extent(root, start, len, NULL);
 
5909
5910	if (pin)
5911		pin_down_extent(root, cache, start, len, 1);
5912	else {
5913		btrfs_add_free_space(cache, start, len);
5914		btrfs_update_reserved_bytes(cache, len, RESERVE_FREE);
5915	}
5916	btrfs_put_block_group(cache);
 
 
 
 
 
 
 
 
5917
5918	trace_btrfs_reserved_extent_free(root, start, len);
 
 
 
 
 
5919
 
 
5920	return ret;
5921}
5922
5923int btrfs_free_reserved_extent(struct btrfs_root *root,
5924					u64 start, u64 len)
5925{
5926	return __btrfs_free_reserved_extent(root, start, len, 0);
5927}
 
 
 
 
 
 
 
 
 
 
 
 
5928
5929int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
5930				       u64 start, u64 len)
5931{
5932	return __btrfs_free_reserved_extent(root, start, len, 1);
5933}
5934
5935static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
5936				      struct btrfs_root *root,
5937				      u64 parent, u64 root_objectid,
5938				      u64 flags, u64 owner, u64 offset,
5939				      struct btrfs_key *ins, int ref_mod)
5940{
 
 
5941	int ret;
5942	struct btrfs_fs_info *fs_info = root->fs_info;
5943	struct btrfs_extent_item *extent_item;
 
5944	struct btrfs_extent_inline_ref *iref;
5945	struct btrfs_path *path;
5946	struct extent_buffer *leaf;
5947	int type;
5948	u32 size;
 
5949
5950	if (parent > 0)
5951		type = BTRFS_SHARED_DATA_REF_KEY;
5952	else
5953		type = BTRFS_EXTENT_DATA_REF_KEY;
5954
5955	size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
 
 
 
5956
5957	path = btrfs_alloc_path();
5958	if (!path)
5959		return -ENOMEM;
5960
5961	path->leave_spinning = 1;
5962	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
5963				      ins, size);
5964	if (ret) {
5965		btrfs_free_path(path);
5966		return ret;
5967	}
5968
5969	leaf = path->nodes[0];
5970	extent_item = btrfs_item_ptr(leaf, path->slots[0],
5971				     struct btrfs_extent_item);
5972	btrfs_set_extent_refs(leaf, extent_item, ref_mod);
5973	btrfs_set_extent_generation(leaf, extent_item, trans->transid);
5974	btrfs_set_extent_flags(leaf, extent_item,
5975			       flags | BTRFS_EXTENT_FLAG_DATA);
5976
5977	iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
 
 
 
 
 
 
5978	btrfs_set_extent_inline_ref_type(leaf, iref, type);
 
5979	if (parent > 0) {
5980		struct btrfs_shared_data_ref *ref;
5981		ref = (struct btrfs_shared_data_ref *)(iref + 1);
5982		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
5983		btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
5984	} else {
5985		struct btrfs_extent_data_ref *ref;
5986		ref = (struct btrfs_extent_data_ref *)(&iref->offset);
5987		btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
5988		btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
5989		btrfs_set_extent_data_ref_offset(leaf, ref, offset);
5990		btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
5991	}
5992
5993	btrfs_mark_buffer_dirty(path->nodes[0]);
5994	btrfs_free_path(path);
5995
5996	ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
5997	if (ret) { /* -ENOENT, logic error */
5998		printk(KERN_ERR "btrfs update block group failed for %llu "
5999		       "%llu\n", (unsigned long long)ins->objectid,
6000		       (unsigned long long)ins->offset);
6001		BUG();
6002	}
6003	return ret;
6004}
6005
6006static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
6007				     struct btrfs_root *root,
6008				     u64 parent, u64 root_objectid,
6009				     u64 flags, struct btrfs_disk_key *key,
6010				     int level, struct btrfs_key *ins)
6011{
 
 
6012	int ret;
6013	struct btrfs_fs_info *fs_info = root->fs_info;
6014	struct btrfs_extent_item *extent_item;
 
6015	struct btrfs_tree_block_info *block_info;
6016	struct btrfs_extent_inline_ref *iref;
6017	struct btrfs_path *path;
6018	struct extent_buffer *leaf;
6019	u32 size = sizeof(*extent_item) + sizeof(*block_info) + sizeof(*iref);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6020
6021	path = btrfs_alloc_path();
6022	if (!path)
6023		return -ENOMEM;
6024
6025	path->leave_spinning = 1;
6026	ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
6027				      ins, size);
6028	if (ret) {
6029		btrfs_free_path(path);
6030		return ret;
6031	}
6032
6033	leaf = path->nodes[0];
6034	extent_item = btrfs_item_ptr(leaf, path->slots[0],
6035				     struct btrfs_extent_item);
6036	btrfs_set_extent_refs(leaf, extent_item, 1);
6037	btrfs_set_extent_generation(leaf, extent_item, trans->transid);
6038	btrfs_set_extent_flags(leaf, extent_item,
6039			       flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
6040	block_info = (struct btrfs_tree_block_info *)(extent_item + 1);
6041
6042	btrfs_set_tree_block_key(leaf, block_info, key);
6043	btrfs_set_tree_block_level(leaf, block_info, level);
 
 
 
 
 
 
6044
6045	iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
6046	if (parent > 0) {
6047		BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
6048		btrfs_set_extent_inline_ref_type(leaf, iref,
6049						 BTRFS_SHARED_BLOCK_REF_KEY);
6050		btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
6051	} else {
6052		btrfs_set_extent_inline_ref_type(leaf, iref,
6053						 BTRFS_TREE_BLOCK_REF_KEY);
6054		btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
6055	}
6056
6057	btrfs_mark_buffer_dirty(leaf);
6058	btrfs_free_path(path);
6059
6060	ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
6061	if (ret) { /* -ENOENT, logic error */
6062		printk(KERN_ERR "btrfs update block group failed for %llu "
6063		       "%llu\n", (unsigned long long)ins->objectid,
6064		       (unsigned long long)ins->offset);
6065		BUG();
6066	}
6067	return ret;
6068}
6069
6070int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
6071				     struct btrfs_root *root,
6072				     u64 root_objectid, u64 owner,
6073				     u64 offset, struct btrfs_key *ins)
6074{
6075	int ret;
 
 
6076
6077	BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);
6078
6079	ret = btrfs_add_delayed_data_ref(root->fs_info, trans, ins->objectid,
6080					 ins->offset, 0,
6081					 root_objectid, owner, offset,
6082					 BTRFS_ADD_DELAYED_EXTENT, NULL, 0);
6083	return ret;
 
 
 
 
 
6084}
6085
6086/*
6087 * this is used by the tree logging recovery code.  It records that
6088 * an extent has been allocated and makes sure to clear the free
6089 * space cache bits as well
6090 */
6091int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
6092				   struct btrfs_root *root,
6093				   u64 root_objectid, u64 owner, u64 offset,
6094				   struct btrfs_key *ins)
6095{
 
6096	int ret;
6097	struct btrfs_block_group_cache *block_group;
6098	struct btrfs_caching_control *caching_ctl;
6099	u64 start = ins->objectid;
6100	u64 num_bytes = ins->offset;
6101
6102	block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
6103	cache_block_group(block_group, trans, NULL, 0);
6104	caching_ctl = get_caching_control(block_group);
6105
6106	if (!caching_ctl) {
6107		BUG_ON(!block_group_cache_done(block_group));
6108		ret = btrfs_remove_free_space(block_group, start, num_bytes);
6109		BUG_ON(ret); /* -ENOMEM */
6110	} else {
6111		mutex_lock(&caching_ctl->mutex);
6112
6113		if (start >= caching_ctl->progress) {
6114			ret = add_excluded_extent(root, start, num_bytes);
6115			BUG_ON(ret); /* -ENOMEM */
6116		} else if (start + num_bytes <= caching_ctl->progress) {
6117			ret = btrfs_remove_free_space(block_group,
6118						      start, num_bytes);
6119			BUG_ON(ret); /* -ENOMEM */
6120		} else {
6121			num_bytes = caching_ctl->progress - start;
6122			ret = btrfs_remove_free_space(block_group,
6123						      start, num_bytes);
6124			BUG_ON(ret); /* -ENOMEM */
6125
6126			start = caching_ctl->progress;
6127			num_bytes = ins->objectid + ins->offset -
6128				    caching_ctl->progress;
6129			ret = add_excluded_extent(root, start, num_bytes);
6130			BUG_ON(ret); /* -ENOMEM */
6131		}
6132
6133		mutex_unlock(&caching_ctl->mutex);
6134		put_caching_control(caching_ctl);
6135	}
 
 
 
 
6136
6137	ret = btrfs_update_reserved_bytes(block_group, ins->offset,
6138					  RESERVE_ALLOC_NO_ACCOUNT);
6139	BUG_ON(ret); /* logic error */
 
 
6140	btrfs_put_block_group(block_group);
6141	ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
6142					 0, owner, offset, ins, 1);
6143	return ret;
6144}
6145
6146struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
6147					    struct btrfs_root *root,
6148					    u64 bytenr, u32 blocksize,
6149					    int level)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6150{
 
6151	struct extent_buffer *buf;
 
 
 
 
 
6152
6153	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
6154	if (!buf)
6155		return ERR_PTR(-ENOMEM);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6156	btrfs_set_header_generation(buf, trans->transid);
6157	btrfs_set_buffer_lockdep_class(root->root_key.objectid, buf, level);
6158	btrfs_tree_lock(buf);
6159	clean_tree_block(trans, root, buf);
 
 
 
 
 
 
 
6160	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);
 
6161
6162	btrfs_set_lock_blocking(buf);
6163	btrfs_set_buffer_uptodate(buf);
6164
 
 
 
 
 
 
 
 
6165	if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
 
6166		/*
6167		 * we allow two log transactions at a time, use different
6168		 * EXENT bit to differentiate dirty pages.
6169		 */
6170		if (root->log_transid % 2 == 0)
6171			set_extent_dirty(&root->dirty_log_pages, buf->start,
6172					buf->start + buf->len - 1, GFP_NOFS);
 
6173		else
6174			set_extent_new(&root->dirty_log_pages, buf->start,
6175					buf->start + buf->len - 1, GFP_NOFS);
6176	} else {
6177		set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
6178			 buf->start + buf->len - 1, GFP_NOFS);
 
 
6179	}
6180	trans->blocks_used++;
6181	/* this returns a buffer locked for blocking */
6182	return buf;
6183}
6184
6185static struct btrfs_block_rsv *
6186use_block_rsv(struct btrfs_trans_handle *trans,
6187	      struct btrfs_root *root, u32 blocksize)
6188{
6189	struct btrfs_block_rsv *block_rsv;
6190	struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
6191	int ret;
6192
6193	block_rsv = get_block_rsv(trans, root);
6194
6195	if (block_rsv->size == 0) {
6196		ret = reserve_metadata_bytes(root, block_rsv, blocksize, 0);
6197		/*
6198		 * If we couldn't reserve metadata bytes try and use some from
6199		 * the global reserve.
6200		 */
6201		if (ret && block_rsv != global_rsv) {
6202			ret = block_rsv_use_bytes(global_rsv, blocksize);
6203			if (!ret)
6204				return global_rsv;
6205			return ERR_PTR(ret);
6206		} else if (ret) {
6207			return ERR_PTR(ret);
6208		}
6209		return block_rsv;
6210	}
6211
6212	ret = block_rsv_use_bytes(block_rsv, blocksize);
6213	if (!ret)
6214		return block_rsv;
6215	if (ret) {
6216		static DEFINE_RATELIMIT_STATE(_rs,
6217				DEFAULT_RATELIMIT_INTERVAL,
6218				/*DEFAULT_RATELIMIT_BURST*/ 2);
6219		if (__ratelimit(&_rs)) {
6220			printk(KERN_DEBUG "btrfs: block rsv returned %d\n", ret);
6221			WARN_ON(1);
6222		}
6223		ret = reserve_metadata_bytes(root, block_rsv, blocksize, 0);
6224		if (!ret) {
6225			return block_rsv;
6226		} else if (ret && block_rsv != global_rsv) {
6227			ret = block_rsv_use_bytes(global_rsv, blocksize);
6228			if (!ret)
6229				return global_rsv;
6230		}
6231	}
6232
6233	return ERR_PTR(-ENOSPC);
6234}
6235
6236static void unuse_block_rsv(struct btrfs_fs_info *fs_info,
6237			    struct btrfs_block_rsv *block_rsv, u32 blocksize)
6238{
6239	block_rsv_add_bytes(block_rsv, blocksize, 0);
6240	block_rsv_release_bytes(fs_info, block_rsv, NULL, 0);
6241}
6242
6243/*
6244 * finds a free extent and does all the dirty work required for allocation
6245 * returns the key for the extent through ins, and a tree buffer for
6246 * the first block of the extent through buf.
6247 *
6248 * returns the tree buffer or NULL.
6249 */
6250struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
6251					struct btrfs_root *root, u32 blocksize,
6252					u64 parent, u64 root_objectid,
6253					struct btrfs_disk_key *key, int level,
6254					u64 hint, u64 empty_size)
 
 
 
6255{
 
6256	struct btrfs_key ins;
6257	struct btrfs_block_rsv *block_rsv;
6258	struct extent_buffer *buf;
 
 
6259	u64 flags = 0;
6260	int ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
6261
6262
6263	block_rsv = use_block_rsv(trans, root, blocksize);
6264	if (IS_ERR(block_rsv))
6265		return ERR_CAST(block_rsv);
6266
6267	ret = btrfs_reserve_extent(trans, root, blocksize, blocksize,
6268				   empty_size, hint, &ins, 0);
6269	if (ret) {
6270		unuse_block_rsv(root->fs_info, block_rsv, blocksize);
6271		return ERR_PTR(ret);
 
 
 
 
 
6272	}
6273
6274	buf = btrfs_init_new_buffer(trans, root, ins.objectid,
6275				    blocksize, level);
6276	BUG_ON(IS_ERR(buf)); /* -ENOMEM */
6277
6278	if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
6279		if (parent == 0)
6280			parent = ins.objectid;
6281		flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
 
6282	} else
6283		BUG_ON(parent > 0);
6284
6285	if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
6286		struct btrfs_delayed_extent_op *extent_op;
6287		extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
6288		BUG_ON(!extent_op); /* -ENOMEM */
 
 
6289		if (key)
6290			memcpy(&extent_op->key, key, sizeof(extent_op->key));
6291		else
6292			memset(&extent_op->key, 0, sizeof(extent_op->key));
6293		extent_op->flags_to_set = flags;
6294		extent_op->update_key = 1;
6295		extent_op->update_flags = 1;
6296		extent_op->is_data = 0;
6297
6298		ret = btrfs_add_delayed_tree_ref(root->fs_info, trans,
6299					ins.objectid,
6300					ins.offset, parent, root_objectid,
6301					level, BTRFS_ADD_DELAYED_EXTENT,
6302					extent_op, 0);
6303		BUG_ON(ret); /* -ENOMEM */
 
 
6304	}
6305	return buf;
 
 
 
 
 
 
 
 
 
 
 
6306}
6307
6308struct walk_control {
6309	u64 refs[BTRFS_MAX_LEVEL];
6310	u64 flags[BTRFS_MAX_LEVEL];
6311	struct btrfs_key update_progress;
 
 
6312	int stage;
6313	int level;
6314	int shared_level;
6315	int update_ref;
6316	int keep_locks;
6317	int reada_slot;
6318	int reada_count;
6319	int for_reloc;
6320};
6321
6322#define DROP_REFERENCE	1
6323#define UPDATE_BACKREF	2
6324
6325static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
6326				     struct btrfs_root *root,
6327				     struct walk_control *wc,
6328				     struct btrfs_path *path)
6329{
 
6330	u64 bytenr;
6331	u64 generation;
6332	u64 refs;
6333	u64 flags;
6334	u32 nritems;
6335	u32 blocksize;
6336	struct btrfs_key key;
6337	struct extent_buffer *eb;
6338	int ret;
6339	int slot;
6340	int nread = 0;
6341
6342	if (path->slots[wc->level] < wc->reada_slot) {
6343		wc->reada_count = wc->reada_count * 2 / 3;
6344		wc->reada_count = max(wc->reada_count, 2);
6345	} else {
6346		wc->reada_count = wc->reada_count * 3 / 2;
6347		wc->reada_count = min_t(int, wc->reada_count,
6348					BTRFS_NODEPTRS_PER_BLOCK(root));
6349	}
6350
6351	eb = path->nodes[wc->level];
6352	nritems = btrfs_header_nritems(eb);
6353	blocksize = btrfs_level_size(root, wc->level - 1);
6354
6355	for (slot = path->slots[wc->level]; slot < nritems; slot++) {
6356		if (nread >= wc->reada_count)
6357			break;
6358
6359		cond_resched();
6360		bytenr = btrfs_node_blockptr(eb, slot);
6361		generation = btrfs_node_ptr_generation(eb, slot);
6362
6363		if (slot == path->slots[wc->level])
6364			goto reada;
6365
6366		if (wc->stage == UPDATE_BACKREF &&
6367		    generation <= root->root_key.offset)
6368			continue;
6369
6370		/* We don't lock the tree block, it's OK to be racy here */
6371		ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
6372					       &refs, &flags);
 
6373		/* We don't care about errors in readahead. */
6374		if (ret < 0)
6375			continue;
6376		BUG_ON(refs == 0);
6377
6378		if (wc->stage == DROP_REFERENCE) {
6379			if (refs == 1)
6380				goto reada;
6381
6382			if (wc->level == 1 &&
6383			    (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6384				continue;
6385			if (!wc->update_ref ||
6386			    generation <= root->root_key.offset)
6387				continue;
6388			btrfs_node_key_to_cpu(eb, &key, slot);
6389			ret = btrfs_comp_cpu_keys(&key,
6390						  &wc->update_progress);
6391			if (ret < 0)
6392				continue;
6393		} else {
6394			if (wc->level == 1 &&
6395			    (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6396				continue;
6397		}
6398reada:
6399		ret = readahead_tree_block(root, bytenr, blocksize,
6400					   generation);
6401		if (ret)
6402			break;
6403		nread++;
6404	}
6405	wc->reada_slot = slot;
6406}
6407
6408/*
6409 * hepler to process tree block while walking down the tree.
6410 *
6411 * when wc->stage == UPDATE_BACKREF, this function updates
6412 * back refs for pointers in the block.
6413 *
6414 * NOTE: return value 1 means we should stop walking down.
6415 */
6416static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
6417				   struct btrfs_root *root,
6418				   struct btrfs_path *path,
6419				   struct walk_control *wc, int lookup_info)
6420{
 
6421	int level = wc->level;
6422	struct extent_buffer *eb = path->nodes[level];
6423	u64 flag = BTRFS_BLOCK_FLAG_FULL_BACKREF;
6424	int ret;
6425
6426	if (wc->stage == UPDATE_BACKREF &&
6427	    btrfs_header_owner(eb) != root->root_key.objectid)
6428		return 1;
6429
6430	/*
6431	 * when reference count of tree block is 1, it won't increase
6432	 * again. once full backref flag is set, we never clear it.
6433	 */
6434	if (lookup_info &&
6435	    ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
6436	     (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
6437		BUG_ON(!path->locks[level]);
6438		ret = btrfs_lookup_extent_info(trans, root,
6439					       eb->start, eb->len,
6440					       &wc->refs[level],
6441					       &wc->flags[level]);
 
6442		BUG_ON(ret == -ENOMEM);
6443		if (ret)
6444			return ret;
6445		BUG_ON(wc->refs[level] == 0);
6446	}
6447
6448	if (wc->stage == DROP_REFERENCE) {
6449		if (wc->refs[level] > 1)
6450			return 1;
6451
6452		if (path->locks[level] && !wc->keep_locks) {
6453			btrfs_tree_unlock_rw(eb, path->locks[level]);
6454			path->locks[level] = 0;
6455		}
6456		return 0;
6457	}
6458
6459	/* wc->stage == UPDATE_BACKREF */
6460	if (!(wc->flags[level] & flag)) {
6461		BUG_ON(!path->locks[level]);
6462		ret = btrfs_inc_ref(trans, root, eb, 1, wc->for_reloc);
6463		BUG_ON(ret); /* -ENOMEM */
6464		ret = btrfs_dec_ref(trans, root, eb, 0, wc->for_reloc);
6465		BUG_ON(ret); /* -ENOMEM */
6466		ret = btrfs_set_disk_extent_flags(trans, root, eb->start,
6467						  eb->len, flag, 0);
6468		BUG_ON(ret); /* -ENOMEM */
6469		wc->flags[level] |= flag;
6470	}
6471
6472	/*
6473	 * the block is shared by multiple trees, so it's not good to
6474	 * keep the tree lock
6475	 */
6476	if (path->locks[level] && level > 0) {
6477		btrfs_tree_unlock_rw(eb, path->locks[level]);
6478		path->locks[level] = 0;
6479	}
6480	return 0;
6481}
6482
6483/*
6484 * hepler to process tree block pointer.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6485 *
6486 * when wc->stage == DROP_REFERENCE, this function checks
6487 * reference count of the block pointed to. if the block
6488 * is shared and we need update back refs for the subtree
6489 * rooted at the block, this function changes wc->stage to
6490 * UPDATE_BACKREF. if the block is shared and there is no
6491 * need to update back, this function drops the reference
6492 * to the block.
6493 *
6494 * NOTE: return value 1 means we should stop walking down.
6495 */
6496static noinline int do_walk_down(struct btrfs_trans_handle *trans,
6497				 struct btrfs_root *root,
6498				 struct btrfs_path *path,
6499				 struct walk_control *wc, int *lookup_info)
6500{
 
6501	u64 bytenr;
6502	u64 generation;
6503	u64 parent;
6504	u32 blocksize;
 
6505	struct btrfs_key key;
 
6506	struct extent_buffer *next;
6507	int level = wc->level;
6508	int reada = 0;
6509	int ret = 0;
 
6510
6511	generation = btrfs_node_ptr_generation(path->nodes[level],
6512					       path->slots[level]);
6513	/*
6514	 * if the lower level block was created before the snapshot
6515	 * was created, we know there is no need to update back refs
6516	 * for the subtree
6517	 */
6518	if (wc->stage == UPDATE_BACKREF &&
6519	    generation <= root->root_key.offset) {
6520		*lookup_info = 1;
6521		return 1;
6522	}
6523
6524	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
6525	blocksize = btrfs_level_size(root, level - 1);
6526
6527	next = btrfs_find_tree_block(root, bytenr, blocksize);
 
 
 
 
 
 
 
6528	if (!next) {
6529		next = btrfs_find_create_tree_block(root, bytenr, blocksize);
6530		if (!next)
6531			return -ENOMEM;
 
6532		reada = 1;
6533	}
6534	btrfs_tree_lock(next);
6535	btrfs_set_lock_blocking(next);
6536
6537	ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
6538				       &wc->refs[level - 1],
6539				       &wc->flags[level - 1]);
6540	if (ret < 0) {
6541		btrfs_tree_unlock(next);
6542		return ret;
 
 
 
 
 
6543	}
6544
6545	BUG_ON(wc->refs[level - 1] == 0);
6546	*lookup_info = 0;
6547
6548	if (wc->stage == DROP_REFERENCE) {
6549		if (wc->refs[level - 1] > 1) {
 
6550			if (level == 1 &&
6551			    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6552				goto skip;
6553
6554			if (!wc->update_ref ||
6555			    generation <= root->root_key.offset)
6556				goto skip;
6557
6558			btrfs_node_key_to_cpu(path->nodes[level], &key,
6559					      path->slots[level]);
6560			ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
6561			if (ret < 0)
6562				goto skip;
6563
6564			wc->stage = UPDATE_BACKREF;
6565			wc->shared_level = level - 1;
6566		}
6567	} else {
6568		if (level == 1 &&
6569		    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
6570			goto skip;
6571	}
6572
6573	if (!btrfs_buffer_uptodate(next, generation, 0)) {
6574		btrfs_tree_unlock(next);
6575		free_extent_buffer(next);
6576		next = NULL;
6577		*lookup_info = 1;
6578	}
6579
6580	if (!next) {
6581		if (reada && level == 1)
6582			reada_walk_down(trans, root, wc, path);
6583		next = read_tree_block(root, bytenr, blocksize, generation);
6584		if (!next)
 
 
 
6585			return -EIO;
 
6586		btrfs_tree_lock(next);
6587		btrfs_set_lock_blocking(next);
6588	}
6589
6590	level--;
6591	BUG_ON(level != btrfs_header_level(next));
 
 
 
 
 
6592	path->nodes[level] = next;
6593	path->slots[level] = 0;
6594	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
6595	wc->level = level;
6596	if (wc->level == 1)
6597		wc->reada_slot = 0;
6598	return 0;
6599skip:
6600	wc->refs[level - 1] = 0;
6601	wc->flags[level - 1] = 0;
6602	if (wc->stage == DROP_REFERENCE) {
6603		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
6604			parent = path->nodes[level]->start;
6605		} else {
6606			BUG_ON(root->root_key.objectid !=
6607			       btrfs_header_owner(path->nodes[level]));
 
 
 
 
 
 
 
6608			parent = 0;
6609		}
6610
6611		ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
6612				root->root_key.objectid, level - 1, 0, 0);
6613		BUG_ON(ret); /* -ENOMEM */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6614	}
 
 
 
 
 
6615	btrfs_tree_unlock(next);
6616	free_extent_buffer(next);
6617	*lookup_info = 1;
6618	return 1;
6619}
6620
6621/*
6622 * hepler to process tree block while walking up the tree.
6623 *
6624 * when wc->stage == DROP_REFERENCE, this function drops
6625 * reference count on the block.
6626 *
6627 * when wc->stage == UPDATE_BACKREF, this function changes
6628 * wc->stage back to DROP_REFERENCE if we changed wc->stage
6629 * to UPDATE_BACKREF previously while processing the block.
6630 *
6631 * NOTE: return value 1 means we should stop walking up.
6632 */
6633static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
6634				 struct btrfs_root *root,
6635				 struct btrfs_path *path,
6636				 struct walk_control *wc)
6637{
 
6638	int ret;
6639	int level = wc->level;
6640	struct extent_buffer *eb = path->nodes[level];
6641	u64 parent = 0;
6642
6643	if (wc->stage == UPDATE_BACKREF) {
6644		BUG_ON(wc->shared_level < level);
6645		if (level < wc->shared_level)
6646			goto out;
6647
6648		ret = find_next_key(path, level + 1, &wc->update_progress);
6649		if (ret > 0)
6650			wc->update_ref = 0;
6651
6652		wc->stage = DROP_REFERENCE;
6653		wc->shared_level = -1;
6654		path->slots[level] = 0;
6655
6656		/*
6657		 * check reference count again if the block isn't locked.
6658		 * we should start walking down the tree again if reference
6659		 * count is one.
6660		 */
6661		if (!path->locks[level]) {
6662			BUG_ON(level == 0);
6663			btrfs_tree_lock(eb);
6664			btrfs_set_lock_blocking(eb);
6665			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
6666
6667			ret = btrfs_lookup_extent_info(trans, root,
6668						       eb->start, eb->len,
6669						       &wc->refs[level],
6670						       &wc->flags[level]);
 
6671			if (ret < 0) {
6672				btrfs_tree_unlock_rw(eb, path->locks[level]);
 
6673				return ret;
6674			}
6675			BUG_ON(wc->refs[level] == 0);
6676			if (wc->refs[level] == 1) {
6677				btrfs_tree_unlock_rw(eb, path->locks[level]);
 
6678				return 1;
6679			}
6680		}
6681	}
6682
6683	/* wc->stage == DROP_REFERENCE */
6684	BUG_ON(wc->refs[level] > 1 && !path->locks[level]);
6685
6686	if (wc->refs[level] == 1) {
6687		if (level == 0) {
6688			if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6689				ret = btrfs_dec_ref(trans, root, eb, 1,
6690						    wc->for_reloc);
6691			else
6692				ret = btrfs_dec_ref(trans, root, eb, 0,
6693						    wc->for_reloc);
6694			BUG_ON(ret); /* -ENOMEM */
 
 
 
 
 
 
 
 
6695		}
6696		/* make block locked assertion in clean_tree_block happy */
6697		if (!path->locks[level] &&
6698		    btrfs_header_generation(eb) == trans->transid) {
6699			btrfs_tree_lock(eb);
6700			btrfs_set_lock_blocking(eb);
6701			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
6702		}
6703		clean_tree_block(trans, root, eb);
6704	}
6705
6706	if (eb == root->node) {
6707		if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6708			parent = eb->start;
6709		else
6710			BUG_ON(root->root_key.objectid !=
6711			       btrfs_header_owner(eb));
6712	} else {
6713		if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6714			parent = path->nodes[level + 1]->start;
6715		else
6716			BUG_ON(root->root_key.objectid !=
6717			       btrfs_header_owner(path->nodes[level + 1]));
6718	}
6719
6720	btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);
 
6721out:
6722	wc->refs[level] = 0;
6723	wc->flags[level] = 0;
6724	return 0;
 
 
 
 
 
6725}
6726
6727static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
6728				   struct btrfs_root *root,
6729				   struct btrfs_path *path,
6730				   struct walk_control *wc)
6731{
6732	int level = wc->level;
6733	int lookup_info = 1;
6734	int ret;
6735
6736	while (level >= 0) {
6737		ret = walk_down_proc(trans, root, path, wc, lookup_info);
6738		if (ret > 0)
6739			break;
6740
6741		if (level == 0)
6742			break;
6743
6744		if (path->slots[level] >=
6745		    btrfs_header_nritems(path->nodes[level]))
6746			break;
6747
6748		ret = do_walk_down(trans, root, path, wc, &lookup_info);
6749		if (ret > 0) {
6750			path->slots[level]++;
6751			continue;
6752		} else if (ret < 0)
6753			return ret;
6754		level = wc->level;
6755	}
6756	return 0;
6757}
6758
6759static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
6760				 struct btrfs_root *root,
6761				 struct btrfs_path *path,
6762				 struct walk_control *wc, int max_level)
6763{
6764	int level = wc->level;
6765	int ret;
6766
6767	path->slots[level] = btrfs_header_nritems(path->nodes[level]);
6768	while (level < max_level && path->nodes[level]) {
6769		wc->level = level;
6770		if (path->slots[level] + 1 <
6771		    btrfs_header_nritems(path->nodes[level])) {
6772			path->slots[level]++;
6773			return 0;
6774		} else {
6775			ret = walk_up_proc(trans, root, path, wc);
6776			if (ret > 0)
6777				return 0;
 
 
6778
6779			if (path->locks[level]) {
6780				btrfs_tree_unlock_rw(path->nodes[level],
6781						     path->locks[level]);
6782				path->locks[level] = 0;
6783			}
6784			free_extent_buffer(path->nodes[level]);
6785			path->nodes[level] = NULL;
6786			level++;
6787		}
6788	}
6789	return 1;
6790}
6791
6792/*
6793 * drop a subvolume tree.
6794 *
6795 * this function traverses the tree freeing any blocks that only
6796 * referenced by the tree.
6797 *
6798 * when a shared tree block is found. this function decreases its
6799 * reference count by one. if update_ref is true, this function
6800 * also make sure backrefs for the shared block and all lower level
6801 * blocks are properly updated.
 
 
6802 */
6803int btrfs_drop_snapshot(struct btrfs_root *root,
6804			 struct btrfs_block_rsv *block_rsv, int update_ref,
6805			 int for_reloc)
6806{
 
 
 
6807	struct btrfs_path *path;
6808	struct btrfs_trans_handle *trans;
6809	struct btrfs_root *tree_root = root->fs_info->tree_root;
6810	struct btrfs_root_item *root_item = &root->root_item;
6811	struct walk_control *wc;
6812	struct btrfs_key key;
6813	int err = 0;
6814	int ret;
6815	int level;
 
 
 
 
6816
6817	path = btrfs_alloc_path();
6818	if (!path) {
6819		err = -ENOMEM;
6820		goto out;
6821	}
6822
6823	wc = kzalloc(sizeof(*wc), GFP_NOFS);
6824	if (!wc) {
6825		btrfs_free_path(path);
6826		err = -ENOMEM;
6827		goto out;
6828	}
6829
6830	trans = btrfs_start_transaction(tree_root, 0);
 
 
 
 
 
 
 
6831	if (IS_ERR(trans)) {
6832		err = PTR_ERR(trans);
6833		goto out_free;
6834	}
6835
6836	if (block_rsv)
6837		trans->block_rsv = block_rsv;
 
 
 
 
 
 
 
 
 
 
 
 
6838
6839	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
6840		level = btrfs_header_level(root->node);
6841		path->nodes[level] = btrfs_lock_root_node(root);
6842		btrfs_set_lock_blocking(path->nodes[level]);
6843		path->slots[level] = 0;
6844		path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
6845		memset(&wc->update_progress, 0,
6846		       sizeof(wc->update_progress));
6847	} else {
6848		btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
6849		memcpy(&wc->update_progress, &key,
6850		       sizeof(wc->update_progress));
6851
6852		level = root_item->drop_level;
6853		BUG_ON(level == 0);
6854		path->lowest_level = level;
6855		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6856		path->lowest_level = 0;
6857		if (ret < 0) {
6858			err = ret;
6859			goto out_end_trans;
6860		}
6861		WARN_ON(ret > 0);
6862
6863		/*
6864		 * unlock our path, this is safe because only this
6865		 * function is allowed to delete this snapshot
6866		 */
6867		btrfs_unlock_up_safe(path, 0);
6868
6869		level = btrfs_header_level(root->node);
6870		while (1) {
6871			btrfs_tree_lock(path->nodes[level]);
6872			btrfs_set_lock_blocking(path->nodes[level]);
6873
6874			ret = btrfs_lookup_extent_info(trans, root,
6875						path->nodes[level]->start,
6876						path->nodes[level]->len,
6877						&wc->refs[level],
6878						&wc->flags[level]);
6879			if (ret < 0) {
6880				err = ret;
6881				goto out_end_trans;
6882			}
6883			BUG_ON(wc->refs[level] == 0);
6884
6885			if (level == root_item->drop_level)
6886				break;
6887
6888			btrfs_tree_unlock(path->nodes[level]);
 
6889			WARN_ON(wc->refs[level] != 1);
6890			level--;
6891		}
6892	}
6893
 
6894	wc->level = level;
6895	wc->shared_level = -1;
6896	wc->stage = DROP_REFERENCE;
6897	wc->update_ref = update_ref;
6898	wc->keep_locks = 0;
6899	wc->for_reloc = for_reloc;
6900	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
6901
6902	while (1) {
 
6903		ret = walk_down_tree(trans, root, path, wc);
6904		if (ret < 0) {
 
6905			err = ret;
6906			break;
6907		}
6908
6909		ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);
6910		if (ret < 0) {
 
6911			err = ret;
6912			break;
6913		}
6914
6915		if (ret > 0) {
6916			BUG_ON(wc->stage != DROP_REFERENCE);
6917			break;
6918		}
6919
6920		if (wc->stage == DROP_REFERENCE) {
6921			level = wc->level;
6922			btrfs_node_key(path->nodes[level],
6923				       &root_item->drop_progress,
6924				       path->slots[level]);
6925			root_item->drop_level = level;
6926		}
 
 
6927
6928		BUG_ON(wc->level == 0);
6929		if (btrfs_should_end_transaction(trans, tree_root)) {
 
6930			ret = btrfs_update_root(trans, tree_root,
6931						&root->root_key,
6932						root_item);
6933			if (ret) {
6934				btrfs_abort_transaction(trans, tree_root, ret);
6935				err = ret;
6936				goto out_end_trans;
6937			}
6938
6939			btrfs_end_transaction_throttle(trans, tree_root);
6940			trans = btrfs_start_transaction(tree_root, 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6941			if (IS_ERR(trans)) {
6942				err = PTR_ERR(trans);
6943				goto out_free;
6944			}
6945			if (block_rsv)
6946				trans->block_rsv = block_rsv;
6947		}
6948	}
6949	btrfs_release_path(path);
6950	if (err)
6951		goto out_end_trans;
6952
6953	ret = btrfs_del_root(trans, tree_root, &root->root_key);
6954	if (ret) {
6955		btrfs_abort_transaction(trans, tree_root, ret);
 
6956		goto out_end_trans;
6957	}
6958
6959	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
6960		ret = btrfs_find_last_root(tree_root, root->root_key.objectid,
6961					   NULL, NULL);
6962		if (ret < 0) {
6963			btrfs_abort_transaction(trans, tree_root, ret);
6964			err = ret;
6965			goto out_end_trans;
6966		} else if (ret > 0) {
6967			/* if we fail to delete the orphan item this time
6968			 * around, it'll get picked up the next time.
6969			 *
6970			 * The most common failure here is just -ENOENT.
6971			 */
6972			btrfs_del_orphan_item(trans, tree_root,
6973					      root->root_key.objectid);
6974		}
6975	}
6976
6977	if (root->in_radix) {
6978		btrfs_free_fs_root(tree_root->fs_info, root);
6979	} else {
6980		free_extent_buffer(root->node);
6981		free_extent_buffer(root->commit_root);
6982		kfree(root);
6983	}
 
 
 
 
 
 
6984out_end_trans:
6985	btrfs_end_transaction_throttle(trans, tree_root);
 
 
 
6986out_free:
6987	kfree(wc);
6988	btrfs_free_path(path);
6989out:
6990	if (err)
6991		btrfs_std_error(root->fs_info, err);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6992	return err;
6993}
6994
6995/*
6996 * drop subtree rooted at tree block 'node'.
6997 *
6998 * NOTE: this function will unlock and release tree block 'node'
6999 * only used by relocation code
7000 */
7001int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
7002			struct btrfs_root *root,
7003			struct extent_buffer *node,
7004			struct extent_buffer *parent)
7005{
 
7006	struct btrfs_path *path;
7007	struct walk_control *wc;
7008	int level;
7009	int parent_level;
7010	int ret = 0;
7011	int wret;
7012
7013	BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
7014
7015	path = btrfs_alloc_path();
7016	if (!path)
7017		return -ENOMEM;
7018
7019	wc = kzalloc(sizeof(*wc), GFP_NOFS);
7020	if (!wc) {
7021		btrfs_free_path(path);
7022		return -ENOMEM;
7023	}
7024
7025	btrfs_assert_tree_locked(parent);
7026	parent_level = btrfs_header_level(parent);
7027	extent_buffer_get(parent);
7028	path->nodes[parent_level] = parent;
7029	path->slots[parent_level] = btrfs_header_nritems(parent);
7030
7031	btrfs_assert_tree_locked(node);
7032	level = btrfs_header_level(node);
7033	path->nodes[level] = node;
7034	path->slots[level] = 0;
7035	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
7036
7037	wc->refs[parent_level] = 1;
7038	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;
7039	wc->level = level;
7040	wc->shared_level = -1;
7041	wc->stage = DROP_REFERENCE;
7042	wc->update_ref = 0;
7043	wc->keep_locks = 1;
7044	wc->for_reloc = 1;
7045	wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
7046
7047	while (1) {
7048		wret = walk_down_tree(trans, root, path, wc);
7049		if (wret < 0) {
7050			ret = wret;
7051			break;
7052		}
7053
7054		wret = walk_up_tree(trans, root, path, wc, parent_level);
7055		if (wret < 0)
7056			ret = wret;
7057		if (wret != 0)
7058			break;
7059	}
7060
7061	kfree(wc);
7062	btrfs_free_path(path);
7063	return ret;
7064}
7065
7066static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
7067{
7068	u64 num_devices;
7069	u64 stripped;
7070
7071	/*
7072	 * if restripe for this chunk_type is on pick target profile and
7073	 * return, otherwise do the usual balance
7074	 */
7075	stripped = get_restripe_target(root->fs_info, flags);
7076	if (stripped)
7077		return extended_to_chunk(stripped);
7078
7079	/*
7080	 * we add in the count of missing devices because we want
7081	 * to make sure that any RAID levels on a degraded FS
7082	 * continue to be honored.
7083	 */
7084	num_devices = root->fs_info->fs_devices->rw_devices +
7085		root->fs_info->fs_devices->missing_devices;
7086
7087	stripped = BTRFS_BLOCK_GROUP_RAID0 |
7088		BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;
7089
7090	if (num_devices == 1) {
7091		stripped |= BTRFS_BLOCK_GROUP_DUP;
7092		stripped = flags & ~stripped;
7093
7094		/* turn raid0 into single device chunks */
7095		if (flags & BTRFS_BLOCK_GROUP_RAID0)
7096			return stripped;
7097
7098		/* turn mirroring into duplication */
7099		if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
7100			     BTRFS_BLOCK_GROUP_RAID10))
7101			return stripped | BTRFS_BLOCK_GROUP_DUP;
7102	} else {
7103		/* they already had raid on here, just return */
7104		if (flags & stripped)
7105			return flags;
7106
7107		stripped |= BTRFS_BLOCK_GROUP_DUP;
7108		stripped = flags & ~stripped;
7109
7110		/* switch duplicated blocks with raid1 */
7111		if (flags & BTRFS_BLOCK_GROUP_DUP)
7112			return stripped | BTRFS_BLOCK_GROUP_RAID1;
7113
7114		/* this is drive concat, leave it alone */
7115	}
7116
7117	return flags;
7118}
7119
7120static int set_block_group_ro(struct btrfs_block_group_cache *cache, int force)
7121{
7122	struct btrfs_space_info *sinfo = cache->space_info;
7123	u64 num_bytes;
7124	u64 min_allocable_bytes;
7125	int ret = -ENOSPC;
7126
7127
7128	/*
7129	 * We need some metadata space and system metadata space for
7130	 * allocating chunks in some corner cases until we force to set
7131	 * it to be readonly.
7132	 */
7133	if ((sinfo->flags &
7134	     (BTRFS_BLOCK_GROUP_SYSTEM | BTRFS_BLOCK_GROUP_METADATA)) &&
7135	    !force)
7136		min_allocable_bytes = 1 * 1024 * 1024;
7137	else
7138		min_allocable_bytes = 0;
7139
7140	spin_lock(&sinfo->lock);
7141	spin_lock(&cache->lock);
7142
7143	if (cache->ro) {
7144		ret = 0;
7145		goto out;
7146	}
7147
7148	num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7149		    cache->bytes_super - btrfs_block_group_used(&cache->item);
7150
7151	if (sinfo->bytes_used + sinfo->bytes_reserved + sinfo->bytes_pinned +
7152	    sinfo->bytes_may_use + sinfo->bytes_readonly + num_bytes +
7153	    min_allocable_bytes <= sinfo->total_bytes) {
7154		sinfo->bytes_readonly += num_bytes;
7155		cache->ro = 1;
7156		ret = 0;
7157	}
7158out:
7159	spin_unlock(&cache->lock);
7160	spin_unlock(&sinfo->lock);
7161	return ret;
7162}
7163
7164int btrfs_set_block_group_ro(struct btrfs_root *root,
7165			     struct btrfs_block_group_cache *cache)
7166
7167{
7168	struct btrfs_trans_handle *trans;
7169	u64 alloc_flags;
7170	int ret;
7171
7172	BUG_ON(cache->ro);
7173
7174	trans = btrfs_join_transaction(root);
7175	if (IS_ERR(trans))
7176		return PTR_ERR(trans);
7177
7178	alloc_flags = update_block_group_flags(root, cache->flags);
7179	if (alloc_flags != cache->flags) {
7180		ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
7181				     CHUNK_ALLOC_FORCE);
7182		if (ret < 0)
7183			goto out;
7184	}
7185
7186	ret = set_block_group_ro(cache, 0);
7187	if (!ret)
7188		goto out;
7189	alloc_flags = get_alloc_profile(root, cache->space_info->flags);
7190	ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
7191			     CHUNK_ALLOC_FORCE);
7192	if (ret < 0)
7193		goto out;
7194	ret = set_block_group_ro(cache, 0);
7195out:
7196	btrfs_end_transaction(trans, root);
7197	return ret;
7198}
7199
7200int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
7201			    struct btrfs_root *root, u64 type)
7202{
7203	u64 alloc_flags = get_alloc_profile(root, type);
7204	return do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
7205			      CHUNK_ALLOC_FORCE);
7206}
7207
7208/*
7209 * helper to account the unused space of all the readonly block group in the
7210 * list. takes mirrors into account.
7211 */
7212static u64 __btrfs_get_ro_block_group_free_space(struct list_head *groups_list)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7213{
7214	struct btrfs_block_group_cache *block_group;
7215	u64 free_bytes = 0;
7216	int factor;
7217
7218	list_for_each_entry(block_group, groups_list, list) {
7219		spin_lock(&block_group->lock);
7220
7221		if (!block_group->ro) {
7222			spin_unlock(&block_group->lock);
7223			continue;
7224		}
7225
7226		if (block_group->flags & (BTRFS_BLOCK_GROUP_RAID1 |
7227					  BTRFS_BLOCK_GROUP_RAID10 |
7228					  BTRFS_BLOCK_GROUP_DUP))
7229			factor = 2;
7230		else
7231			factor = 1;
7232
7233		free_bytes += (block_group->key.offset -
7234			       btrfs_block_group_used(&block_group->item)) *
7235			       factor;
7236
7237		spin_unlock(&block_group->lock);
7238	}
7239
7240	return free_bytes;
7241}
 
7242
7243/*
7244 * helper to account the unused space of all the readonly block group in the
7245 * space_info. takes mirrors into account.
7246 */
7247u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo)
7248{
7249	int i;
7250	u64 free_bytes = 0;
7251
7252	spin_lock(&sinfo->lock);
7253
7254	for(i = 0; i < BTRFS_NR_RAID_TYPES; i++)
7255		if (!list_empty(&sinfo->block_groups[i]))
7256			free_bytes += __btrfs_get_ro_block_group_free_space(
7257						&sinfo->block_groups[i]);
7258
7259	spin_unlock(&sinfo->lock);
7260
7261	return free_bytes;
7262}
7263
7264void btrfs_set_block_group_rw(struct btrfs_root *root,
7265			      struct btrfs_block_group_cache *cache)
7266{
7267	struct btrfs_space_info *sinfo = cache->space_info;
7268	u64 num_bytes;
7269
7270	BUG_ON(!cache->ro);
7271
7272	spin_lock(&sinfo->lock);
7273	spin_lock(&cache->lock);
7274	num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7275		    cache->bytes_super - btrfs_block_group_used(&cache->item);
7276	sinfo->bytes_readonly -= num_bytes;
7277	cache->ro = 0;
7278	spin_unlock(&cache->lock);
7279	spin_unlock(&sinfo->lock);
7280}
7281
7282/*
7283 * checks to see if its even possible to relocate this block group.
7284 *
7285 * @return - -1 if it's not a good idea to relocate this block group, 0 if its
7286 * ok to go ahead and try.
7287 */
7288int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
7289{
7290	struct btrfs_block_group_cache *block_group;
7291	struct btrfs_space_info *space_info;
7292	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
7293	struct btrfs_device *device;
7294	u64 min_free;
7295	u64 dev_min = 1;
7296	u64 dev_nr = 0;
7297	u64 target;
7298	int index;
7299	int full = 0;
7300	int ret = 0;
7301
7302	block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
7303
7304	/* odd, couldn't find the block group, leave it alone */
7305	if (!block_group)
7306		return -1;
7307
7308	min_free = btrfs_block_group_used(&block_group->item);
7309
7310	/* no bytes used, we're good */
7311	if (!min_free)
7312		goto out;
7313
7314	space_info = block_group->space_info;
7315	spin_lock(&space_info->lock);
7316
7317	full = space_info->full;
7318
7319	/*
7320	 * if this is the last block group we have in this space, we can't
7321	 * relocate it unless we're able to allocate a new chunk below.
7322	 *
7323	 * Otherwise, we need to make sure we have room in the space to handle
7324	 * all of the extents from this block group.  If we can, we're good
7325	 */
7326	if ((space_info->total_bytes != block_group->key.offset) &&
7327	    (space_info->bytes_used + space_info->bytes_reserved +
7328	     space_info->bytes_pinned + space_info->bytes_readonly +
7329	     min_free < space_info->total_bytes)) {
7330		spin_unlock(&space_info->lock);
7331		goto out;
7332	}
7333	spin_unlock(&space_info->lock);
7334
7335	/*
7336	 * ok we don't have enough space, but maybe we have free space on our
7337	 * devices to allocate new chunks for relocation, so loop through our
7338	 * alloc devices and guess if we have enough space.  if this block
7339	 * group is going to be restriped, run checks against the target
7340	 * profile instead of the current one.
7341	 */
7342	ret = -1;
7343
7344	/*
7345	 * index:
7346	 *      0: raid10
7347	 *      1: raid1
7348	 *      2: dup
7349	 *      3: raid0
7350	 *      4: single
7351	 */
7352	target = get_restripe_target(root->fs_info, block_group->flags);
7353	if (target) {
7354		index = __get_block_group_index(extended_to_chunk(target));
7355	} else {
7356		/*
7357		 * this is just a balance, so if we were marked as full
7358		 * we know there is no space for a new chunk
7359		 */
7360		if (full)
7361			goto out;
7362
7363		index = get_block_group_index(block_group);
7364	}
7365
7366	if (index == 0) {
7367		dev_min = 4;
7368		/* Divide by 2 */
7369		min_free >>= 1;
7370	} else if (index == 1) {
7371		dev_min = 2;
7372	} else if (index == 2) {
7373		/* Multiply by 2 */
7374		min_free <<= 1;
7375	} else if (index == 3) {
7376		dev_min = fs_devices->rw_devices;
7377		do_div(min_free, dev_min);
7378	}
7379
7380	mutex_lock(&root->fs_info->chunk_mutex);
7381	list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
7382		u64 dev_offset;
7383
7384		/*
7385		 * check to make sure we can actually find a chunk with enough
7386		 * space to fit our block group in.
7387		 */
7388		if (device->total_bytes > device->bytes_used + min_free) {
7389			ret = find_free_dev_extent(device, min_free,
7390						   &dev_offset, NULL);
7391			if (!ret)
7392				dev_nr++;
7393
7394			if (dev_nr >= dev_min)
7395				break;
7396
7397			ret = -1;
7398		}
7399	}
7400	mutex_unlock(&root->fs_info->chunk_mutex);
7401out:
7402	btrfs_put_block_group(block_group);
7403	return ret;
7404}
7405
7406static int find_first_block_group(struct btrfs_root *root,
7407		struct btrfs_path *path, struct btrfs_key *key)
7408{
7409	int ret = 0;
7410	struct btrfs_key found_key;
7411	struct extent_buffer *leaf;
7412	int slot;
7413
7414	ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
7415	if (ret < 0)
7416		goto out;
7417
7418	while (1) {
7419		slot = path->slots[0];
7420		leaf = path->nodes[0];
7421		if (slot >= btrfs_header_nritems(leaf)) {
7422			ret = btrfs_next_leaf(root, path);
7423			if (ret == 0)
7424				continue;
7425			if (ret < 0)
7426				goto out;
7427			break;
7428		}
7429		btrfs_item_key_to_cpu(leaf, &found_key, slot);
7430
7431		if (found_key.objectid >= key->objectid &&
7432		    found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
 
 
 
 
 
 
 
 
 
 
 
7433			ret = 0;
7434			goto out;
7435		}
7436		path->slots[0]++;
7437	}
7438out:
7439	return ret;
7440}
7441
7442void btrfs_put_block_group_cache(struct btrfs_fs_info *info)
7443{
7444	struct btrfs_block_group_cache *block_group;
7445	u64 last = 0;
7446
7447	while (1) {
7448		struct inode *inode;
7449
7450		block_group = btrfs_lookup_first_block_group(info, last);
7451		while (block_group) {
7452			spin_lock(&block_group->lock);
7453			if (block_group->iref)
7454				break;
7455			spin_unlock(&block_group->lock);
7456			block_group = next_block_group(info->tree_root,
7457						       block_group);
7458		}
7459		if (!block_group) {
7460			if (last == 0)
7461				break;
7462			last = 0;
7463			continue;
7464		}
7465
7466		inode = block_group->inode;
7467		block_group->iref = 0;
7468		block_group->inode = NULL;
7469		spin_unlock(&block_group->lock);
7470		iput(inode);
7471		last = block_group->key.objectid + block_group->key.offset;
7472		btrfs_put_block_group(block_group);
7473	}
7474}
7475
7476int btrfs_free_block_groups(struct btrfs_fs_info *info)
7477{
7478	struct btrfs_block_group_cache *block_group;
7479	struct btrfs_space_info *space_info;
7480	struct btrfs_caching_control *caching_ctl;
7481	struct rb_node *n;
7482
7483	down_write(&info->extent_commit_sem);
7484	while (!list_empty(&info->caching_block_groups)) {
7485		caching_ctl = list_entry(info->caching_block_groups.next,
7486					 struct btrfs_caching_control, list);
7487		list_del(&caching_ctl->list);
7488		put_caching_control(caching_ctl);
7489	}
7490	up_write(&info->extent_commit_sem);
7491
7492	spin_lock(&info->block_group_cache_lock);
7493	while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
7494		block_group = rb_entry(n, struct btrfs_block_group_cache,
7495				       cache_node);
7496		rb_erase(&block_group->cache_node,
7497			 &info->block_group_cache_tree);
7498		spin_unlock(&info->block_group_cache_lock);
7499
7500		down_write(&block_group->space_info->groups_sem);
7501		list_del(&block_group->list);
7502		up_write(&block_group->space_info->groups_sem);
7503
7504		if (block_group->cached == BTRFS_CACHE_STARTED)
7505			wait_block_group_cache_done(block_group);
7506
7507		/*
7508		 * We haven't cached this block group, which means we could
7509		 * possibly have excluded extents on this block group.
 
7510		 */
7511		if (block_group->cached == BTRFS_CACHE_NO)
7512			free_excluded_extents(info->extent_root, block_group);
7513
7514		btrfs_remove_free_space_cache(block_group);
7515		btrfs_put_block_group(block_group);
7516
7517		spin_lock(&info->block_group_cache_lock);
7518	}
7519	spin_unlock(&info->block_group_cache_lock);
7520
7521	/* now that all the block groups are freed, go through and
7522	 * free all the space_info structs.  This is only called during
7523	 * the final stages of unmount, and so we know nobody is
7524	 * using them.  We call synchronize_rcu() once before we start,
7525	 * just to be on the safe side.
7526	 */
7527	synchronize_rcu();
7528
7529	release_global_block_rsv(info);
7530
7531	while(!list_empty(&info->space_info)) {
7532		space_info = list_entry(info->space_info.next,
7533					struct btrfs_space_info,
7534					list);
7535		if (space_info->bytes_pinned > 0 ||
7536		    space_info->bytes_reserved > 0 ||
7537		    space_info->bytes_may_use > 0) {
7538			WARN_ON(1);
7539			dump_space_info(space_info, 0, 0);
7540		}
7541		list_del(&space_info->list);
7542		kfree(space_info);
7543	}
7544	return 0;
7545}
7546
7547static void __link_block_group(struct btrfs_space_info *space_info,
7548			       struct btrfs_block_group_cache *cache)
7549{
7550	int index = get_block_group_index(cache);
 
 
7551
7552	down_write(&space_info->groups_sem);
7553	list_add_tail(&cache->list, &space_info->block_groups[index]);
7554	up_write(&space_info->groups_sem);
7555}
7556
7557int btrfs_read_block_groups(struct btrfs_root *root)
7558{
7559	struct btrfs_path *path;
7560	int ret;
7561	struct btrfs_block_group_cache *cache;
7562	struct btrfs_fs_info *info = root->fs_info;
7563	struct btrfs_space_info *space_info;
7564	struct btrfs_key key;
7565	struct btrfs_key found_key;
7566	struct extent_buffer *leaf;
7567	int need_clear = 0;
7568	u64 cache_gen;
7569
7570	root = info->extent_root;
7571	key.objectid = 0;
7572	key.offset = 0;
7573	btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
7574	path = btrfs_alloc_path();
7575	if (!path)
7576		return -ENOMEM;
7577	path->reada = 1;
7578
7579	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
7580	if (btrfs_test_opt(root, SPACE_CACHE) &&
7581	    btrfs_super_generation(root->fs_info->super_copy) != cache_gen)
7582		need_clear = 1;
7583	if (btrfs_test_opt(root, CLEAR_CACHE))
7584		need_clear = 1;
7585
7586	while (1) {
7587		ret = find_first_block_group(root, path, &key);
7588		if (ret > 0)
7589			break;
7590		if (ret != 0)
7591			goto error;
7592		leaf = path->nodes[0];
7593		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
7594		cache = kzalloc(sizeof(*cache), GFP_NOFS);
7595		if (!cache) {
7596			ret = -ENOMEM;
7597			goto error;
7598		}
7599		cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
7600						GFP_NOFS);
7601		if (!cache->free_space_ctl) {
7602			kfree(cache);
7603			ret = -ENOMEM;
7604			goto error;
7605		}
7606
7607		atomic_set(&cache->count, 1);
7608		spin_lock_init(&cache->lock);
7609		cache->fs_info = info;
7610		INIT_LIST_HEAD(&cache->list);
7611		INIT_LIST_HEAD(&cache->cluster_list);
7612
7613		if (need_clear)
7614			cache->disk_cache_state = BTRFS_DC_CLEAR;
7615
7616		read_extent_buffer(leaf, &cache->item,
7617				   btrfs_item_ptr_offset(leaf, path->slots[0]),
7618				   sizeof(cache->item));
7619		memcpy(&cache->key, &found_key, sizeof(found_key));
7620
7621		key.objectid = found_key.objectid + found_key.offset;
7622		btrfs_release_path(path);
7623		cache->flags = btrfs_block_group_flags(&cache->item);
7624		cache->sectorsize = root->sectorsize;
7625
7626		btrfs_init_free_space_ctl(cache);
7627
7628		/*
7629		 * We need to exclude the super stripes now so that the space
7630		 * info has super bytes accounted for, otherwise we'll think
7631		 * we have more space than we actually do.
7632		 */
7633		exclude_super_stripes(root, cache);
7634
7635		/*
7636		 * check for two cases, either we are full, and therefore
7637		 * don't need to bother with the caching work since we won't
7638		 * find any space, or we are empty, and we can just add all
7639		 * the space in and be done with it.  This saves us _alot_ of
7640		 * time, particularly in the full case.
7641		 */
7642		if (found_key.offset == btrfs_block_group_used(&cache->item)) {
7643			cache->last_byte_to_unpin = (u64)-1;
7644			cache->cached = BTRFS_CACHE_FINISHED;
7645			free_excluded_extents(root, cache);
7646		} else if (btrfs_block_group_used(&cache->item) == 0) {
7647			cache->last_byte_to_unpin = (u64)-1;
7648			cache->cached = BTRFS_CACHE_FINISHED;
7649			add_new_free_space(cache, root->fs_info,
7650					   found_key.objectid,
7651					   found_key.objectid +
7652					   found_key.offset);
7653			free_excluded_extents(root, cache);
7654		}
7655
7656		ret = update_space_info(info, cache->flags, found_key.offset,
7657					btrfs_block_group_used(&cache->item),
7658					&space_info);
7659		BUG_ON(ret); /* -ENOMEM */
7660		cache->space_info = space_info;
7661		spin_lock(&cache->space_info->lock);
7662		cache->space_info->bytes_readonly += cache->bytes_super;
7663		spin_unlock(&cache->space_info->lock);
7664
7665		__link_block_group(space_info, cache);
7666
7667		ret = btrfs_add_block_group_cache(root->fs_info, cache);
7668		BUG_ON(ret); /* Logic error */
7669
7670		set_avail_alloc_bits(root->fs_info, cache->flags);
7671		if (btrfs_chunk_readonly(root, cache->key.objectid))
7672			set_block_group_ro(cache, 1);
7673	}
7674
7675	list_for_each_entry_rcu(space_info, &root->fs_info->space_info, list) {
7676		if (!(get_alloc_profile(root, space_info->flags) &
7677		      (BTRFS_BLOCK_GROUP_RAID10 |
7678		       BTRFS_BLOCK_GROUP_RAID1 |
7679		       BTRFS_BLOCK_GROUP_DUP)))
7680			continue;
7681		/*
7682		 * avoid allocating from un-mirrored block group if there are
7683		 * mirrored block groups.
7684		 */
7685		list_for_each_entry(cache, &space_info->block_groups[3], list)
7686			set_block_group_ro(cache, 1);
7687		list_for_each_entry(cache, &space_info->block_groups[4], list)
7688			set_block_group_ro(cache, 1);
7689	}
7690
7691	init_global_block_rsv(info);
7692	ret = 0;
7693error:
7694	btrfs_free_path(path);
7695	return ret;
7696}
7697
7698int btrfs_make_block_group(struct btrfs_trans_handle *trans,
7699			   struct btrfs_root *root, u64 bytes_used,
7700			   u64 type, u64 chunk_objectid, u64 chunk_offset,
7701			   u64 size)
 
 
 
 
 
 
7702{
7703	int ret;
7704	struct btrfs_root *extent_root;
7705	struct btrfs_block_group_cache *cache;
7706
7707	extent_root = root->fs_info->extent_root;
7708
7709	root->fs_info->last_trans_log_full_commit = trans->transid;
7710
7711	cache = kzalloc(sizeof(*cache), GFP_NOFS);
7712	if (!cache)
7713		return -ENOMEM;
7714	cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl),
7715					GFP_NOFS);
7716	if (!cache->free_space_ctl) {
7717		kfree(cache);
7718		return -ENOMEM;
7719	}
7720
7721	cache->key.objectid = chunk_offset;
7722	cache->key.offset = size;
7723	cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
7724	cache->sectorsize = root->sectorsize;
7725	cache->fs_info = root->fs_info;
7726
7727	atomic_set(&cache->count, 1);
7728	spin_lock_init(&cache->lock);
7729	INIT_LIST_HEAD(&cache->list);
7730	INIT_LIST_HEAD(&cache->cluster_list);
7731
7732	btrfs_init_free_space_ctl(cache);
7733
7734	btrfs_set_block_group_used(&cache->item, bytes_used);
7735	btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
7736	cache->flags = type;
7737	btrfs_set_block_group_flags(&cache->item, type);
7738
7739	cache->last_byte_to_unpin = (u64)-1;
7740	cache->cached = BTRFS_CACHE_FINISHED;
7741	exclude_super_stripes(root, cache);
7742
7743	add_new_free_space(cache, root->fs_info, chunk_offset,
7744			   chunk_offset + size);
7745
7746	free_excluded_extents(root, cache);
7747
7748	ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
7749				&cache->space_info);
7750	BUG_ON(ret); /* -ENOMEM */
7751	update_global_block_rsv(root->fs_info);
7752
7753	spin_lock(&cache->space_info->lock);
7754	cache->space_info->bytes_readonly += cache->bytes_super;
7755	spin_unlock(&cache->space_info->lock);
7756
7757	__link_block_group(cache->space_info, cache);
7758
7759	ret = btrfs_add_block_group_cache(root->fs_info, cache);
7760	BUG_ON(ret); /* Logic error */
7761
7762	ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
7763				sizeof(cache->item));
7764	if (ret) {
7765		btrfs_abort_transaction(trans, extent_root, ret);
7766		return ret;
7767	}
7768
7769	set_avail_alloc_bits(extent_root->fs_info, type);
7770
7771	return 0;
7772}
7773
7774static void clear_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
7775{
7776	u64 extra_flags = chunk_to_extended(flags) &
7777				BTRFS_EXTENDED_PROFILE_MASK;
7778
7779	if (flags & BTRFS_BLOCK_GROUP_DATA)
7780		fs_info->avail_data_alloc_bits &= ~extra_flags;
7781	if (flags & BTRFS_BLOCK_GROUP_METADATA)
7782		fs_info->avail_metadata_alloc_bits &= ~extra_flags;
7783	if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
7784		fs_info->avail_system_alloc_bits &= ~extra_flags;
7785}
7786
7787int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
7788			     struct btrfs_root *root, u64 group_start)
7789{
7790	struct btrfs_path *path;
7791	struct btrfs_block_group_cache *block_group;
7792	struct btrfs_free_cluster *cluster;
7793	struct btrfs_root *tree_root = root->fs_info->tree_root;
7794	struct btrfs_key key;
7795	struct inode *inode;
7796	int ret;
7797	int index;
7798	int factor;
7799
7800	root = root->fs_info->extent_root;
7801
7802	block_group = btrfs_lookup_block_group(root->fs_info, group_start);
7803	BUG_ON(!block_group);
7804	BUG_ON(!block_group->ro);
7805
7806	/*
7807	 * Free the reserved super bytes from this block group before
7808	 * remove it.
7809	 */
7810	free_excluded_extents(root, block_group);
7811
7812	memcpy(&key, &block_group->key, sizeof(key));
7813	index = get_block_group_index(block_group);
7814	if (block_group->flags & (BTRFS_BLOCK_GROUP_DUP |
7815				  BTRFS_BLOCK_GROUP_RAID1 |
7816				  BTRFS_BLOCK_GROUP_RAID10))
7817		factor = 2;
7818	else
7819		factor = 1;
7820
7821	/* make sure this block group isn't part of an allocation cluster */
7822	cluster = &root->fs_info->data_alloc_cluster;
7823	spin_lock(&cluster->refill_lock);
7824	btrfs_return_cluster_to_free_space(block_group, cluster);
7825	spin_unlock(&cluster->refill_lock);
7826
7827	/*
7828	 * make sure this block group isn't part of a metadata
7829	 * allocation cluster
7830	 */
7831	cluster = &root->fs_info->meta_alloc_cluster;
7832	spin_lock(&cluster->refill_lock);
7833	btrfs_return_cluster_to_free_space(block_group, cluster);
7834	spin_unlock(&cluster->refill_lock);
7835
7836	path = btrfs_alloc_path();
7837	if (!path) {
7838		ret = -ENOMEM;
7839		goto out;
7840	}
7841
7842	inode = lookup_free_space_inode(tree_root, block_group, path);
7843	if (!IS_ERR(inode)) {
7844		ret = btrfs_orphan_add(trans, inode);
7845		if (ret) {
7846			btrfs_add_delayed_iput(inode);
7847			goto out;
7848		}
7849		clear_nlink(inode);
7850		/* One for the block groups ref */
7851		spin_lock(&block_group->lock);
7852		if (block_group->iref) {
7853			block_group->iref = 0;
7854			block_group->inode = NULL;
7855			spin_unlock(&block_group->lock);
7856			iput(inode);
7857		} else {
7858			spin_unlock(&block_group->lock);
7859		}
7860		/* One for our lookup ref */
7861		btrfs_add_delayed_iput(inode);
7862	}
7863
7864	key.objectid = BTRFS_FREE_SPACE_OBJECTID;
7865	key.offset = block_group->key.objectid;
7866	key.type = 0;
7867
7868	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
7869	if (ret < 0)
7870		goto out;
7871	if (ret > 0)
7872		btrfs_release_path(path);
7873	if (ret == 0) {
7874		ret = btrfs_del_item(trans, tree_root, path);
7875		if (ret)
7876			goto out;
7877		btrfs_release_path(path);
7878	}
7879
7880	spin_lock(&root->fs_info->block_group_cache_lock);
7881	rb_erase(&block_group->cache_node,
7882		 &root->fs_info->block_group_cache_tree);
7883	spin_unlock(&root->fs_info->block_group_cache_lock);
7884
7885	down_write(&block_group->space_info->groups_sem);
7886	/*
7887	 * we must use list_del_init so people can check to see if they
7888	 * are still on the list after taking the semaphore
7889	 */
7890	list_del_init(&block_group->list);
7891	if (list_empty(&block_group->space_info->block_groups[index]))
7892		clear_avail_alloc_bits(root->fs_info, block_group->flags);
7893	up_write(&block_group->space_info->groups_sem);
7894
7895	if (block_group->cached == BTRFS_CACHE_STARTED)
7896		wait_block_group_cache_done(block_group);
7897
7898	btrfs_remove_free_space_cache(block_group);
7899
7900	spin_lock(&block_group->space_info->lock);
7901	block_group->space_info->total_bytes -= block_group->key.offset;
7902	block_group->space_info->bytes_readonly -= block_group->key.offset;
7903	block_group->space_info->disk_total -= block_group->key.offset * factor;
7904	spin_unlock(&block_group->space_info->lock);
7905
7906	memcpy(&key, &block_group->key, sizeof(key));
7907
7908	btrfs_clear_space_info_full(root->fs_info);
7909
7910	btrfs_put_block_group(block_group);
7911	btrfs_put_block_group(block_group);
7912
7913	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
7914	if (ret > 0)
7915		ret = -EIO;
7916	if (ret < 0)
7917		goto out;
7918
7919	ret = btrfs_del_item(trans, root, path);
7920out:
7921	btrfs_free_path(path);
7922	return ret;
7923}
7924
7925int btrfs_init_space_info(struct btrfs_fs_info *fs_info)
7926{
7927	struct btrfs_space_info *space_info;
7928	struct btrfs_super_block *disk_super;
7929	u64 features;
7930	u64 flags;
7931	int mixed = 0;
7932	int ret;
7933
7934	disk_super = fs_info->super_copy;
7935	if (!btrfs_super_root(disk_super))
7936		return 1;
7937
7938	features = btrfs_super_incompat_flags(disk_super);
7939	if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
7940		mixed = 1;
7941
7942	flags = BTRFS_BLOCK_GROUP_SYSTEM;
7943	ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7944	if (ret)
7945		goto out;
7946
7947	if (mixed) {
7948		flags = BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA;
7949		ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7950	} else {
7951		flags = BTRFS_BLOCK_GROUP_METADATA;
7952		ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7953		if (ret)
7954			goto out;
7955
7956		flags = BTRFS_BLOCK_GROUP_DATA;
7957		ret = update_space_info(fs_info, flags, 0, 0, &space_info);
7958	}
7959out:
7960	return ret;
7961}
7962
7963int btrfs_error_unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
7964{
7965	return unpin_extent_range(root, start, end);
7966}
7967
7968int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
7969			       u64 num_bytes, u64 *actual_bytes)
7970{
7971	return btrfs_discard_extent(root, bytenr, num_bytes, actual_bytes);
7972}
7973
7974int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range)
7975{
7976	struct btrfs_fs_info *fs_info = root->fs_info;
7977	struct btrfs_block_group_cache *cache = NULL;
7978	u64 group_trimmed;
 
7979	u64 start;
7980	u64 end;
7981	u64 trimmed = 0;
7982	u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
 
 
 
7983	int ret = 0;
7984
 
 
 
7985	/*
7986	 * try to trim all FS space, our block group may start from non-zero.
 
7987	 */
7988	if (range->len == total_bytes)
7989		cache = btrfs_lookup_first_block_group(fs_info, range->start);
7990	else
7991		cache = btrfs_lookup_block_group(fs_info, range->start);
7992
7993	while (cache) {
7994		if (cache->key.objectid >= (range->start + range->len)) {
 
7995			btrfs_put_block_group(cache);
7996			break;
7997		}
7998
7999		start = max(range->start, cache->key.objectid);
8000		end = min(range->start + range->len,
8001				cache->key.objectid + cache->key.offset);
8002
8003		if (end - start >= range->minlen) {
8004			if (!block_group_cache_done(cache)) {
8005				ret = cache_block_group(cache, NULL, root, 0);
8006				if (!ret)
8007					wait_block_group_cache_done(cache);
 
 
 
8008			}
8009			ret = btrfs_trim_block_group(cache,
8010						     &group_trimmed,
8011						     start,
8012						     end,
8013						     range->minlen);
8014
8015			trimmed += group_trimmed;
8016			if (ret) {
8017				btrfs_put_block_group(cache);
8018				break;
 
8019			}
8020		}
 
 
 
 
 
 
 
 
 
 
 
8021
8022		cache = next_block_group(fs_info->tree_root, cache);
 
 
 
 
 
 
 
8023	}
 
8024
 
 
 
 
8025	range->len = trimmed;
8026	return ret;
 
 
8027}