// SPDX-License-Identifier: GPL-2.0#include <linux/capability.h>#include <linux/compat.h>#include <linux/blkdev.h>#include <linux/export.h>#include <linux/gfp.h>#include <linux/blkpg.h>#include <linux/hdreg.h>#include <linux/backing-dev.h>#include <linux/fs.h>#include <linux/blktrace_api.h>#include <linux/pr.h>#include <linux/uaccess.h>#include <linux/pagemap.h>#include <linux/io_uring/cmd.h>#include <linux/blk-integrity.h>#include <uapi/linux/blkdev.h>#include "blk.h"#include "blk-crypto-internal.h" static int blkpg_do_ioctl(struct block_device *bdev,			  struct blkpg_partition __user *upart, int op){	struct gendisk *disk = bdev->bd_disk;	struct blkpg_partition p;	sector_t start, length, capacity, end; 	if (!capable(CAP_SYS_ADMIN))		return -EACCES;	if (copy_from_user(&p, upart, sizeof(struct blkpg_partition)))		return -EFAULT;	if (bdev_is_partition(bdev))		return -EINVAL; 	if (p.pno <= 0)		return -EINVAL; 	if (op == BLKPG_DEL_PARTITION)		return bdev_del_partition(disk, p.pno); 	if (p.start < 0 || p.length <= 0 || LLONG_MAX - p.length < p.start)		return -EINVAL;	/* Check that the partition is aligned to the block size */	if (!IS_ALIGNED(p.start | p.length, bdev_logical_block_size(bdev)))		return -EINVAL; 	start = p.start >> SECTOR_SHIFT;	length = p.length >> SECTOR_SHIFT;	capacity = get_capacity(disk); 	if (check_add_overflow(start, length, &end))		return -EINVAL; 	if (start >= capacity || end > capacity)		return -EINVAL; 	switch (op) {	case BLKPG_ADD_PARTITION:		return bdev_add_partition(disk, p.pno, start, length);	case BLKPG_RESIZE_PARTITION:		return bdev_resize_partition(disk, p.pno, start, length);	default:		return -EINVAL;	}} static int blkpg_ioctl(struct block_device *bdev,		       struct blkpg_ioctl_arg __user *arg){	struct blkpg_partition __user *udata;	int op; 	if (get_user(op, &arg->op) || get_user(udata, &arg->data))		return -EFAULT; 	return blkpg_do_ioctl(bdev, udata, op);} #ifdef CONFIG_COMPATstruct compat_blkpg_ioctl_arg {	compat_int_t op;	compat_int_t flags;	compat_int_t datalen;	compat_caddr_t data;}; static int compat_blkpg_ioctl(struct block_device *bdev,			      struct compat_blkpg_ioctl_arg __user *arg){	compat_caddr_t udata;	int op; 	if (get_user(op, &arg->op) || get_user(udata, &arg->data))		return -EFAULT; 	return blkpg_do_ioctl(bdev, compat_ptr(udata), op);}#endif /* * Check that [start, start + len) is a valid range from the block device's * perspective, including verifying that it can be correctly translated into * logical block addresses. */static int blk_validate_byte_range(struct block_device *bdev,				   uint64_t start, uint64_t len){	unsigned int bs_mask = bdev_logical_block_size(bdev) - 1;	uint64_t end; 	if ((start | len) & bs_mask)		return -EINVAL;	if (!len)		return -EINVAL;	if (check_add_overflow(start, len, &end) || end > bdev_nr_bytes(bdev))		return -EINVAL; 	return 0;} static int blk_ioctl_discard(struct block_device *bdev, blk_mode_t mode,		unsigned long arg){	uint64_t range[2], start, len;	struct bio *prev = NULL, *bio;	sector_t sector, nr_sects;	struct blk_plug plug;	int err; 	if (copy_from_user(range, (void __user *)arg, sizeof(range)))		return -EFAULT;	start = range[0];	len = range[1]; 	if (!bdev_max_discard_sectors(bdev))		return -EOPNOTSUPP; 	if (!(mode & BLK_OPEN_WRITE))		return -EBADF;	if (bdev_read_only(bdev))		return -EPERM;	err = blk_validate_byte_range(bdev, start, len);	if (err)		return err; 	inode_lock(bdev->bd_mapping->host);	filemap_invalidate_lock(bdev->bd_mapping);	err = truncate_bdev_range(bdev, mode, start, start + len - 1);	if (err)		goto fail; 	sector = start >> SECTOR_SHIFT;	nr_sects = len >> SECTOR_SHIFT; 	blk_start_plug(&plug);	while (!fatal_signal_pending(current)) {		bio = blk_alloc_discard_bio(bdev, &sector, &nr_sects,				GFP_KERNEL);		if (!bio)			break;		prev = bio_chain_and_submit(prev, bio);	}	if (prev) {		err = bio_submit_or_kill(prev, BLKDEV_ZERO_KILLABLE);		if (err == -EOPNOTSUPP)			err = 0;		bio_put(prev);	}	blk_finish_plug(&plug);fail:	filemap_invalidate_unlock(bdev->bd_mapping);	inode_unlock(bdev->bd_mapping->host);	return err;} static int blk_ioctl_secure_erase(struct block_device *bdev, blk_mode_t mode,		void __user *argp){	uint64_t start, len, end;	uint64_t range[2];	int err; 	if (!(mode & BLK_OPEN_WRITE))		return -EBADF;	if (!bdev_max_secure_erase_sectors(bdev))		return -EOPNOTSUPP;	if (copy_from_user(range, argp, sizeof(range)))		return -EFAULT; 	start = range[0];	len = range[1];	if ((start & 511) || (len & 511))		return -EINVAL;	if (check_add_overflow(start, len, &end) ||	    end > bdev_nr_bytes(bdev))		return -EINVAL; 	inode_lock(bdev->bd_mapping->host);	filemap_invalidate_lock(bdev->bd_mapping);	err = truncate_bdev_range(bdev, mode, start, end - 1);	if (!err)		err = blkdev_issue_secure_erase(bdev, start >> 9, len >> 9,						GFP_KERNEL);	filemap_invalidate_unlock(bdev->bd_mapping);	inode_unlock(bdev->bd_mapping->host);	return err;}  static int blk_ioctl_zeroout(struct block_device *bdev, blk_mode_t mode,		unsigned long arg){	uint64_t range[2];	uint64_t start, end, len;	int err; 	if (!(mode & BLK_OPEN_WRITE))		return -EBADF; 	if (copy_from_user(range, (void __user *)arg, sizeof(range)))		return -EFAULT; 	start = range[0];	len = range[1];	end = start + len - 1; 	if (start & 511)		return -EINVAL;	if (len & 511)		return -EINVAL;	if (end >= (uint64_t)bdev_nr_bytes(bdev))		return -EINVAL;	if (end < start)		return -EINVAL; 	/* Invalidate the page cache, including dirty pages */	inode_lock(bdev->bd_mapping->host);	filemap_invalidate_lock(bdev->bd_mapping);	err = truncate_bdev_range(bdev, mode, start, end);	if (err)		goto fail; 	err = blkdev_issue_zeroout(bdev, start >> 9, len >> 9, GFP_KERNEL,				   BLKDEV_ZERO_NOUNMAP | BLKDEV_ZERO_KILLABLE); fail:	filemap_invalidate_unlock(bdev->bd_mapping);	inode_unlock(bdev->bd_mapping->host);	return err;} static int put_ushort(unsigned short __user *argp, unsigned short val){	return put_user(val, argp);} static int put_int(int __user *argp, int val){	return put_user(val, argp);} static int put_uint(unsigned int __user *argp, unsigned int val){	return put_user(val, argp);} static int put_long(long __user *argp, long val){	return put_user(val, argp);} static int put_ulong(unsigned long __user *argp, unsigned long val){	return put_user(val, argp);} static int put_u64(u64 __user *argp, u64 val){	return put_user(val, argp);} #ifdef CONFIG_COMPATstatic int compat_put_long(compat_long_t __user *argp, long val){	return put_user(val, argp);} static int compat_put_ulong(compat_ulong_t __user *argp, compat_ulong_t val){	return put_user(val, argp);}#endif #ifdef CONFIG_COMPAT/* * This is the equivalent of compat_ptr_ioctl(), to be used by block * drivers that implement only commands that are completely compatible * between 32-bit and 64-bit user space */int blkdev_compat_ptr_ioctl(struct block_device *bdev, blk_mode_t mode,			unsigned cmd, unsigned long arg){	struct gendisk *disk = bdev->bd_disk; 	if (disk->fops->ioctl)		return disk->fops->ioctl(bdev, mode, cmd,					 (unsigned long)compat_ptr(arg)); 	return -ENOIOCTLCMD;}EXPORT_SYMBOL(blkdev_compat_ptr_ioctl);#endif enum pr_direction {	PR_IN,  /* read from device */	PR_OUT, /* write to device */}; static bool blkdev_pr_allowed(struct block_device *bdev, blk_mode_t mode,		enum pr_direction dir){	/* no sense to make reservations for partitions */	if (bdev_is_partition(bdev))		return false; 	if (capable(CAP_SYS_ADMIN))		return true; 	/*	 * Only allow unprivileged reservation _out_ commands if the file	 * descriptor is open for writing. Allow reservation _in_ commands if	 * the file descriptor is open for reading since they do not modify the	 * device.	 */	if (dir == PR_IN)		return mode & BLK_OPEN_READ;	else		return mode & BLK_OPEN_WRITE;} static int blkdev_pr_register(struct block_device *bdev, blk_mode_t mode,		struct pr_registration __user *arg){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_registration reg; 	if (!blkdev_pr_allowed(bdev, mode, PR_OUT))		return -EPERM;	if (!ops || !ops->pr_register)		return -EOPNOTSUPP;	if (copy_from_user(&reg, arg, sizeof(reg)))		return -EFAULT; 	if (reg.flags & ~PR_FL_IGNORE_KEY)		return -EOPNOTSUPP;	return ops->pr_register(bdev, reg.old_key, reg.new_key, reg.flags);} static int blkdev_pr_reserve(struct block_device *bdev, blk_mode_t mode,		struct pr_reservation __user *arg){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_reservation rsv; 	if (!blkdev_pr_allowed(bdev, mode, PR_OUT))		return -EPERM;	if (!ops || !ops->pr_reserve)		return -EOPNOTSUPP;	if (copy_from_user(&rsv, arg, sizeof(rsv)))		return -EFAULT; 	if (rsv.flags & ~PR_FL_IGNORE_KEY)		return -EOPNOTSUPP;	return ops->pr_reserve(bdev, rsv.key, rsv.type, rsv.flags);} static int blkdev_pr_release(struct block_device *bdev, blk_mode_t mode,		struct pr_reservation __user *arg){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_reservation rsv; 	if (!blkdev_pr_allowed(bdev, mode, PR_OUT))		return -EPERM;	if (!ops || !ops->pr_release)		return -EOPNOTSUPP;	if (copy_from_user(&rsv, arg, sizeof(rsv)))		return -EFAULT; 	if (rsv.flags)		return -EOPNOTSUPP;	return ops->pr_release(bdev, rsv.key, rsv.type);} static int blkdev_pr_preempt(struct block_device *bdev, blk_mode_t mode,		struct pr_preempt __user *arg, bool abort){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_preempt p; 	if (!blkdev_pr_allowed(bdev, mode, PR_OUT))		return -EPERM;	if (!ops || !ops->pr_preempt)		return -EOPNOTSUPP;	if (copy_from_user(&p, arg, sizeof(p)))		return -EFAULT; 	if (p.flags)		return -EOPNOTSUPP;	return ops->pr_preempt(bdev, p.old_key, p.new_key, p.type, abort);} static int blkdev_pr_clear(struct block_device *bdev, blk_mode_t mode,		struct pr_clear __user *arg){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_clear c; 	if (!blkdev_pr_allowed(bdev, mode, PR_OUT))		return -EPERM;	if (!ops || !ops->pr_clear)		return -EOPNOTSUPP;	if (copy_from_user(&c, arg, sizeof(c)))		return -EFAULT; 	if (c.flags)		return -EOPNOTSUPP;	return ops->pr_clear(bdev, c.key);} static int blkdev_pr_read_keys(struct block_device *bdev, blk_mode_t mode,		struct pr_read_keys __user *arg){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_keys *keys_info;	struct pr_read_keys read_keys;	u64 __user *keys_ptr;	size_t keys_info_len;	size_t keys_copy_len;	int ret; 	if (!blkdev_pr_allowed(bdev, mode, PR_IN))		return -EPERM;	if (!ops || !ops->pr_read_keys)		return -EOPNOTSUPP; 	if (copy_from_user(&read_keys, arg, sizeof(read_keys)))		return -EFAULT; 	if (read_keys.num_keys > PR_KEYS_MAX)		return -EINVAL; 	keys_info_len = struct_size(keys_info, keys, read_keys.num_keys); 	keys_info = kvzalloc(keys_info_len, GFP_KERNEL);	if (!keys_info)		return -ENOMEM; 	keys_info->num_keys = read_keys.num_keys; 	ret = ops->pr_read_keys(bdev, keys_info);	if (ret)		goto out; 	/* Copy out individual keys */	keys_ptr = u64_to_user_ptr(read_keys.keys_ptr);	keys_copy_len = min(read_keys.num_keys, keys_info->num_keys) *		        sizeof(keys_info->keys[0]); 	if (copy_to_user(keys_ptr, keys_info->keys, keys_copy_len)) {		ret = -EFAULT;		goto out;	} 	/* Copy out the arg struct */	read_keys.generation = keys_info->generation;	read_keys.num_keys = keys_info->num_keys; 	if (copy_to_user(arg, &read_keys, sizeof(read_keys)))		ret = -EFAULT;out:	kvfree(keys_info);	return ret;} static int blkdev_pr_read_reservation(struct block_device *bdev,		blk_mode_t mode, struct pr_read_reservation __user *arg){	const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;	struct pr_held_reservation rsv = {};	struct pr_read_reservation out = {};	int ret; 	if (!blkdev_pr_allowed(bdev, mode, PR_IN))		return -EPERM;	if (!ops || !ops->pr_read_reservation)		return -EOPNOTSUPP; 	ret = ops->pr_read_reservation(bdev, &rsv);	if (ret)

Lines 1–500 of 974. Load more