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

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

Pull btrfs fixes from David Sterba:
 "This is the first batch of fixes that usually arrive during the merge
  window code freeze. Regressions and stable material.

  Regressions:

   - fix deadlock in log sync in zoned mode

   - fix bugs in subpage mode still wrongly assuming sectorsize == page
     size

  Fixes:

   - fix missing kunmap of the Q stripe in RAID6

   - block group fixes:
      - fix race between extent freeing/allocation when using bitmaps
      - avoid double put of block group when emptying cluster

   - swapfile fixes:
      - fix swapfile writes vs running scrub
      - fix swapfile activation vs snapshot creation

   - fix stale data exposure after cloning a hole with NO_HOLES enabled

   - remove tree-checker check that does not work in case information
     from other leaves is necessary"

* tag 'for-5.12-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
  btrfs: zoned: fix deadlock on log sync
  btrfs: avoid double put of block group when emptying cluster
  btrfs: fix stale data exposure after cloning a hole with NO_HOLES enabled
  btrfs: tree-checker: do not error out if extent ref hash doesn't match
  btrfs: fix race between swap file activation and snapshot creation
  btrfs: fix race between writes to swap files and scrub
  btrfs: avoid checking for RO block group twice during nocow writeback
  btrfs: fix race between extent freeing/allocation when using bitmaps
  btrfs: make check_compressed_csum() to be subpage compatible
  btrfs: make btrfs_submit_compressed_read() subpage compatible
  btrfs: fix raid6 qstripe kmap
parents fe07bfda 6e37d245

fs/btrfs/block-group.c

+32 −1
Original line number Diff line number Diff line
@@ -1162,6 +1162,11 @@ static int inc_block_group_ro(struct btrfs_block_group *cache, int force) 
	spin_lock(&sinfo->lock);

	spin_lock(&cache->lock);



	if (cache->swap_extents) {

		ret = -ETXTBSY;

		goto out;

	}



	if (cache->ro) {

		cache->ro++;

		ret = 0;
@@ -2307,7 +2312,7 @@ int btrfs_inc_block_group_ro(struct btrfs_block_group *cache, 
	}



	ret = inc_block_group_ro(cache, 0);

	if (!do_chunk_alloc)

	if (!do_chunk_alloc || ret == -ETXTBSY)

		goto unlock_out;

	if (!ret)

		goto out;
@@ -2316,6 +2321,8 @@ int btrfs_inc_block_group_ro(struct btrfs_block_group *cache, 
	if (ret < 0)

		goto out;

	ret = inc_block_group_ro(cache, 0);

	if (ret == -ETXTBSY)

		goto unlock_out;

out:

	if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) {

		alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags);
@@ -3406,6 +3413,7 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info) 
		ASSERT(list_empty(&block_group->io_list));

		ASSERT(list_empty(&block_group->bg_list));

		ASSERT(refcount_read(&block_group->refs) == 1);

		ASSERT(block_group->swap_extents == 0);

		btrfs_put_block_group(block_group);



		spin_lock(&info->block_group_cache_lock);
@@ -3472,3 +3480,26 @@ void btrfs_unfreeze_block_group(struct btrfs_block_group *block_group) 
		__btrfs_remove_free_space_cache(block_group->free_space_ctl);

	}

}



bool btrfs_inc_block_group_swap_extents(struct btrfs_block_group *bg)

{

	bool ret = true;



	spin_lock(&bg->lock);

	if (bg->ro)

		ret = false;

	else

		bg->swap_extents++;

	spin_unlock(&bg->lock);



	return ret;

}



void btrfs_dec_block_group_swap_extents(struct btrfs_block_group *bg, int amount)

{

	spin_lock(&bg->lock);

	ASSERT(!bg->ro);

	ASSERT(bg->swap_extents >= amount);

	bg->swap_extents -= amount;

	spin_unlock(&bg->lock);

}

fs/btrfs/block-group.h

+9 −0
Original line number Diff line number Diff line
@@ -186,6 +186,12 @@ struct btrfs_block_group { 
	/* Flag indicating this block group is placed on a sequential zone */

	bool seq_zone;



	/*

	 * Number of extents in this block group used for swap files.

	 * All accesses protected by the spinlock 'lock'.

	 */

	int swap_extents;



	/* Record locked full stripes for RAID5/6 block group */

	struct btrfs_full_stripe_locks_tree full_stripe_locks_root;
@@ -312,4 +318,7 @@ static inline int btrfs_block_group_done(struct btrfs_block_group *cache) 
void btrfs_freeze_block_group(struct btrfs_block_group *cache);

void btrfs_unfreeze_block_group(struct btrfs_block_group *cache);



bool btrfs_inc_block_group_swap_extents(struct btrfs_block_group *bg);

void btrfs_dec_block_group_swap_extents(struct btrfs_block_group *bg, int amount);



#endif /* BTRFS_BLOCK_GROUP_H */

fs/btrfs/compression.c

+43 −19
Original line number Diff line number Diff line
@@ -141,6 +141,7 @@ static int check_compressed_csum(struct btrfs_inode *inode, struct bio *bio, 
	struct btrfs_fs_info *fs_info = inode->root->fs_info;

	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);

	const u32 csum_size = fs_info->csum_size;

	const u32 sectorsize = fs_info->sectorsize;

	struct page *page;

	unsigned long i;

	char *kaddr;
@@ -154,13 +155,23 @@ static int check_compressed_csum(struct btrfs_inode *inode, struct bio *bio, 
	shash->tfm = fs_info->csum_shash;



	for (i = 0; i < cb->nr_pages; i++) {

		u32 pg_offset;

		u32 bytes_left = PAGE_SIZE;

		page = cb->compressed_pages[i];



		/* Determine the remaining bytes inside the page first */

		if (i == cb->nr_pages - 1)

			bytes_left = cb->compressed_len - i * PAGE_SIZE;



		/* Hash through the page sector by sector */

		for (pg_offset = 0; pg_offset < bytes_left;

		     pg_offset += sectorsize) {

			kaddr = kmap_atomic(page);

		crypto_shash_digest(shash, kaddr, PAGE_SIZE, csum);

			crypto_shash_digest(shash, kaddr + pg_offset,

					    sectorsize, csum);

			kunmap_atomic(kaddr);



		if (memcmp(&csum, cb_sum, csum_size)) {

			if (memcmp(&csum, cb_sum, csum_size) != 0) {

				btrfs_print_data_csum_error(inode, disk_start,

						csum, cb_sum, cb->mirror_num);

				if (btrfs_io_bio(bio)->device)
@@ -170,6 +181,8 @@ static int check_compressed_csum(struct btrfs_inode *inode, struct bio *bio, 
				return -EIO;

			}

			cb_sum += csum_size;

			disk_start += sectorsize;

		}

	}

	return 0;

}
@@ -640,7 +653,7 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	read_lock(&em_tree->lock);

	em = lookup_extent_mapping(em_tree,

				   page_offset(bio_first_page_all(bio)),

				   PAGE_SIZE);

				   fs_info->sectorsize);

	read_unlock(&em_tree->lock);

	if (!em)

		return BLK_STS_IOERR;
@@ -698,19 +711,30 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	refcount_set(&cb->pending_bios, 1);



	for (pg_index = 0; pg_index < nr_pages; pg_index++) {

		u32 pg_len = PAGE_SIZE;

		int submit = 0;



		/*

		 * To handle subpage case, we need to make sure the bio only

		 * covers the range we need.

		 *

		 * If we're at the last page, truncate the length to only cover

		 * the remaining part.

		 */

		if (pg_index == nr_pages - 1)

			pg_len = min_t(u32, PAGE_SIZE,

					compressed_len - pg_index * PAGE_SIZE);



		page = cb->compressed_pages[pg_index];

		page->mapping = inode->i_mapping;

		page->index = em_start >> PAGE_SHIFT;



		if (comp_bio->bi_iter.bi_size)

			submit = btrfs_bio_fits_in_stripe(page, PAGE_SIZE,

			submit = btrfs_bio_fits_in_stripe(page, pg_len,

							  comp_bio, 0);



		page->mapping = NULL;

		if (submit || bio_add_page(comp_bio, page, PAGE_SIZE, 0) <

		    PAGE_SIZE) {

		if (submit || bio_add_page(comp_bio, page, pg_len, 0) < pg_len) {

			unsigned int nr_sectors;



			ret = btrfs_bio_wq_end_io(fs_info, comp_bio,
@@ -743,9 +767,9 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
			comp_bio->bi_private = cb;

			comp_bio->bi_end_io = end_compressed_bio_read;



			bio_add_page(comp_bio, page, PAGE_SIZE, 0);

			bio_add_page(comp_bio, page, pg_len, 0);

		}

		cur_disk_byte += PAGE_SIZE;

		cur_disk_byte += pg_len;

	}



	ret = btrfs_bio_wq_end_io(fs_info, comp_bio, BTRFS_WQ_ENDIO_DATA);

fs/btrfs/ctree.h

+5 −0
Original line number Diff line number Diff line
@@ -524,6 +524,11 @@ struct btrfs_swapfile_pin { 
	 * points to a struct btrfs_device.

	 */

	bool is_block_group;

	/*

	 * Only used when 'is_block_group' is true and it is the number of

	 * extents used by a swapfile for this block group ('ptr' field).

	 */

	int bg_extent_count;

};



bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);

fs/btrfs/free-space-cache.c

+8 −6
Original line number Diff line number Diff line
@@ -2801,8 +2801,10 @@ static void __btrfs_return_cluster_to_free_space( 
	struct rb_node *node;



	spin_lock(&cluster->lock);

	if (cluster->block_group != block_group)

		goto out;

	if (cluster->block_group != block_group) {

		spin_unlock(&cluster->lock);

		return;

	}



	cluster->block_group = NULL;

	cluster->window_start = 0;
@@ -2840,8 +2842,6 @@ static void __btrfs_return_cluster_to_free_space( 
				   entry->offset, &entry->offset_index, bitmap);

	}

	cluster->root = RB_ROOT;



out:

	spin_unlock(&cluster->lock);

	btrfs_put_block_group(block_group);

}
@@ -3125,8 +3125,6 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group *block_group, 
			entry->bytes -= bytes;

		}



		if (entry->bytes == 0)

			rb_erase(&entry->offset_index, &cluster->root);

		break;

	}

out:
@@ -3143,7 +3141,10 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group *block_group, 
	ctl->free_space -= bytes;

	if (!entry->bitmap && !btrfs_free_space_trimmed(entry))

		ctl->discardable_bytes[BTRFS_STAT_CURR] -= bytes;



	spin_lock(&cluster->lock);

	if (entry->bytes == 0) {

		rb_erase(&entry->offset_index, &cluster->root);

		ctl->free_extents--;

		if (entry->bitmap) {

			kmem_cache_free(btrfs_free_space_bitmap_cachep,
@@ -3156,6 +3157,7 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group *block_group, 
		kmem_cache_free(btrfs_free_space_cachep, entry);

	}



	spin_unlock(&cluster->lock);

	spin_unlock(&ctl->tree_lock);



	return ret;