Commit f1ee3b88 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-5.11-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux 

Pull btrfs updates from David Sterba:
 "We have a mix of all kinds of changes, feature updates, core stuff,
  performance improvements and lots of cleanups and preparatory changes.

  User visible:

   - export filesystem generation in sysfs

   - new features for mount option 'rescue':
       - what's currently supported is exported in sysfs
       - 'ignorebadroots'/'ibadroots' - continue even if some essential
         tree roots are not usable (extent, uuid, data reloc, device,
         csum, free space)
       - 'ignoredatacsums'/'idatacsums' - skip checksum verification on
         data
       - 'all' - now enables 'ignorebadroots' + 'ignoredatacsums' +
         'nologreplay'

   - export read mirror policy settings to sysfs, new policies will be
     added in the future

   - remove inode number cache feature (mount -o inode_cache), obsoleted
     in 5.9

  User visible fixes:

   - async discard scheduling fixes on high loads

   - update inode byte counter atomically so stat() does not report
     wrong value in some cases

   - free space tree fixes:
       - correctly report status of v2 after remount
       - clear v1 cache inodes when v2 is newly enabled after remount

  Core:

   - switch own tree lock implementation to standard rw semaphore:
       - one-level lock nesting is not required anymore, the last use of
         this was in free space that's now loaded asynchronously
       - own implementation of adaptive spinning before taking mutex has
         been part of rwsem
       - performance seems to be better in general, much better (+tens
         of percents) for some workloads
       - lockdep does not complain

   - finish direct IO conversion to iomap infrastructure, remove
     temporary workaround for DSYNC after iomap API updates

   - preparatory work to support data and metadata blocks smaller than
     page:
       - generalize code that assumes sectorsize == PAGE_SIZE, lots of
         refactoring
       - planned namely for 64K pages (eg. arm64, ppc64)
       - scrub read-only support

   - preparatory work for zoned allocation mode (SMR/ZBC/ZNS friendly):
       - disable incompatible features
       - round-robin superblock write

   - free space cache (v1) is loaded asynchronously, remove tree path
     recursion

   - slightly improved time tacking for transaction kthread wake ups

  Performance improvements (note that the numbers depend on load type or
  other features and weren't run on the same machine):

   - skip unnecessary work:
       - do not start readahead for csum tree when scrubbing non-data
         block groups
       - do not start and wait for delalloc on snapshot roots on
         transaction commit
       - fix race when defragmenting leads to unnecessary IO

   - dbench speedups (+throughput%/-max latency%):
       - skip unnecessary searches for xattrs when logging an inode
         (+10.8/-8.2)
       - stop incrementing log batch when joining log transaction (1-2)
       - unlock path before checking if extent is shared during nocow
         writeback (+5.0/-20.5), on fio load +9.7% throughput/-9.8%
         runtime
       - several tree log improvements, eg. removing unnecessary
         operations, fixing races that lead to additional work
         (+12.7/-8.2)

   - tree-checker error branches annotated with unlikely() (+3%
     throughput)

  Other:

   - cleanups

   - lockdep fixes

   - more btrfs_inode conversions

   - error variable cleanups"

* tag 'for-5.11-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux: (198 commits)
  btrfs: scrub: allow scrub to work with subpage sectorsize
  btrfs: scrub: support subpage data scrub
  btrfs: scrub: support subpage tree block scrub
  btrfs: scrub: always allocate one full page for one sector for RAID56
  btrfs: scrub: reduce width of extent_len/stripe_len from 64 to 32 bits
  btrfs: refactor btrfs_lookup_bio_sums to handle out-of-order bvecs
  btrfs: remove btrfs_find_ordered_sum call from btrfs_lookup_bio_sums
  btrfs: handle sectorsize < PAGE_SIZE case for extent buffer accessors
  btrfs: update num_extent_pages to support subpage sized extent buffer
  btrfs: don't allow tree block to cross page boundary for subpage support
  btrfs: calculate inline extent buffer page size based on page size
  btrfs: factor out btree page submission code to a helper
  btrfs: make btrfs_verify_data_csum follow sector size
  btrfs: pass bio_offset to check_data_csum() directly
  btrfs: rename bio_offset of extent_submit_bio_start_t to dio_file_offset
  btrfs: fix lockdep warning when creating free space tree
  btrfs: skip space_cache v1 setup when not using it
  btrfs: remove free space items when disabling space cache v1
  btrfs: warn when remount will not change the free space tree
  btrfs: use superblock state to print space_cache mount option
  ...
parents a725cb4d b42fe98c

fs/btrfs/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ 
obj-$(CONFIG_BTRFS_FS) := btrfs.o



btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \

	   file-item.o inode-item.o inode-map.o disk-io.o \

	   file-item.o inode-item.o disk-io.o \

	   transaction.o inode.o file.o tree-defrag.o \

	   extent_map.o sysfs.o struct-funcs.o xattr.o ordered-data.o \

	   extent_io.o volumes.o async-thread.o ioctl.o locking.o orphan.o \
@@ -16,6 +16,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ 
btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o

btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o

btrfs-$(CONFIG_BTRFS_FS_REF_VERIFY) += ref-verify.o

btrfs-$(CONFIG_BLK_DEV_ZONED) += zoned.o



btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o \

	tests/extent-buffer-tests.o tests/btrfs-tests.o \

fs/btrfs/backref.c

+6 −13
Original line number Diff line number Diff line
@@ -783,8 +783,8 @@ static int add_missing_keys(struct btrfs_fs_info *fs_info, 
		BUG_ON(ref->key_for_search.type);

		BUG_ON(!ref->wanted_disk_byte);



		eb = read_tree_block(fs_info, ref->wanted_disk_byte, 0,

				     ref->level - 1, NULL);

		eb = read_tree_block(fs_info, ref->wanted_disk_byte,

				     ref->root_id, 0, ref->level - 1, NULL);

		if (IS_ERR(eb)) {

			free_pref(ref);

			return PTR_ERR(eb);
@@ -1331,7 +1331,7 @@ again: 
				struct extent_buffer *eb;



				eb = read_tree_block(fs_info, ref->parent, 0,

						     ref->level, NULL);

						     0, ref->level, NULL);

				if (IS_ERR(eb)) {

					ret = PTR_ERR(eb);

					goto out;
@@ -1341,14 +1341,12 @@ again: 
					goto out;

				}



				if (!path->skip_locking) {

				if (!path->skip_locking)

					btrfs_tree_read_lock(eb);

					btrfs_set_lock_blocking_read(eb);

				}

				ret = find_extent_in_eb(eb, bytenr,

							*extent_item_pos, &eie, ignore_offset);

				if (!path->skip_locking)

					btrfs_tree_read_unlock_blocking(eb);

					btrfs_tree_read_unlock(eb);

				free_extent_buffer(eb);

				if (ret < 0)

					goto out;
@@ -1671,13 +1669,11 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
	s64 bytes_left = ((s64)size) - 1;

	struct extent_buffer *eb = eb_in;

	struct btrfs_key found_key;

	int leave_spinning = path->leave_spinning;

	struct btrfs_inode_ref *iref;



	if (bytes_left >= 0)

		dest[bytes_left] = '\0';



	path->leave_spinning = 1;

	while (1) {

		bytes_left -= name_len;

		if (bytes_left >= 0)
@@ -1685,7 +1681,7 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
					   name_off, name_len);

		if (eb != eb_in) {

			if (!path->skip_locking)

				btrfs_tree_read_unlock_blocking(eb);

				btrfs_tree_read_unlock(eb);

			free_extent_buffer(eb);

		}

		ret = btrfs_find_item(fs_root, path, parent, 0,
@@ -1705,8 +1701,6 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
		eb = path->nodes[0];

		/* make sure we can use eb after releasing the path */

		if (eb != eb_in) {

			if (!path->skip_locking)

				btrfs_set_lock_blocking_read(eb);

			path->nodes[0] = NULL;

			path->locks[0] = 0;

		}
@@ -1723,7 +1717,6 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
	}



	btrfs_release_path(path);

	path->leave_spinning = leave_spinning;



	if (ret)

		return ERR_PTR(ret);

fs/btrfs/block-group.c

+125 −143
Original line number Diff line number Diff line
@@ -424,6 +424,23 @@ int btrfs_wait_block_group_cache_done(struct btrfs_block_group *cache) 
	return ret;

}



static bool space_cache_v1_done(struct btrfs_block_group *cache)

{

	bool ret;



	spin_lock(&cache->lock);

	ret = cache->cached != BTRFS_CACHE_FAST;

	spin_unlock(&cache->lock);



	return ret;

}



void btrfs_wait_space_cache_v1_finished(struct btrfs_block_group *cache,

				struct btrfs_caching_control *caching_ctl)

{

	wait_event(caching_ctl->wait, space_cache_v1_done(cache));

}



#ifdef CONFIG_BTRFS_DEBUG

static void fragment_free_space(struct btrfs_block_group *block_group)

{
@@ -639,11 +656,28 @@ static noinline void caching_thread(struct btrfs_work *work) 
	mutex_lock(&caching_ctl->mutex);

	down_read(&fs_info->commit_root_sem);



	if (btrfs_test_opt(fs_info, SPACE_CACHE)) {

		ret = load_free_space_cache(block_group);

		if (ret == 1) {

			ret = 0;

			goto done;

		}



		/*

		 * We failed to load the space cache, set ourselves to

		 * CACHE_STARTED and carry on.

		 */

		spin_lock(&block_group->lock);

		block_group->cached = BTRFS_CACHE_STARTED;

		spin_unlock(&block_group->lock);

		wake_up(&caching_ctl->wait);

	}



	if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

		ret = load_free_space_tree(caching_ctl);

	else

		ret = load_extent_tree_free(caching_ctl);



done:

	spin_lock(&block_group->lock);

	block_group->caching_ctl = NULL;

	block_group->cached = ret ? BTRFS_CACHE_ERROR : BTRFS_CACHE_FINISHED;
@@ -679,7 +713,7 @@ int btrfs_cache_block_group(struct btrfs_block_group *cache, int load_cache_only 
{

	DEFINE_WAIT(wait);

	struct btrfs_fs_info *fs_info = cache->fs_info;

	struct btrfs_caching_control *caching_ctl;

	struct btrfs_caching_control *caching_ctl = NULL;

	int ret = 0;



	caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
@@ -691,119 +725,41 @@ int btrfs_cache_block_group(struct btrfs_block_group *cache, int load_cache_only 
	init_waitqueue_head(&caching_ctl->wait);

	caching_ctl->block_group = cache;

	caching_ctl->progress = cache->start;

	refcount_set(&caching_ctl->count, 1);

	refcount_set(&caching_ctl->count, 2);

	btrfs_init_work(&caching_ctl->work, caching_thread, NULL, NULL);



	spin_lock(&cache->lock);

	/*

	 * This should be a rare occasion, but this could happen I think in the

	 * case where one thread starts to load the space cache info, and then

	 * some other thread starts a transaction commit which tries to do an

	 * allocation while the other thread is still loading the space cache

	 * info.  The previous loop should have kept us from choosing this block

	 * group, but if we've moved to the state where we will wait on caching

	 * block groups we need to first check if we're doing a fast load here,

	 * so we can wait for it to finish, otherwise we could end up allocating

	 * from a block group who's cache gets evicted for one reason or

	 * another.

	 */

	while (cache->cached == BTRFS_CACHE_FAST) {

		struct btrfs_caching_control *ctl;



		ctl = cache->caching_ctl;

		refcount_inc(&ctl->count);

		prepare_to_wait(&ctl->wait, &wait, TASK_UNINTERRUPTIBLE);

		spin_unlock(&cache->lock);



		schedule();



		finish_wait(&ctl->wait, &wait);

		btrfs_put_caching_control(ctl);

		spin_lock(&cache->lock);

	}



	if (cache->cached != BTRFS_CACHE_NO) {

		spin_unlock(&cache->lock);

		kfree(caching_ctl);

		return 0;



		caching_ctl = cache->caching_ctl;

		if (caching_ctl)

			refcount_inc(&caching_ctl->count);

		spin_unlock(&cache->lock);

		goto out;

	}

	WARN_ON(cache->caching_ctl);

	cache->caching_ctl = caching_ctl;

	if (btrfs_test_opt(fs_info, SPACE_CACHE))

		cache->cached = BTRFS_CACHE_FAST;

	spin_unlock(&cache->lock);



	if (btrfs_test_opt(fs_info, SPACE_CACHE)) {

		mutex_lock(&caching_ctl->mutex);

		ret = load_free_space_cache(cache);



		spin_lock(&cache->lock);

		if (ret == 1) {

			cache->caching_ctl = NULL;

			cache->cached = BTRFS_CACHE_FINISHED;

			cache->last_byte_to_unpin = (u64)-1;

			caching_ctl->progress = (u64)-1;

		} else {

			if (load_cache_only) {

				cache->caching_ctl = NULL;

				cache->cached = BTRFS_CACHE_NO;

			} else {

				cache->cached = BTRFS_CACHE_STARTED;

				cache->has_caching_ctl = 1;

			}

		}

		spin_unlock(&cache->lock);

#ifdef CONFIG_BTRFS_DEBUG

		if (ret == 1 &&

		    btrfs_should_fragment_free_space(cache)) {

			u64 bytes_used;



			spin_lock(&cache->space_info->lock);

			spin_lock(&cache->lock);

			bytes_used = cache->length - cache->used;

			cache->space_info->bytes_used += bytes_used >> 1;

			spin_unlock(&cache->lock);

			spin_unlock(&cache->space_info->lock);

			fragment_free_space(cache);

		}

#endif

		mutex_unlock(&caching_ctl->mutex);



		wake_up(&caching_ctl->wait);

		if (ret == 1) {

			btrfs_put_caching_control(caching_ctl);

			btrfs_free_excluded_extents(cache);

			return 0;

		}

	} else {

		/*

		 * We're either using the free space tree or no caching at all.

		 * Set cached to the appropriate value and wakeup any waiters.

		 */

		spin_lock(&cache->lock);

		if (load_cache_only) {

			cache->caching_ctl = NULL;

			cache->cached = BTRFS_CACHE_NO;

		} else {

	else

		cache->cached = BTRFS_CACHE_STARTED;

	cache->has_caching_ctl = 1;

		}

	spin_unlock(&cache->lock);

		wake_up(&caching_ctl->wait);

	}



	if (load_cache_only) {

		btrfs_put_caching_control(caching_ctl);

		return 0;

	}



	down_write(&fs_info->commit_root_sem);

	spin_lock(&fs_info->block_group_cache_lock);

	refcount_inc(&caching_ctl->count);

	list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);

	up_write(&fs_info->commit_root_sem);

	spin_unlock(&fs_info->block_group_cache_lock);



	btrfs_get_block_group(cache);



	btrfs_queue_work(fs_info->caching_workers, &caching_ctl->work);

out:

	if (load_cache_only && caching_ctl)

		btrfs_wait_space_cache_v1_finished(cache, caching_ctl);

	if (caching_ctl)

		btrfs_put_caching_control(caching_ctl);



	return ret;

}
@@ -892,8 +848,6 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	struct btrfs_path *path;

	struct btrfs_block_group *block_group;

	struct btrfs_free_cluster *cluster;

	struct btrfs_root *tree_root = fs_info->tree_root;

	struct btrfs_key key;

	struct inode *inode;

	struct kobject *kobj = NULL;

	int ret;
@@ -971,42 +925,9 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	spin_unlock(&trans->transaction->dirty_bgs_lock);

	mutex_unlock(&trans->transaction->cache_write_mutex);



	if (!IS_ERR(inode)) {

		ret = btrfs_orphan_add(trans, BTRFS_I(inode));

		if (ret) {

			btrfs_add_delayed_iput(inode);

			goto out;

		}

		clear_nlink(inode);

		/* One for the block groups ref */

		spin_lock(&block_group->lock);

		if (block_group->iref) {

			block_group->iref = 0;

			block_group->inode = NULL;

			spin_unlock(&block_group->lock);

			iput(inode);

		} else {

			spin_unlock(&block_group->lock);

		}

		/* One for our lookup ref */

		btrfs_add_delayed_iput(inode);

	}



	key.objectid = BTRFS_FREE_SPACE_OBJECTID;

	key.type = 0;

	key.offset = block_group->start;



	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);

	if (ret < 0)

		goto out;

	if (ret > 0)

		btrfs_release_path(path);

	if (ret == 0) {

		ret = btrfs_del_item(trans, tree_root, path);

	ret = btrfs_remove_free_space_inode(trans, inode, block_group);

	if (ret)

		goto out;

		btrfs_release_path(path);

	}



	spin_lock(&fs_info->block_group_cache_lock);

	rb_erase(&block_group->cache_node,
@@ -1043,7 +964,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
	if (block_group->cached == BTRFS_CACHE_STARTED)

		btrfs_wait_block_group_cache_done(block_group);

	if (block_group->has_caching_ctl) {

		down_write(&fs_info->commit_root_sem);

		spin_lock(&fs_info->block_group_cache_lock);

		if (!caching_ctl) {

			struct btrfs_caching_control *ctl;
@@ -1057,7 +978,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 
		}

		if (caching_ctl)

			list_del_init(&caching_ctl->list);

		up_write(&fs_info->commit_root_sem);

		spin_unlock(&fs_info->block_group_cache_lock);

		if (caching_ctl) {

			/* Once for the caching bgs list and once for us. */

			btrfs_put_caching_control(caching_ctl);
@@ -1723,6 +1644,7 @@ out: 
static int exclude_super_stripes(struct btrfs_block_group *cache)

{

	struct btrfs_fs_info *fs_info = cache->fs_info;

	const bool zoned = btrfs_is_zoned(fs_info);

	u64 bytenr;

	u64 *logical;

	int stripe_len;
@@ -1744,6 +1666,14 @@ static int exclude_super_stripes(struct btrfs_block_group *cache) 
		if (ret)

			return ret;



		/* Shouldn't have super stripes in sequential zones */

		if (zoned && nr) {

			btrfs_err(fs_info,

			"zoned: block group %llu must not contain super block",

				  cache->start);

			return -EUCLEAN;

		}



		while (nr--) {

			u64 len = min_t(u64, stripe_len,

				cache->start + cache->length - logical[nr]);
@@ -1805,7 +1735,7 @@ static struct btrfs_block_group *btrfs_create_block_group_cache( 
	INIT_LIST_HEAD(&cache->discard_list);

	INIT_LIST_HEAD(&cache->dirty_list);

	INIT_LIST_HEAD(&cache->io_list);

	btrfs_init_free_space_ctl(cache);

	btrfs_init_free_space_ctl(cache, cache->free_space_ctl);

	atomic_set(&cache->frozen, 0);

	mutex_init(&cache->free_space_lock);

	btrfs_init_full_stripe_locks_tree(&cache->full_stripe_locks_root);
@@ -1985,6 +1915,51 @@ error: 
	return ret;

}



static int fill_dummy_bgs(struct btrfs_fs_info *fs_info)

{

	struct extent_map_tree *em_tree = &fs_info->mapping_tree;

	struct btrfs_space_info *space_info;

	struct rb_node *node;

	int ret = 0;



	for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) {

		struct extent_map *em;

		struct map_lookup *map;

		struct btrfs_block_group *bg;



		em = rb_entry(node, struct extent_map, rb_node);

		map = em->map_lookup;

		bg = btrfs_create_block_group_cache(fs_info, em->start);

		if (!bg) {

			ret = -ENOMEM;

			break;

		}



		/* Fill dummy cache as FULL */

		bg->length = em->len;

		bg->flags = map->type;

		bg->last_byte_to_unpin = (u64)-1;

		bg->cached = BTRFS_CACHE_FINISHED;

		bg->used = em->len;

		bg->flags = map->type;

		ret = btrfs_add_block_group_cache(fs_info, bg);

		if (ret) {

			btrfs_remove_free_space_cache(bg);

			btrfs_put_block_group(bg);

			break;

		}

		btrfs_update_space_info(fs_info, bg->flags, em->len, em->len,

					0, &space_info);

		bg->space_info = space_info;

		link_block_group(bg);



		set_avail_alloc_bits(fs_info, bg->flags);

	}

	if (!ret)

		btrfs_init_global_block_rsv(fs_info);

	return ret;

}



int btrfs_read_block_groups(struct btrfs_fs_info *info)

{

	struct btrfs_path *path;
@@ -1995,6 +1970,9 @@ int btrfs_read_block_groups(struct btrfs_fs_info *info) 
	int need_clear = 0;

	u64 cache_gen;



	if (!info->extent_root)

		return fill_dummy_bgs(info);



	key.objectid = 0;

	key.offset = 0;

	key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
@@ -2152,6 +2130,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, 
	cache->flags = type;

	cache->last_byte_to_unpin = (u64)-1;

	cache->cached = BTRFS_CACHE_FINISHED;

	if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))

		cache->needs_free_space = 1;

	ret = exclude_super_stripes(cache);

	if (ret) {
@@ -2361,6 +2340,9 @@ static int cache_save_setup(struct btrfs_block_group *block_group, 
	int retries = 0;

	int ret = 0;



	if (!btrfs_test_opt(fs_info, SPACE_CACHE))

		return 0;



	/*

	 * If this block group is smaller than 100 megs don't bother caching the

	 * block group.
@@ -2401,7 +2383,7 @@ again: 
	 * time.

	 */

	BTRFS_I(inode)->generation = 0;

	ret = btrfs_update_inode(trans, root, inode);

	ret = btrfs_update_inode(trans, root, BTRFS_I(inode));

	if (ret) {

		/*

		 * So theoretically we could recover from this, simply set the
@@ -3307,14 +3289,14 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info) 
	struct btrfs_caching_control *caching_ctl;

	struct rb_node *n;



	down_write(&info->commit_root_sem);

	spin_lock(&info->block_group_cache_lock);

	while (!list_empty(&info->caching_block_groups)) {

		caching_ctl = list_entry(info->caching_block_groups.next,

					 struct btrfs_caching_control, list);

		list_del(&caching_ctl->list);

		btrfs_put_caching_control(caching_ctl);

	}

	up_write(&info->commit_root_sem);

	spin_unlock(&info->block_group_cache_lock);



	spin_lock(&info->unused_bgs_lock);

	while (!list_empty(&info->unused_bgs)) {

fs/btrfs/block-group.h

+2 −0
Original line number Diff line number Diff line
@@ -268,6 +268,8 @@ void check_system_chunk(struct btrfs_trans_handle *trans, const u64 type); 
u64 btrfs_get_alloc_profile(struct btrfs_fs_info *fs_info, u64 orig_flags);

void btrfs_put_block_group_cache(struct btrfs_fs_info *info);

int btrfs_free_block_groups(struct btrfs_fs_info *info);

void btrfs_wait_space_cache_v1_finished(struct btrfs_block_group *cache,

				struct btrfs_caching_control *caching_ctl);



static inline u64 btrfs_data_alloc_profile(struct btrfs_fs_info *fs_info)

{

fs/btrfs/block-rsv.c

+8 −0
Original line number Diff line number Diff line
@@ -426,6 +426,14 @@ void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) 
	fs_info->delayed_block_rsv.space_info = space_info;

	fs_info->delayed_refs_rsv.space_info = space_info;



	/*

	 * Our various recovery options can leave us with NULL roots, so check

	 * here and just bail before we go dereferencing NULLs everywhere.

	 */

	if (!fs_info->extent_root || !fs_info->csum_root ||

	    !fs_info->dev_root || !fs_info->chunk_root || !fs_info->tree_root)

		return;



	fs_info->extent_root->block_rsv = &fs_info->delayed_refs_rsv;

	fs_info->csum_root->block_rsv = &fs_info->delayed_refs_rsv;

	fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;

CRA Git | Maintained and supported by SUSTech CRA and CCSE