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

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

Pull more btrfs updates from David Sterba:
 "Fixes that arrived after the merge window freeze, mostly stable
  material.

   - fix race in tree-mod-log element tracking

   - fix bio flushing inside extent writepages

   - fix assertion when in-memory tracking of discarded extents finds an
     empty tree (eg. after adding a new device)

   - update logic of temporary read-only block groups to take into
     account overcommit

   - fix some fixup worker corner cases:
       - page could not go through proper COW cycle and the dirty status
         is lost due to page migration
       - deadlock if delayed allocation is performed under page lock

   - fix send emitting invalid clones within the same file

   - fix statfs reporting 0 free space when global block reserve size is
     larger than remaining free space but there is still space for new
     chunks"

* tag 'for-5.6-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
  btrfs: do not zero f_bavail if we have available space
  Btrfs: send, fix emission of invalid clone operations within the same file
  btrfs: do not do delalloc reservation under page lock
  btrfs: drop the -EBUSY case in __extent_writepage_io
  Btrfs: keep pages dirty when using btrfs_writepage_fixup_worker
  btrfs: take overcommit into account in inc_block_group_ro
  btrfs: fix force usage in inc_block_group_ro
  btrfs: Correctly handle empty trees in find_first_clear_extent_bit
  btrfs: flush write bio if we loop in extent_write_cache_pages
  Btrfs: fix race between adding and putting tree mod seq elements and nodes
parents e17ac02b d55966c4

fs/btrfs/block-group.c

+27 −12
Original line number Diff line number Diff line
@@ -1191,7 +1191,6 @@ static int inc_block_group_ro(struct btrfs_block_group *cache, int force) 
{

	struct btrfs_space_info *sinfo = cache->space_info;

	u64 num_bytes;

	u64 sinfo_used;

	int ret = -ENOSPC;



	spin_lock(&sinfo->lock);
@@ -1205,19 +1204,38 @@ static int inc_block_group_ro(struct btrfs_block_group *cache, int force) 


	num_bytes = cache->length - cache->reserved - cache->pinned -

		    cache->bytes_super - cache->used;

	sinfo_used = btrfs_space_info_used(sinfo, true);



	/*

	 * sinfo_used + num_bytes should always <= sinfo->total_bytes.

	 *

	 * Data never overcommits, even in mixed mode, so do just the straight

	 * check of left over space in how much we have allocated.

	 */

	if (force) {

		ret = 0;

	} else if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA) {

		u64 sinfo_used = btrfs_space_info_used(sinfo, true);



		/*

		 * Here we make sure if we mark this bg RO, we still have enough

		 * free space as buffer.

		 */

	if (sinfo_used + num_bytes <= sinfo->total_bytes) {

		if (sinfo_used + num_bytes <= sinfo->total_bytes)

			ret = 0;

	} else {

		/*

		 * We overcommit metadata, so we need to do the

		 * btrfs_can_overcommit check here, and we need to pass in

		 * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of

		 * leeway to allow us to mark this block group as read only.

		 */

		if (btrfs_can_overcommit(cache->fs_info, sinfo, num_bytes,

					 BTRFS_RESERVE_NO_FLUSH))

			ret = 0;

	}



	if (!ret) {

		sinfo->bytes_readonly += num_bytes;

		cache->ro++;

		list_add_tail(&cache->ro_list, &sinfo->ro_bgs);

		ret = 0;

	}

out:

	spin_unlock(&cache->lock);
@@ -1225,9 +1243,6 @@ out: 
	if (ret == -ENOSPC && btrfs_test_opt(cache->fs_info, ENOSPC_DEBUG)) {

		btrfs_info(cache->fs_info,

			"unable to make block group %llu ro", cache->start);

		btrfs_info(cache->fs_info,

			"sinfo_used=%llu bg_num_bytes=%llu",

			sinfo_used, num_bytes);

		btrfs_dump_space_info(cache->fs_info, cache->space_info, 0, 0);

	}

	return ret;
@@ -2225,7 +2240,7 @@ again: 
		}

	}



	ret = inc_block_group_ro(cache, !do_chunk_alloc);

	ret = inc_block_group_ro(cache, 0);

	if (!do_chunk_alloc)

		goto unlock_out;

	if (!ret)

fs/btrfs/ctree.c

+2 −6
Original line number Diff line number Diff line
@@ -326,12 +326,10 @@ u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info, 
			   struct seq_list *elem)

{

	write_lock(&fs_info->tree_mod_log_lock);

	spin_lock(&fs_info->tree_mod_seq_lock);

	if (!elem->seq) {

		elem->seq = btrfs_inc_tree_mod_seq(fs_info);

		list_add_tail(&elem->list, &fs_info->tree_mod_seq_list);

	}

	spin_unlock(&fs_info->tree_mod_seq_lock);

	write_unlock(&fs_info->tree_mod_log_lock);



	return elem->seq;
@@ -351,7 +349,7 @@ void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info, 
	if (!seq_putting)

		return;



	spin_lock(&fs_info->tree_mod_seq_lock);

	write_lock(&fs_info->tree_mod_log_lock);

	list_del(&elem->list);

	elem->seq = 0;
@@ -362,19 +360,17 @@ void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info, 
				 * blocker with lower sequence number exists, we

				 * cannot remove anything from the log

				 */

				spin_unlock(&fs_info->tree_mod_seq_lock);

				write_unlock(&fs_info->tree_mod_log_lock);

				return;

			}

			min_seq = cur_elem->seq;

		}

	}

	spin_unlock(&fs_info->tree_mod_seq_lock);



	/*

	 * anything that's lower than the lowest existing (read: blocked)

	 * sequence number can be removed from the tree.

	 */

	write_lock(&fs_info->tree_mod_log_lock);

	tm_root = &fs_info->tree_mod_log;

	for (node = rb_first(tm_root); node; node = next) {

		next = rb_next(node);

fs/btrfs/ctree.h

+2 −4
Original line number Diff line number Diff line
@@ -714,14 +714,12 @@ struct btrfs_fs_info { 
	atomic_t nr_delayed_iputs;

	wait_queue_head_t delayed_iputs_wait;



	/* this protects tree_mod_seq_list */

	spinlock_t tree_mod_seq_lock;

	atomic64_t tree_mod_seq;

	struct list_head tree_mod_seq_list;



	/* this protects tree_mod_log */

	/* this protects tree_mod_log and tree_mod_seq_list */

	rwlock_t tree_mod_log_lock;

	struct rb_root tree_mod_log;

	struct list_head tree_mod_seq_list;



	atomic_t async_delalloc_pages;

fs/btrfs/delayed-ref.c

+4 −4
Original line number Diff line number Diff line
@@ -492,7 +492,7 @@ void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans, 
	if (head->is_data)

		return;



	spin_lock(&fs_info->tree_mod_seq_lock);

	read_lock(&fs_info->tree_mod_log_lock);

	if (!list_empty(&fs_info->tree_mod_seq_list)) {

		struct seq_list *elem;
@@ -500,7 +500,7 @@ void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans, 
					struct seq_list, list);

		seq = elem->seq;

	}

	spin_unlock(&fs_info->tree_mod_seq_lock);

	read_unlock(&fs_info->tree_mod_log_lock);



again:

	for (node = rb_first_cached(&head->ref_tree); node;
@@ -518,7 +518,7 @@ int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq) 
	struct seq_list *elem;

	int ret = 0;



	spin_lock(&fs_info->tree_mod_seq_lock);

	read_lock(&fs_info->tree_mod_log_lock);

	if (!list_empty(&fs_info->tree_mod_seq_list)) {

		elem = list_first_entry(&fs_info->tree_mod_seq_list,

					struct seq_list, list);
@@ -531,7 +531,7 @@ int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info, u64 seq) 
		}

	}



	spin_unlock(&fs_info->tree_mod_seq_lock);

	read_unlock(&fs_info->tree_mod_log_lock);

	return ret;

}

fs/btrfs/disk-io.c

+0 −1
Original line number Diff line number Diff line
@@ -2697,7 +2697,6 @@ int __cold open_ctree(struct super_block *sb, 
	spin_lock_init(&fs_info->fs_roots_radix_lock);

	spin_lock_init(&fs_info->delayed_iput_lock);

	spin_lock_init(&fs_info->defrag_inodes_lock);

	spin_lock_init(&fs_info->tree_mod_seq_lock);

	spin_lock_init(&fs_info->super_lock);

	spin_lock_init(&fs_info->buffer_lock);

	spin_lock_init(&fs_info->unused_bgs_lock);

CRA Git | Maintained and supported by SUSTech CRA and CCSE