2019-04-30 21:42:43 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2006-01-11 23:17:46 +03:00
|
|
|
#include <linux/capability.h>
|
2019-11-28 17:48:10 +03:00
|
|
|
#include <linux/compat.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/blkdev.h>
|
2011-05-27 00:00:52 +04:00
|
|
|
#include <linux/export.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
|
|
|
#include <linux/gfp.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/blkpg.h>
|
2006-01-08 12:02:50 +03:00
|
|
|
#include <linux/hdreg.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/backing-dev.h>
|
2011-09-16 10:31:11 +04:00
|
|
|
#include <linux/fs.h>
|
2006-03-23 22:00:26 +03:00
|
|
|
#include <linux/blktrace_api.h>
|
2015-10-15 15:10:48 +03:00
|
|
|
#include <linux/pr.h>
|
2016-12-24 22:46:01 +03:00
|
|
|
#include <linux/uaccess.h>
|
2020-03-25 18:48:41 +03:00
|
|
|
#include "blk.h"
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-11-28 13:28:41 +03:00
|
|
|
static int blkpg_do_ioctl(struct block_device *bdev,
|
|
|
|
struct blkpg_partition __user *upart, int op)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2021-08-10 18:45:10 +03:00
|
|
|
struct gendisk *disk = bdev->bd_disk;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct blkpg_partition p;
|
|
|
|
long long start, length;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
2019-11-28 13:28:41 +03:00
|
|
|
if (copy_from_user(&p, upart, sizeof(struct blkpg_partition)))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EFAULT;
|
2020-09-03 08:40:57 +03:00
|
|
|
if (bdev_is_partition(bdev))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
2008-08-25 14:30:16 +04:00
|
|
|
|
2020-04-14 10:28:53 +03:00
|
|
|
if (p.pno <= 0)
|
|
|
|
return -EINVAL;
|
2008-09-03 11:03:02 +04:00
|
|
|
|
2020-04-14 10:28:53 +03:00
|
|
|
if (op == BLKPG_DEL_PARTITION)
|
2021-08-10 18:45:11 +03:00
|
|
|
return bdev_del_partition(disk, p.pno);
|
2008-09-03 11:03:02 +04:00
|
|
|
|
2020-04-14 10:28:53 +03:00
|
|
|
start = p.start >> SECTOR_SHIFT;
|
|
|
|
length = p.length >> SECTOR_SHIFT;
|
2008-09-03 11:03:02 +04:00
|
|
|
|
2020-04-14 10:28:53 +03:00
|
|
|
switch (op) {
|
|
|
|
case BLKPG_ADD_PARTITION:
|
|
|
|
/* check if partition is aligned to blocksize */
|
|
|
|
if (p.start & (bdev_logical_block_size(bdev) - 1))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
2021-08-10 18:45:10 +03:00
|
|
|
return bdev_add_partition(disk, p.pno, start, length);
|
2020-04-14 10:28:53 +03:00
|
|
|
case BLKPG_RESIZE_PARTITION:
|
2021-08-10 18:45:12 +03:00
|
|
|
return bdev_resize_partition(disk, p.pno, start, length);
|
2020-04-14 10:28:53 +03:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-28 13:28:41 +03:00
|
|
|
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_COMPAT
|
|
|
|
struct 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
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
static int blk_ioctl_discard(struct block_device *bdev, fmode_t mode,
|
2022-04-15 07:52:57 +03:00
|
|
|
unsigned long arg)
|
2008-08-11 18:58:42 +04:00
|
|
|
{
|
2015-10-15 15:10:47 +03:00
|
|
|
uint64_t range[2];
|
|
|
|
uint64_t start, len;
|
2021-11-09 13:47:22 +03:00
|
|
|
struct inode *inode = bdev->bd_inode;
|
2020-09-04 11:58:52 +03:00
|
|
|
int err;
|
2015-10-15 15:10:47 +03:00
|
|
|
|
|
|
|
if (!(mode & FMODE_WRITE))
|
|
|
|
return -EBADF;
|
|
|
|
|
2022-04-15 07:52:55 +03:00
|
|
|
if (!bdev_max_discard_sectors(bdev))
|
2017-10-25 03:44:57 +03:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
if (copy_from_user(range, (void __user *)arg, sizeof(range)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
start = range[0];
|
|
|
|
len = range[1];
|
2010-08-12 01:17:49 +04:00
|
|
|
|
2008-08-11 18:58:42 +04:00
|
|
|
if (start & 511)
|
|
|
|
return -EINVAL;
|
|
|
|
if (len & 511)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2021-10-19 09:20:22 +03:00
|
|
|
if (start + len > bdev_nr_bytes(bdev))
|
2008-08-11 18:58:42 +04:00
|
|
|
return -EINVAL;
|
2020-09-04 11:58:52 +03:00
|
|
|
|
2021-11-09 13:47:22 +03:00
|
|
|
filemap_invalidate_lock(inode->i_mapping);
|
2020-09-04 11:58:52 +03:00
|
|
|
err = truncate_bdev_range(bdev, mode, start, start + len - 1);
|
|
|
|
if (err)
|
2021-11-09 13:47:22 +03:00
|
|
|
goto fail;
|
2022-04-15 07:52:57 +03:00
|
|
|
err = blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL);
|
2021-11-09 13:47:22 +03:00
|
|
|
fail:
|
|
|
|
filemap_invalidate_unlock(inode->i_mapping);
|
|
|
|
return err;
|
2008-08-11 18:58:42 +04:00
|
|
|
}
|
|
|
|
|
2022-04-15 07:52:57 +03:00
|
|
|
static int blk_ioctl_secure_erase(struct block_device *bdev, fmode_t mode,
|
|
|
|
void __user *argp)
|
|
|
|
{
|
|
|
|
uint64_t start, len;
|
|
|
|
uint64_t range[2];
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!(mode & FMODE_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 (start + len > bdev_nr_bytes(bdev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
filemap_invalidate_lock(bdev->bd_inode->i_mapping);
|
|
|
|
err = truncate_bdev_range(bdev, mode, start, start + len - 1);
|
|
|
|
if (!err)
|
|
|
|
err = blkdev_issue_secure_erase(bdev, start >> 9, len >> 9,
|
|
|
|
GFP_KERNEL);
|
|
|
|
filemap_invalidate_unlock(bdev->bd_inode->i_mapping);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
static int blk_ioctl_zeroout(struct block_device *bdev, fmode_t mode,
|
|
|
|
unsigned long arg)
|
2012-09-18 20:19:29 +04:00
|
|
|
{
|
2015-10-15 15:10:47 +03:00
|
|
|
uint64_t range[2];
|
2016-10-11 23:51:05 +03:00
|
|
|
uint64_t start, end, len;
|
2021-11-09 13:47:23 +03:00
|
|
|
struct inode *inode = bdev->bd_inode;
|
2020-09-04 11:58:52 +03:00
|
|
|
int err;
|
2015-10-15 15:10:47 +03:00
|
|
|
|
|
|
|
if (!(mode & FMODE_WRITE))
|
|
|
|
return -EBADF;
|
|
|
|
|
|
|
|
if (copy_from_user(range, (void __user *)arg, sizeof(range)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
start = range[0];
|
|
|
|
len = range[1];
|
2016-10-11 23:51:05 +03:00
|
|
|
end = start + len - 1;
|
2015-10-15 15:10:47 +03:00
|
|
|
|
2012-09-18 20:19:29 +04:00
|
|
|
if (start & 511)
|
|
|
|
return -EINVAL;
|
|
|
|
if (len & 511)
|
|
|
|
return -EINVAL;
|
2021-10-19 09:20:22 +03:00
|
|
|
if (end >= (uint64_t)bdev_nr_bytes(bdev))
|
2016-10-11 23:51:05 +03:00
|
|
|
return -EINVAL;
|
|
|
|
if (end < start)
|
2012-09-18 20:19:29 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-10-11 23:51:05 +03:00
|
|
|
/* Invalidate the page cache, including dirty pages */
|
2021-11-09 13:47:23 +03:00
|
|
|
filemap_invalidate_lock(inode->i_mapping);
|
2020-09-04 11:58:52 +03:00
|
|
|
err = truncate_bdev_range(bdev, mode, start, end);
|
|
|
|
if (err)
|
2021-11-09 13:47:23 +03:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
err = blkdev_issue_zeroout(bdev, start >> 9, len >> 9, GFP_KERNEL,
|
|
|
|
BLKDEV_ZERO_NOUNMAP);
|
2016-10-11 23:51:05 +03:00
|
|
|
|
2021-11-09 13:47:23 +03:00
|
|
|
fail:
|
|
|
|
filemap_invalidate_unlock(inode->i_mapping);
|
|
|
|
return err;
|
2012-09-18 20:19:29 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int put_ushort(unsigned short __user *argp, unsigned short val)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int put_int(int __user *argp, int val)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int put_uint(unsigned int __user *argp, unsigned int val)
|
2009-10-03 22:52:01 +04:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2009-10-03 22:52:01 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int put_long(long __user *argp, long val)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int put_ulong(unsigned long __user *argp, unsigned long val)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int put_u64(u64 __user *argp, u64 val)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-11-29 13:45:30 +03:00
|
|
|
#ifdef CONFIG_COMPAT
|
2020-05-19 07:07:34 +03:00
|
|
|
static int compat_put_long(compat_long_t __user *argp, long val)
|
2019-11-29 13:45:30 +03:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2019-11-29 13:45:30 +03:00
|
|
|
}
|
|
|
|
|
2020-05-19 07:07:34 +03:00
|
|
|
static int compat_put_ulong(compat_ulong_t __user *argp, compat_ulong_t val)
|
2019-11-29 13:45:30 +03:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_user(val, argp);
|
2019-11-29 13:45:30 +03:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-11-28 17:48:10 +03:00
|
|
|
#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, fmode_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
|
|
|
|
|
2015-10-15 15:10:48 +03:00
|
|
|
static int blkdev_pr_register(struct block_device *bdev,
|
|
|
|
struct pr_registration __user *arg)
|
|
|
|
{
|
|
|
|
const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
|
|
|
|
struct pr_registration reg;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
if (!ops || !ops->pr_register)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
if (copy_from_user(®, 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,
|
|
|
|
struct pr_reservation __user *arg)
|
|
|
|
{
|
|
|
|
const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
|
|
|
|
struct pr_reservation rsv;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
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,
|
|
|
|
struct pr_reservation __user *arg)
|
|
|
|
{
|
|
|
|
const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
|
|
|
|
struct pr_reservation rsv;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
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,
|
|
|
|
struct pr_preempt __user *arg, bool abort)
|
|
|
|
{
|
|
|
|
const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
|
|
|
|
struct pr_preempt p;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
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,
|
|
|
|
struct pr_clear __user *arg)
|
|
|
|
{
|
|
|
|
const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
|
|
|
|
struct pr_clear c;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
static int blkdev_flushbuf(struct block_device *bdev, fmode_t mode,
|
|
|
|
unsigned cmd, unsigned long arg)
|
2005-06-23 11:10:15 +04:00
|
|
|
{
|
2015-10-15 15:10:47 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
fsync_bdev(bdev);
|
|
|
|
invalidate_bdev(bdev);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-11 18:58:42 +04:00
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
static int blkdev_roset(struct block_device *bdev, fmode_t mode,
|
|
|
|
unsigned cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
int ret, n;
|
2008-08-11 18:58:42 +04:00
|
|
|
|
2017-10-18 15:38:38 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
if (get_user(n, (int __user *)arg))
|
|
|
|
return -EFAULT;
|
2020-11-03 13:00:11 +03:00
|
|
|
if (bdev->bd_disk->fops->set_read_only) {
|
|
|
|
ret = bdev->bd_disk->fops->set_read_only(bdev, n);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2020-11-23 18:36:02 +03:00
|
|
|
bdev->bd_read_only = n;
|
2015-10-15 15:10:47 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2008-08-11 18:58:42 +04:00
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
static int blkdev_getgeo(struct block_device *bdev,
|
|
|
|
struct hd_geometry __user *argp)
|
|
|
|
{
|
|
|
|
struct gendisk *disk = bdev->bd_disk;
|
|
|
|
struct hd_geometry geo;
|
|
|
|
int ret;
|
2008-08-11 18:58:42 +04:00
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
if (!argp)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!disk->fops->getgeo)
|
|
|
|
return -ENOTTY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to set the startsect first, the driver may
|
|
|
|
* want to override it.
|
|
|
|
*/
|
|
|
|
memset(&geo, 0, sizeof(geo));
|
|
|
|
geo.start = get_start_sect(bdev);
|
|
|
|
ret = disk->fops->getgeo(bdev, &geo);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (copy_to_user(argp, &geo, sizeof(geo)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
2012-09-18 20:19:29 +04:00
|
|
|
|
2019-11-29 13:45:30 +03:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
struct compat_hd_geometry {
|
|
|
|
unsigned char heads;
|
|
|
|
unsigned char sectors;
|
|
|
|
unsigned short cylinders;
|
|
|
|
u32 start;
|
|
|
|
};
|
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
static int compat_hdio_getgeo(struct block_device *bdev,
|
|
|
|
struct compat_hd_geometry __user *ugeo)
|
2019-11-29 13:45:30 +03:00
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
struct gendisk *disk = bdev->bd_disk;
|
2019-11-29 13:45:30 +03:00
|
|
|
struct hd_geometry geo;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!ugeo)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!disk->fops->getgeo)
|
|
|
|
return -ENOTTY;
|
|
|
|
|
|
|
|
memset(&geo, 0, sizeof(geo));
|
|
|
|
/*
|
|
|
|
* We need to set the startsect first, the driver may
|
|
|
|
* want to override it.
|
|
|
|
*/
|
|
|
|
geo.start = get_start_sect(bdev);
|
|
|
|
ret = disk->fops->getgeo(bdev, &geo);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = copy_to_user(ugeo, &geo, 4);
|
|
|
|
ret |= put_user(geo.start, &ugeo->start);
|
|
|
|
if (ret)
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
/* set the logical block size */
|
|
|
|
static int blkdev_bszset(struct block_device *bdev, fmode_t mode,
|
|
|
|
int __user *argp)
|
|
|
|
{
|
|
|
|
int ret, n;
|
2012-09-18 20:19:29 +04:00
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
if (!argp)
|
|
|
|
return -EINVAL;
|
|
|
|
if (get_user(n, argp))
|
|
|
|
return -EFAULT;
|
2012-09-18 20:19:29 +04:00
|
|
|
|
2020-09-21 10:19:47 +03:00
|
|
|
if (mode & FMODE_EXCL)
|
|
|
|
return set_blocksize(bdev, n);
|
2008-08-11 18:58:42 +04:00
|
|
|
|
2020-09-21 10:19:47 +03:00
|
|
|
if (IS_ERR(blkdev_get_by_dev(bdev->bd_dev, mode | FMODE_EXCL, &bdev)))
|
|
|
|
return -EBUSY;
|
2015-10-15 15:10:47 +03:00
|
|
|
ret = set_blocksize(bdev, n);
|
2020-09-21 10:19:47 +03:00
|
|
|
blkdev_put(bdev, mode | FMODE_EXCL);
|
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
return ret;
|
|
|
|
}
|
2006-01-08 12:02:50 +03:00
|
|
|
|
2015-10-15 15:10:47 +03:00
|
|
|
/*
|
2019-11-29 13:48:31 +03:00
|
|
|
* 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.
|
2015-10-15 15:10:47 +03:00
|
|
|
*/
|
2023-02-17 05:21:59 +03:00
|
|
|
static int blkdev_common_ioctl(struct block_device *bdev, fmode_t mode,
|
|
|
|
unsigned int cmd, unsigned long arg,
|
|
|
|
void __user *argp)
|
2015-10-15 15:10:47 +03:00
|
|
|
{
|
|
|
|
unsigned int max_sectors;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case BLKFLSBUF:
|
|
|
|
return blkdev_flushbuf(bdev, mode, cmd, arg);
|
|
|
|
case BLKROSET:
|
|
|
|
return blkdev_roset(bdev, mode, cmd, arg);
|
|
|
|
case BLKDISCARD:
|
2022-04-15 07:52:57 +03:00
|
|
|
return blk_ioctl_discard(bdev, mode, arg);
|
2015-10-15 15:10:47 +03:00
|
|
|
case BLKSECDISCARD:
|
2022-04-15 07:52:57 +03:00
|
|
|
return blk_ioctl_secure_erase(bdev, mode, argp);
|
2015-10-15 15:10:47 +03:00
|
|
|
case BLKZEROOUT:
|
|
|
|
return blk_ioctl_zeroout(bdev, mode, arg);
|
2021-07-13 02:05:27 +03:00
|
|
|
case BLKGETDISKSEQ:
|
|
|
|
return put_u64(argp, bdev->bd_disk->diskseq);
|
2016-10-18 09:40:35 +03:00
|
|
|
case BLKREPORTZONE:
|
|
|
|
return blkdev_report_zones_ioctl(bdev, mode, cmd, arg);
|
|
|
|
case BLKRESETZONE:
|
2019-10-27 17:05:46 +03:00
|
|
|
case BLKOPENZONE:
|
|
|
|
case BLKCLOSEZONE:
|
|
|
|
case BLKFINISHZONE:
|
|
|
|
return blkdev_zone_mgmt_ioctl(bdev, mode, cmd, arg);
|
2018-10-12 13:08:45 +03:00
|
|
|
case BLKGETZONESZ:
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_uint(argp, bdev_zone_sectors(bdev));
|
2018-10-12 13:08:46 +03:00
|
|
|
case BLKGETNRZONES:
|
2022-07-06 10:03:45 +03:00
|
|
|
return put_uint(argp, bdev_nr_zones(bdev));
|
2008-09-18 23:53:24 +04:00
|
|
|
case BLKROGET:
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_int(argp, bdev_read_only(bdev) != 0);
|
2009-10-03 22:52:01 +04:00
|
|
|
case BLKSSZGET: /* get block device logical block size */
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_int(argp, bdev_logical_block_size(bdev));
|
2009-10-03 22:52:01 +04:00
|
|
|
case BLKPBSZGET: /* get block device physical block size */
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_uint(argp, bdev_physical_block_size(bdev));
|
2009-10-03 22:52:01 +04:00
|
|
|
case BLKIOMIN:
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_uint(argp, bdev_io_min(bdev));
|
2009-10-03 22:52:01 +04:00
|
|
|
case BLKIOOPT:
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_uint(argp, bdev_io_opt(bdev));
|
2009-10-03 22:52:01 +04:00
|
|
|
case BLKALIGNOFF:
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_int(argp, bdev_alignment_offset(bdev));
|
2009-12-03 11:24:48 +03:00
|
|
|
case BLKDISCARDZEROES:
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_uint(argp, 0);
|
2008-09-18 23:53:24 +04:00
|
|
|
case BLKSECTGET:
|
2014-05-25 16:43:33 +04:00
|
|
|
max_sectors = min_t(unsigned int, USHRT_MAX,
|
|
|
|
queue_max_sectors(bdev_get_queue(bdev)));
|
2019-11-29 13:48:31 +03:00
|
|
|
return put_ushort(argp, max_sectors);
|
2012-01-11 19:29:31 +04:00
|
|
|
case BLKROTATIONAL:
|
2022-04-15 07:52:42 +03:00
|
|
|
return put_ushort(argp, !bdev_nonrot(bdev));
|
2008-09-18 23:53:24 +04:00
|
|
|
case BLKRASET:
|
|
|
|
case BLKFRASET:
|
|
|
|
if(!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
2021-08-09 17:17:44 +03:00
|
|
|
bdev->bd_disk->bdi->ra_pages = (arg * 512) / PAGE_SIZE;
|
2008-09-18 23:53:24 +04:00
|
|
|
return 0;
|
|
|
|
case BLKRRPART:
|
2021-11-22 16:06:16 +03:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
if (bdev_is_partition(bdev))
|
|
|
|
return -EINVAL;
|
2023-02-17 05:22:00 +03:00
|
|
|
return disk_scan_partitions(bdev->bd_disk, mode);
|
2008-09-18 23:53:24 +04:00
|
|
|
case BLKTRACESTART:
|
|
|
|
case BLKTRACESTOP:
|
|
|
|
case BLKTRACETEARDOWN:
|
2015-10-15 15:10:47 +03:00
|
|
|
return blk_trace_ioctl(bdev, cmd, argp);
|
2015-10-15 15:10:48 +03:00
|
|
|
case IOC_PR_REGISTER:
|
|
|
|
return blkdev_pr_register(bdev, argp);
|
|
|
|
case IOC_PR_RESERVE:
|
|
|
|
return blkdev_pr_reserve(bdev, argp);
|
|
|
|
case IOC_PR_RELEASE:
|
|
|
|
return blkdev_pr_release(bdev, argp);
|
|
|
|
case IOC_PR_PREEMPT:
|
|
|
|
return blkdev_pr_preempt(bdev, argp, false);
|
|
|
|
case IOC_PR_PREEMPT_ABORT:
|
|
|
|
return blkdev_pr_preempt(bdev, argp, true);
|
|
|
|
case IOC_PR_CLEAR:
|
|
|
|
return blkdev_pr_clear(bdev, argp);
|
2008-09-18 23:53:24 +04:00
|
|
|
default:
|
2019-11-29 13:48:31 +03:00
|
|
|
return -ENOIOCTLCMD;
|
2008-09-18 23:53:24 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2019-11-29 13:48:31 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2021-10-12 13:44:50 +03:00
|
|
|
long blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
|
2019-11-29 13:48:31 +03:00
|
|
|
{
|
2021-10-12 13:44:50 +03:00
|
|
|
struct block_device *bdev = I_BDEV(file->f_mapping->host);
|
2019-11-29 13:48:31 +03:00
|
|
|
void __user *argp = (void __user *)arg;
|
2021-10-12 13:44:50 +03:00
|
|
|
fmode_t mode = file->f_mode;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
|
|
|
|
* to updated it before every ioctl.
|
|
|
|
*/
|
|
|
|
if (file->f_flags & O_NDELAY)
|
|
|
|
mode |= FMODE_NDELAY;
|
|
|
|
else
|
|
|
|
mode &= ~FMODE_NDELAY;
|
2019-11-29 13:48:31 +03:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
/* These need separate implementations for the data structure */
|
|
|
|
case HDIO_GETGEO:
|
|
|
|
return blkdev_getgeo(bdev, argp);
|
|
|
|
case BLKPG:
|
|
|
|
return blkpg_ioctl(bdev, argp);
|
|
|
|
|
|
|
|
/* Compat mode returns 32-bit data instead of 'long' */
|
|
|
|
case BLKRAGET:
|
|
|
|
case BLKFRAGET:
|
|
|
|
if (!argp)
|
|
|
|
return -EINVAL;
|
2021-08-09 17:17:44 +03:00
|
|
|
return put_long(argp,
|
|
|
|
(bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512);
|
2019-11-29 13:48:31 +03:00
|
|
|
case BLKGETSIZE:
|
2021-10-19 09:20:22 +03:00
|
|
|
if (bdev_nr_sectors(bdev) > ~0UL)
|
2019-11-29 13:48:31 +03:00
|
|
|
return -EFBIG;
|
2021-10-19 09:20:22 +03:00
|
|
|
return put_ulong(argp, bdev_nr_sectors(bdev));
|
2019-11-29 13:48:31 +03:00
|
|
|
|
|
|
|
/* The data is compatible, but the command number is different */
|
|
|
|
case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */
|
|
|
|
return put_int(argp, block_size(bdev));
|
|
|
|
case BLKBSZSET:
|
|
|
|
return blkdev_bszset(bdev, mode, argp);
|
|
|
|
case BLKGETSIZE64:
|
2021-10-19 09:20:22 +03:00
|
|
|
return put_u64(argp, bdev_nr_bytes(bdev));
|
2019-11-29 13:48:31 +03:00
|
|
|
|
|
|
|
/* Incompatible alignment on i386 */
|
|
|
|
case BLKTRACESETUP:
|
|
|
|
return blk_trace_ioctl(bdev, cmd, argp);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-02-17 05:21:59 +03:00
|
|
|
ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp);
|
2020-11-03 13:00:18 +03:00
|
|
|
if (ret != -ENOIOCTLCMD)
|
|
|
|
return ret;
|
2019-11-29 13:48:31 +03:00
|
|
|
|
2020-11-03 13:00:18 +03:00
|
|
|
if (!bdev->bd_disk->fops->ioctl)
|
|
|
|
return -ENOTTY;
|
|
|
|
return bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg);
|
2019-11-29 13:48:31 +03:00
|
|
|
}
|
2019-11-29 13:45:30 +03:00
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
2019-11-29 13:48:31 +03:00
|
|
|
|
2019-11-29 13:45:30 +03:00
|
|
|
#define BLKBSZGET_32 _IOR(0x12, 112, int)
|
|
|
|
#define BLKBSZSET_32 _IOW(0x12, 113, int)
|
|
|
|
#define BLKGETSIZE64_32 _IOR(0x12, 114, int)
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
{
|
2019-11-29 13:48:31 +03:00
|
|
|
int ret;
|
|
|
|
void __user *argp = compat_ptr(arg);
|
2020-11-23 15:38:40 +03:00
|
|
|
struct block_device *bdev = I_BDEV(file->f_mapping->host);
|
2019-11-29 13:45:30 +03:00
|
|
|
struct gendisk *disk = bdev->bd_disk;
|
|
|
|
fmode_t mode = file->f_mode;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
|
|
|
|
* to updated it before every ioctl.
|
|
|
|
*/
|
|
|
|
if (file->f_flags & O_NDELAY)
|
|
|
|
mode |= FMODE_NDELAY;
|
|
|
|
else
|
|
|
|
mode &= ~FMODE_NDELAY;
|
|
|
|
|
|
|
|
switch (cmd) {
|
2019-11-29 13:48:31 +03:00
|
|
|
/* These need separate implementations for the data structure */
|
2019-11-29 13:45:30 +03:00
|
|
|
case HDIO_GETGEO:
|
2019-11-29 13:48:31 +03:00
|
|
|
return compat_hdio_getgeo(bdev, argp);
|
2019-11-29 13:45:30 +03:00
|
|
|
case BLKPG:
|
2019-11-29 13:48:31 +03:00
|
|
|
return compat_blkpg_ioctl(bdev, argp);
|
|
|
|
|
|
|
|
/* Compat mode returns 32-bit data instead of 'long' */
|
2019-11-29 13:45:30 +03:00
|
|
|
case BLKRAGET:
|
|
|
|
case BLKFRAGET:
|
2019-11-29 13:48:31 +03:00
|
|
|
if (!argp)
|
2019-11-29 13:45:30 +03:00
|
|
|
return -EINVAL;
|
2019-11-29 13:48:31 +03:00
|
|
|
return compat_put_long(argp,
|
2021-08-09 17:17:44 +03:00
|
|
|
(bdev->bd_disk->bdi->ra_pages * PAGE_SIZE) / 512);
|
2019-11-29 13:45:30 +03:00
|
|
|
case BLKGETSIZE:
|
2022-04-15 01:40:56 +03:00
|
|
|
if (bdev_nr_sectors(bdev) > ~(compat_ulong_t)0)
|
2019-11-29 13:45:30 +03:00
|
|
|
return -EFBIG;
|
2021-10-19 09:20:22 +03:00
|
|
|
return compat_put_ulong(argp, bdev_nr_sectors(bdev));
|
2019-11-29 13:45:30 +03:00
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
/* The data is compatible, but the command number is different */
|
|
|
|
case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
|
|
|
|
return put_int(argp, bdev_logical_block_size(bdev));
|
|
|
|
case BLKBSZSET_32:
|
|
|
|
return blkdev_bszset(bdev, mode, argp);
|
2019-11-29 13:45:30 +03:00
|
|
|
case BLKGETSIZE64_32:
|
2021-10-19 09:20:22 +03:00
|
|
|
return put_u64(argp, bdev_nr_bytes(bdev));
|
2019-11-29 13:45:30 +03:00
|
|
|
|
2019-11-29 13:48:31 +03:00
|
|
|
/* Incompatible alignment on i386 */
|
2019-11-29 13:45:30 +03:00
|
|
|
case BLKTRACESETUP32:
|
2019-11-29 13:48:31 +03:00
|
|
|
return blk_trace_ioctl(bdev, cmd, argp);
|
2019-11-29 13:45:30 +03:00
|
|
|
default:
|
2019-11-29 13:48:31 +03:00
|
|
|
break;
|
2019-11-29 13:45:30 +03:00
|
|
|
}
|
2019-11-29 13:48:31 +03:00
|
|
|
|
2023-02-17 05:21:59 +03:00
|
|
|
ret = blkdev_common_ioctl(bdev, mode, cmd, arg, argp);
|
2019-11-29 13:48:31 +03:00
|
|
|
if (ret == -ENOIOCTLCMD && disk->fops->compat_ioctl)
|
|
|
|
ret = disk->fops->compat_ioctl(bdev, mode, cmd, arg);
|
|
|
|
|
|
|
|
return ret;
|
2019-11-29 13:45:30 +03:00
|
|
|
}
|
|
|
|
#endif
|