Merge branch 'block-6.15' of... (6475ece8) · Commits · git / linux-net

block/bdev.c

+51 −16

Original line number	Diff line number	Diff line
		@@ -152,27 +152,65 @@ static void set_init_blocksize(struct block_device *bdev)
		get_order(bsize));
		}

		int set_blocksize(struct file *file, int size)
		/**
		* bdev_validate_blocksize - check that this block size is acceptable
		* @bdev: blockdevice to check
		* @block_size: block size to check
		*
		* For block device users that do not use buffer heads or the block device
		* page cache, make sure that this block size can be used with the device.
		*
		* Return: On success zero is returned, negative error code on failure.
		*/
		int bdev_validate_blocksize(struct block_device *bdev, int block_size)
		{
		struct inode *inode = file->f_mapping->host;
		struct block_device *bdev = I_BDEV(inode);

		if (blk_validate_block_size(size))
		if (blk_validate_block_size(block_size))
		return -EINVAL;

		/* Size cannot be smaller than the size supported by the device */
		if (size < bdev_logical_block_size(bdev))
		if (block_size < bdev_logical_block_size(bdev))
		return -EINVAL;

		return 0;
		}
		EXPORT_SYMBOL_GPL(bdev_validate_blocksize);

		int set_blocksize(struct file *file, int size)
		{
		struct inode *inode = file->f_mapping->host;
		struct block_device *bdev = I_BDEV(inode);
		int ret;

		ret = bdev_validate_blocksize(bdev, size);
		if (ret)
		return ret;

		if (!file->private_data)
		return -EINVAL;

		/* Don't change the size if it is same as current */
		if (inode->i_blkbits != blksize_bits(size)) {
		/*
		* Flush and truncate the pagecache before we reconfigure the
		* mapping geometry because folio sizes are variable now. If a
		* reader has already allocated a folio whose size is smaller
		* than the new min_order but invokes readahead after the new
		* min_order becomes visible, readahead will think there are
		* "zero" blocks per folio and crash. Take the inode and
		* invalidation locks to avoid racing with
		* read/write/fallocate.
		*/
		inode_lock(inode);
		filemap_invalidate_lock(inode->i_mapping);

		sync_blockdev(bdev);
		kill_bdev(bdev);

		inode->i_blkbits = blksize_bits(size);
		mapping_set_folio_min_order(inode->i_mapping, get_order(size));
		kill_bdev(bdev);
		filemap_invalidate_unlock(inode->i_mapping);
		inode_unlock(inode);
		}
		return 0;
		}
		@@ -777,13 +815,13 @@ static void blkdev_put_part(struct block_device *part)
		blkdev_put_whole(whole);
		}

		struct block_device *blkdev_get_no_open(dev_t dev)
		struct block_device *blkdev_get_no_open(dev_t dev, bool autoload)
		{
		struct block_device *bdev;
		struct inode *inode;

		inode = ilookup(blockdev_superblock, dev);
		if (!inode && IS_ENABLED(CONFIG_BLOCK_LEGACY_AUTOLOAD)) {
		if (!inode && autoload && IS_ENABLED(CONFIG_BLOCK_LEGACY_AUTOLOAD)) {
		blk_request_module(dev);
		inode = ilookup(blockdev_superblock, dev);
		if (inode)
		@@ -1005,7 +1043,7 @@ struct file bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void holder,
		if (ret)
		return ERR_PTR(ret);

		bdev = blkdev_get_no_open(dev);
		bdev = blkdev_get_no_open(dev, true);
		if (!bdev)
		return ERR_PTR(-ENXIO);

		@@ -1275,18 +1313,15 @@ void sync_bdevs(bool wait)
		void bdev_statx(struct path path, struct kstat stat,
		u32 request_mask)
		{
		struct inode *backing_inode;
		struct block_device *bdev;

		backing_inode = d_backing_inode(path->dentry);

		/*
		* Note that backing_inode is the inode of a block device node file,
		* not the block device's internal inode. Therefore it is not valid
		* to use I_BDEV() here; the block device has to be looked up by i_rdev
		* Note that d_backing_inode() returns the block device node inode, not
		* the block device's internal inode. Therefore it is not valid to
		* use I_BDEV() here; the block device has to be looked up by i_rdev
		* instead.
		*/
		bdev = blkdev_get_no_open(backing_inode->i_rdev);
		bdev = blkdev_get_no_open(d_backing_inode(path->dentry)->i_rdev, false);
		if (!bdev)
		return;

block/bio-integrity-auto.c

+47 −15

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@
		* not aware of PI.
		*/
		#include <linux/blk-integrity.h>
		#include <linux/t10-pi.h>
		#include <linux/workqueue.h>
		#include "blk.h"

		@@ -43,6 +44,29 @@ static void bio_integrity_verify_fn(struct work_struct *work)
		bio_endio(bio);
		}

		#define BIP_CHECK_FLAGS (BIP_CHECK_GUARD \| BIP_CHECK_REFTAG \| BIP_CHECK_APPTAG)
		static bool bip_should_check(struct bio_integrity_payload *bip)
		{
		return bip->bip_flags & BIP_CHECK_FLAGS;
		}

		static bool bi_offload_capable(struct blk_integrity *bi)
		{
		switch (bi->csum_type) {
		case BLK_INTEGRITY_CSUM_CRC64:
		return bi->tuple_size == sizeof(struct crc64_pi_tuple);
		case BLK_INTEGRITY_CSUM_CRC:
		case BLK_INTEGRITY_CSUM_IP:
		return bi->tuple_size == sizeof(struct t10_pi_tuple);
		default:
		pr_warn_once("%s: unknown integrity checksum type:%d\n",
		__func__, bi->csum_type);
		fallthrough;
		case BLK_INTEGRITY_CSUM_NONE:
		return false;
		}
		}

		/**
		* __bio_integrity_endio - Integrity I/O completion function
		* @bio: Protected bio
		@@ -54,12 +78,12 @@ static void bio_integrity_verify_fn(struct work_struct *work)
		*/
		bool __bio_integrity_endio(struct bio *bio)
		{
		struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
		struct bio_integrity_payload *bip = bio_integrity(bio);
		struct bio_integrity_data *bid =
		container_of(bip, struct bio_integrity_data, bip);

		if (bio_op(bio) == REQ_OP_READ && !bio->bi_status && bi->csum_type) {
		if (bio_op(bio) == REQ_OP_READ && !bio->bi_status &&
		bip_should_check(bip)) {
		INIT_WORK(&bid->work, bio_integrity_verify_fn);
		queue_work(kintegrityd_wq, &bid->work);
		return false;
		@@ -84,6 +108,7 @@ bool bio_integrity_prep(struct bio *bio)
		{
		struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
		struct bio_integrity_data *bid;
		bool set_flags = true;
		gfp_t gfp = GFP_NOIO;
		unsigned int len;
		void *buf;
		@@ -100,19 +125,24 @@ bool bio_integrity_prep(struct bio *bio)

		switch (bio_op(bio)) {
		case REQ_OP_READ:
		if (bi->flags & BLK_INTEGRITY_NOVERIFY)
		if (bi->flags & BLK_INTEGRITY_NOVERIFY) {
		if (bi_offload_capable(bi))
		return true;
		set_flags = false;
		}
		break;
		case REQ_OP_WRITE:
		if (bi->flags & BLK_INTEGRITY_NOGENERATE)
		return true;

		/*
		* Zero the memory allocated to not leak uninitialized kernel
		* memory to disk for non-integrity metadata where nothing else
		* initializes the memory.
		*/
		if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE)
		if (bi->flags & BLK_INTEGRITY_NOGENERATE) {
		if (bi_offload_capable(bi))
		return true;
		set_flags = false;
		gfp \|= __GFP_ZERO;
		} else if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE)
		gfp \|= __GFP_ZERO;
		break;
		default:
		@@ -137,19 +167,21 @@ bool bio_integrity_prep(struct bio *bio)
		bid->bip.bip_flags \|= BIP_BLOCK_INTEGRITY;
		bip_set_seed(&bid->bip, bio->bi_iter.bi_sector);

		if (set_flags) {
		if (bi->csum_type == BLK_INTEGRITY_CSUM_IP)
		bid->bip.bip_flags \|= BIP_IP_CHECKSUM;
		if (bi->csum_type)
		bid->bip.bip_flags \|= BIP_CHECK_GUARD;
		if (bi->flags & BLK_INTEGRITY_REF_TAG)
		bid->bip.bip_flags \|= BIP_CHECK_REFTAG;
		}

		if (bio_integrity_add_page(bio, virt_to_page(buf), len,
		offset_in_page(buf)) < len)
		goto err_end_io;

		/* Auto-generate integrity metadata if this is a write */
		if (bio_data_dir(bio) == WRITE)
		if (bio_data_dir(bio) == WRITE && bip_should_check(&bid->bip))
		blk_integrity_generate(bio);
		else
		bid->saved_bio_iter = bio->bi_iter;

block/bio-integrity.c

+6 −11

Original line number	Diff line number	Diff line
		@@ -66,17 +66,13 @@ struct bio_integrity_payload bio_integrity_alloc(struct bio bio,
		}
		EXPORT_SYMBOL(bio_integrity_alloc);

		static void bio_integrity_unpin_bvec(struct bio_vec *bv, int nr_vecs,
		bool dirty)
		static void bio_integrity_unpin_bvec(struct bio_vec *bv, int nr_vecs)
		{
		int i;

		for (i = 0; i < nr_vecs; i++) {
		if (dirty && !PageCompound(bv[i].bv_page))
		set_page_dirty_lock(bv[i].bv_page);
		for (i = 0; i < nr_vecs; i++)
		unpin_user_page(bv[i].bv_page);
		}
		}

		static void bio_integrity_uncopy_user(struct bio_integrity_payload *bip)
		{
		@@ -91,7 +87,7 @@ static void bio_integrity_uncopy_user(struct bio_integrity_payload *bip)
		ret = copy_to_iter(bvec_virt(bounce_bvec), bytes, &orig_iter);
		WARN_ON_ONCE(ret != bytes);

		bio_integrity_unpin_bvec(orig_bvecs, orig_nr_vecs, true);
		bio_integrity_unpin_bvec(orig_bvecs, orig_nr_vecs);
		}

		/**
		@@ -111,8 +107,7 @@ void bio_integrity_unmap_user(struct bio *bio)
		return;
		}

		bio_integrity_unpin_bvec(bip->bip_vec, bip->bip_max_vcnt,
		bio_data_dir(bio) == READ);
		bio_integrity_unpin_bvec(bip->bip_vec, bip->bip_max_vcnt);
		}

		/**
		@@ -198,7 +193,7 @@ static int bio_integrity_copy_user(struct bio bio, struct bio_vec bvec,
		}

		if (write)
		bio_integrity_unpin_bvec(bvec, nr_vecs, false);
		bio_integrity_unpin_bvec(bvec, nr_vecs);
		else
		memcpy(&bip->bip_vec[1], bvec, nr_vecs * sizeof(*bvec));

		@@ -319,7 +314,7 @@ int bio_integrity_map_user(struct bio bio, struct iov_iter iter)
		return 0;

		release_pages:
		bio_integrity_unpin_bvec(bvec, nr_bvecs, false);
		bio_integrity_unpin_bvec(bvec, nr_bvecs);
		free_bvec:
		if (bvec != stack_vec)
		kfree(bvec);

block/blk-cgroup.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -797,7 +797,7 @@ int blkg_conf_open_bdev(struct blkg_conf_ctx *ctx)
		return -EINVAL;
		input = skip_spaces(input);

		bdev = blkdev_get_no_open(MKDEV(major, minor));
		bdev = blkdev_get_no_open(MKDEV(major, minor), false);
		if (!bdev)
		return -ENODEV;
		if (bdev_is_partition(bdev)) {

block/blk-settings.c

+7 −1

Original line number	Diff line number	Diff line
		@@ -61,8 +61,14 @@ void blk_apply_bdi_limits(struct backing_dev_info *bdi,
		/*
		* For read-ahead of large files to be effective, we need to read ahead
		* at least twice the optimal I/O size.
		*
		* There is no hardware limitation for the read-ahead size and the user
		* might have increased the read-ahead size through sysfs, so don't ever
		* decrease it.
		*/
		bdi->ra_pages = max(lim->io_opt * 2 / PAGE_SIZE, VM_READAHEAD_PAGES);
		bdi->ra_pages = max3(bdi->ra_pages,
		lim->io_opt * 2 / PAGE_SIZE,
		VM_READAHEAD_PAGES);
		bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT;
		}