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 "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

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