linux/block/ioctl.c

// 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 <uapi/linux/blkdev.h>
#include "blk.h"

static int blkpg_do_ioctl(struct block_device *bdev,
			  struct blkpg_partition __user *upart, int op)
{ … }

static int blkpg_ioctl(struct block_device *bdev,
		       struct blkpg_ioctl_arg __user *arg)
{ … }

#ifdef CONFIG_COMPAT
struct compat_blkpg_ioctl_arg { … };

static int compat_blkpg_ioctl(struct block_device *bdev,
			      struct compat_blkpg_ioctl_arg __user *arg)
{ … }
#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)
{ … }

static int blk_ioctl_discard(struct block_device *bdev, blk_mode_t mode,
		unsigned long arg)
{ … }

static int blk_ioctl_secure_erase(struct block_device *bdev, blk_mode_t mode,
		void __user *argp)
{ … }


static int blk_ioctl_zeroout(struct block_device *bdev, blk_mode_t mode,
		unsigned long arg)
{ … }

static int put_ushort(unsigned short __user *argp, unsigned short val)
{ … }

static int put_int(int __user *argp, int val)
{ … }

static int put_uint(unsigned int __user *argp, unsigned int val)
{ … }

static int put_long(long __user *argp, long val)
{ … }

static int put_ulong(unsigned long __user *argp, unsigned long val)
{ … }

static int put_u64(u64 __user *argp, u64 val)
{ … }

#ifdef CONFIG_COMPAT
static int compat_put_long(compat_long_t __user *argp, long val)
{ … }

static int compat_put_ulong(compat_ulong_t __user *argp, compat_ulong_t val)
{ … }
#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)
{ … }
EXPORT_SYMBOL(…);
#endif

static bool blkdev_pr_allowed(struct block_device *bdev, blk_mode_t mode)
{ … }

static int blkdev_pr_register(struct block_device *bdev, blk_mode_t mode,
		struct pr_registration __user *arg)
{ … }

static int blkdev_pr_reserve(struct block_device *bdev, blk_mode_t mode,
		struct pr_reservation __user *arg)
{ … }

static int blkdev_pr_release(struct block_device *bdev, blk_mode_t mode,
		struct pr_reservation __user *arg)
{ … }

static int blkdev_pr_preempt(struct block_device *bdev, blk_mode_t mode,
		struct pr_preempt __user *arg, bool abort)
{ … }

static int blkdev_pr_clear(struct block_device *bdev, blk_mode_t mode,
		struct pr_clear __user *arg)
{ … }

static int blkdev_flushbuf(struct block_device *bdev, unsigned cmd,
		unsigned long arg)
{ … }

static int blkdev_roset(struct block_device *bdev, unsigned cmd,
		unsigned long arg)
{ … }

static int blkdev_getgeo(struct block_device *bdev,
		struct hd_geometry __user *argp)
{ … }

#ifdef CONFIG_COMPAT
struct compat_hd_geometry { … };

static int compat_hdio_getgeo(struct block_device *bdev,
			      struct compat_hd_geometry __user *ugeo)
{ … }
#endif

/* set the logical block size */
static int blkdev_bszset(struct file *file, blk_mode_t mode,
		int __user *argp)
{ … }

/*
 * Common commands that are handled the same way on native and compat
 * user space. Note the separate arg/argp parameters that are needed
 * to deal with the compat_ptr() conversion.
 */
static int blkdev_common_ioctl(struct block_device *bdev, blk_mode_t mode,
			       unsigned int cmd, unsigned long arg,
			       void __user *argp)
{ … }

/*
 * Always keep this in sync with compat_blkdev_ioctl()
 * to handle all incompatible commands in both functions.
 *
 * New commands must be compatible and go into blkdev_common_ioctl
 */
long blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
{ … }

#ifdef CONFIG_COMPAT

#define BLKBSZGET_32 …
#define BLKBSZSET_32 …
#define BLKGETSIZE64_32 …

/* Most of the generic ioctls are handled in the normal fallback path.
   This assumes the blkdev's low level compat_ioctl always returns
   ENOIOCTLCMD for unknown ioctls. */
long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
{ … }
#endif

struct blk_iou_cmd { … };

static void blk_cmd_complete(struct io_uring_cmd *cmd, unsigned int issue_flags)
{ … }

static void bio_cmd_bio_end_io(struct bio *bio)
{ … }

static int blkdev_cmd_discard(struct io_uring_cmd *cmd,
			      struct block_device *bdev,
			      uint64_t start, uint64_t len, bool nowait)
{ … }

int blkdev_uring_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags)
{ … }