mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-04 01:24:12 +08:00
compat_ioctl: remove most of fs/compat_ioctl.c
As part of the cleanup of some remaining y2038 issues, I came to fs/compat_ioctl.c, which still has a couple of commands that need support for time64_t. In completely unrelated work, I spent time on cleaning up parts of this file in the past, moving things out into drivers instead. After Al Viro reviewed an earlier version of this series and did a lot more of that cleanup, I decided to try to completely eliminate the rest of it and move it all into drivers. This series incorporates some of Al's work and many patches of my own, but in the end stops short of actually removing the last part, which is the scsi ioctl handlers. I have patches for those as well, but they need more testing or possibly a rewrite. Signed-off-by: Arnd Bergmann <arnd@arndb.de> -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQIcBAABCAAGBQJdsHCdAAoJEJpsee/mABjZtYkP/1JGl3jFv3Iq/5BCdPkaePP1 RtMJRNfURgK3GeuHUui330PvVjI/pLWXU/VXMK2MPTASpJLzYz3uCaZrpVWEMpDZ +ImzGmgJkITlW1uWU3zOcQhOxTyb1hCZ0Ci+2xn9QAmyOL7prXoXCXDWv3h6iyiF lwG+nW+HNtyx41YG+9bRfKNoG0ZJ+nkJ70BV6u0acQHXWn7Xuupa9YUmBL87hxAL 6dlJfLTJg6q8QSv/Q6LxslfWk2Ti8OOJZOwtFM5R8Bgl0iUcvshiRCKfv/3t9jXD dJNvF1uq8z+gracWK49Qsfq5dnZ2ZxHFUo9u0NjbCrxNvWH/sdvhbaUBuJI75seH VIznCkdxFhrqitJJ8KmxANxG08u+9zSKjSlxG2SmlA4qFx/AoStoHwQXcogJscNb YIXYKmWBvwPzYu09QFAXdHFPmZvp/3HhMWU6o92lvDhsDwzkSGt3XKhCJea4DCaT m+oCcoACqSWhMwdbJOEFofSub4bY43s5iaYuKes+c8O261/Dwg6v/pgIVez9mxXm TBnvCsotq5m8wbwzv99eFqGeJH8zpDHrXxEtRR5KQqMqjLq/OQVaEzmpHZTEuK7n e/V/PAKo2/V63g4k6GApQXDxnjwT+m0aWToWoeEzPYXS6KmtWC91r4bWtslu3rdl bN65armTm7bFFR32Avnu =lgCl -----END PGP SIGNATURE----- Merge tag 'compat-ioctl-5.5' of git://git.kernel.org:/pub/scm/linux/kernel/git/arnd/playground Pull removal of most of fs/compat_ioctl.c from Arnd Bergmann: "As part of the cleanup of some remaining y2038 issues, I came to fs/compat_ioctl.c, which still has a couple of commands that need support for time64_t. In completely unrelated work, I spent time on cleaning up parts of this file in the past, moving things out into drivers instead. After Al Viro reviewed an earlier version of this series and did a lot more of that cleanup, I decided to try to completely eliminate the rest of it and move it all into drivers. This series incorporates some of Al's work and many patches of my own, but in the end stops short of actually removing the last part, which is the scsi ioctl handlers. I have patches for those as well, but they need more testing or possibly a rewrite" * tag 'compat-ioctl-5.5' of git://git.kernel.org:/pub/scm/linux/kernel/git/arnd/playground: (42 commits) scsi: sd: enable compat ioctls for sed-opal pktcdvd: add compat_ioctl handler compat_ioctl: move SG_GET_REQUEST_TABLE handling compat_ioctl: ppp: move simple commands into ppp_generic.c compat_ioctl: handle PPPIOCGIDLE for 64-bit time_t compat_ioctl: move PPPIOCSCOMPRESS to ppp_generic compat_ioctl: unify copy-in of ppp filters tty: handle compat PPP ioctls compat_ioctl: move SIOCOUTQ out of compat_ioctl.c compat_ioctl: handle SIOCOUTQNSD af_unix: add compat_ioctl support compat_ioctl: reimplement SG_IO handling compat_ioctl: move WDIOC handling into wdt drivers fs: compat_ioctl: move FITRIM emulation into file systems gfs2: add compat_ioctl support compat_ioctl: remove unused convert_in_user macro compat_ioctl: remove last RAID handling code compat_ioctl: remove /dev/raw ioctl translation compat_ioctl: remove PCI ioctl translation compat_ioctl: remove joystick ioctl translation ...
This commit is contained in:
commit
0da522107e
@ -378,6 +378,8 @@ an interface unit are:
|
||||
CONFIG_PPP_FILTER option is enabled, the set of packets which reset
|
||||
the transmit and receive idle timers is restricted to those which
|
||||
pass the `active' packet filter.
|
||||
Two versions of this command exist, to deal with user space
|
||||
expecting times as either 32-bit or 64-bit time_t seconds.
|
||||
|
||||
* PPPIOCSMAXCID sets the maximum connection-ID parameter (and thus the
|
||||
number of connection slots) for the TCP header compressor and
|
||||
|
@ -650,6 +650,7 @@ static const struct file_operations mpc52xx_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = mpc52xx_wdt_write,
|
||||
.unlocked_ioctl = mpc52xx_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = mpc52xx_wdt_open,
|
||||
.release = mpc52xx_wdt_release,
|
||||
};
|
||||
|
@ -165,6 +165,7 @@ static const struct file_operations harddog_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.write = harddog_write,
|
||||
.unlocked_ioctl = harddog_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = harddog_open,
|
||||
.release = harddog_release,
|
||||
.llseek = no_llseek,
|
||||
|
@ -298,6 +298,7 @@ static const struct file_operations hostaudio_fops = {
|
||||
.write = hostaudio_write,
|
||||
.poll = hostaudio_poll,
|
||||
.unlocked_ioctl = hostaudio_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.mmap = NULL,
|
||||
.open = hostaudio_open,
|
||||
.release = hostaudio_release,
|
||||
|
@ -2,6 +2,7 @@
|
||||
/*
|
||||
* Copyright (C) 2001 Jens Axboe <axboe@suse.de>
|
||||
*/
|
||||
#include <linux/compat.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/string.h>
|
||||
@ -327,7 +328,14 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
|
||||
struct iov_iter i;
|
||||
struct iovec *iov = NULL;
|
||||
|
||||
ret = import_iovec(rq_data_dir(rq),
|
||||
#ifdef CONFIG_COMPAT
|
||||
if (in_compat_syscall())
|
||||
ret = compat_import_iovec(rq_data_dir(rq),
|
||||
hdr->dxferp, hdr->iovec_count,
|
||||
0, &iov, &i);
|
||||
else
|
||||
#endif
|
||||
ret = import_iovec(rq_data_dir(rq),
|
||||
hdr->dxferp, hdr->iovec_count,
|
||||
0, &iov, &i);
|
||||
if (ret < 0)
|
||||
@ -542,6 +550,122 @@ static inline int blk_send_start_stop(struct request_queue *q,
|
||||
return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
struct compat_sg_io_hdr {
|
||||
compat_int_t interface_id; /* [i] 'S' for SCSI generic (required) */
|
||||
compat_int_t dxfer_direction; /* [i] data transfer direction */
|
||||
unsigned char cmd_len; /* [i] SCSI command length ( <= 16 bytes) */
|
||||
unsigned char mx_sb_len; /* [i] max length to write to sbp */
|
||||
unsigned short iovec_count; /* [i] 0 implies no scatter gather */
|
||||
compat_uint_t dxfer_len; /* [i] byte count of data transfer */
|
||||
compat_uint_t dxferp; /* [i], [*io] points to data transfer memory
|
||||
or scatter gather list */
|
||||
compat_uptr_t cmdp; /* [i], [*i] points to command to perform */
|
||||
compat_uptr_t sbp; /* [i], [*o] points to sense_buffer memory */
|
||||
compat_uint_t timeout; /* [i] MAX_UINT->no timeout (unit: millisec) */
|
||||
compat_uint_t flags; /* [i] 0 -> default, see SG_FLAG... */
|
||||
compat_int_t pack_id; /* [i->o] unused internally (normally) */
|
||||
compat_uptr_t usr_ptr; /* [i->o] unused internally */
|
||||
unsigned char status; /* [o] scsi status */
|
||||
unsigned char masked_status; /* [o] shifted, masked scsi status */
|
||||
unsigned char msg_status; /* [o] messaging level data (optional) */
|
||||
unsigned char sb_len_wr; /* [o] byte count actually written to sbp */
|
||||
unsigned short host_status; /* [o] errors from host adapter */
|
||||
unsigned short driver_status; /* [o] errors from software driver */
|
||||
compat_int_t resid; /* [o] dxfer_len - actual_transferred */
|
||||
compat_uint_t duration; /* [o] time taken by cmd (unit: millisec) */
|
||||
compat_uint_t info; /* [o] auxiliary information */
|
||||
};
|
||||
#endif
|
||||
|
||||
int put_sg_io_hdr(const struct sg_io_hdr *hdr, void __user *argp)
|
||||
{
|
||||
#ifdef CONFIG_COMPAT
|
||||
if (in_compat_syscall()) {
|
||||
struct compat_sg_io_hdr hdr32 = {
|
||||
.interface_id = hdr->interface_id,
|
||||
.dxfer_direction = hdr->dxfer_direction,
|
||||
.cmd_len = hdr->cmd_len,
|
||||
.mx_sb_len = hdr->mx_sb_len,
|
||||
.iovec_count = hdr->iovec_count,
|
||||
.dxfer_len = hdr->dxfer_len,
|
||||
.dxferp = (uintptr_t)hdr->dxferp,
|
||||
.cmdp = (uintptr_t)hdr->cmdp,
|
||||
.sbp = (uintptr_t)hdr->sbp,
|
||||
.timeout = hdr->timeout,
|
||||
.flags = hdr->flags,
|
||||
.pack_id = hdr->pack_id,
|
||||
.usr_ptr = (uintptr_t)hdr->usr_ptr,
|
||||
.status = hdr->status,
|
||||
.masked_status = hdr->masked_status,
|
||||
.msg_status = hdr->msg_status,
|
||||
.sb_len_wr = hdr->sb_len_wr,
|
||||
.host_status = hdr->host_status,
|
||||
.driver_status = hdr->driver_status,
|
||||
.resid = hdr->resid,
|
||||
.duration = hdr->duration,
|
||||
.info = hdr->info,
|
||||
};
|
||||
|
||||
if (copy_to_user(argp, &hdr32, sizeof(hdr32)))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (copy_to_user(argp, hdr, sizeof(*hdr)))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(put_sg_io_hdr);
|
||||
|
||||
int get_sg_io_hdr(struct sg_io_hdr *hdr, const void __user *argp)
|
||||
{
|
||||
#ifdef CONFIG_COMPAT
|
||||
struct compat_sg_io_hdr hdr32;
|
||||
|
||||
if (in_compat_syscall()) {
|
||||
if (copy_from_user(&hdr32, argp, sizeof(hdr32)))
|
||||
return -EFAULT;
|
||||
|
||||
*hdr = (struct sg_io_hdr) {
|
||||
.interface_id = hdr32.interface_id,
|
||||
.dxfer_direction = hdr32.dxfer_direction,
|
||||
.cmd_len = hdr32.cmd_len,
|
||||
.mx_sb_len = hdr32.mx_sb_len,
|
||||
.iovec_count = hdr32.iovec_count,
|
||||
.dxfer_len = hdr32.dxfer_len,
|
||||
.dxferp = compat_ptr(hdr32.dxferp),
|
||||
.cmdp = compat_ptr(hdr32.cmdp),
|
||||
.sbp = compat_ptr(hdr32.sbp),
|
||||
.timeout = hdr32.timeout,
|
||||
.flags = hdr32.flags,
|
||||
.pack_id = hdr32.pack_id,
|
||||
.usr_ptr = compat_ptr(hdr32.usr_ptr),
|
||||
.status = hdr32.status,
|
||||
.masked_status = hdr32.masked_status,
|
||||
.msg_status = hdr32.msg_status,
|
||||
.sb_len_wr = hdr32.sb_len_wr,
|
||||
.host_status = hdr32.host_status,
|
||||
.driver_status = hdr32.driver_status,
|
||||
.resid = hdr32.resid,
|
||||
.duration = hdr32.duration,
|
||||
.info = hdr32.info,
|
||||
};
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (copy_from_user(hdr, argp, sizeof(*hdr)))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(get_sg_io_hdr);
|
||||
|
||||
int scsi_cmd_ioctl(struct request_queue *q, struct gendisk *bd_disk, fmode_t mode,
|
||||
unsigned int cmd, void __user *arg)
|
||||
{
|
||||
@ -581,14 +705,14 @@ int scsi_cmd_ioctl(struct request_queue *q, struct gendisk *bd_disk, fmode_t mod
|
||||
case SG_IO: {
|
||||
struct sg_io_hdr hdr;
|
||||
|
||||
err = -EFAULT;
|
||||
if (copy_from_user(&hdr, arg, sizeof(hdr)))
|
||||
err = get_sg_io_hdr(&hdr, arg);
|
||||
if (err)
|
||||
break;
|
||||
err = sg_io(q, bd_disk, &hdr, mode);
|
||||
if (err == -EFAULT)
|
||||
break;
|
||||
|
||||
if (copy_to_user(arg, &hdr, sizeof(hdr)))
|
||||
if (put_sg_io_hdr(&hdr, arg))
|
||||
err = -EFAULT;
|
||||
break;
|
||||
}
|
||||
|
@ -6054,7 +6054,7 @@ const struct file_operations binder_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.poll = binder_poll,
|
||||
.unlocked_ioctl = binder_ioctl,
|
||||
.compat_ioctl = binder_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.mmap = binder_mmap,
|
||||
.open = binder_open,
|
||||
.flush = binder_flush,
|
||||
|
@ -2663,6 +2663,28 @@ static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static int pkt_compat_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
switch (cmd) {
|
||||
/* compatible */
|
||||
case CDROMEJECT:
|
||||
case CDROMMULTISESSION:
|
||||
case CDROMREADTOCENTRY:
|
||||
case SCSI_IOCTL_SEND_COMMAND:
|
||||
return pkt_ioctl(bdev, mode, cmd, (unsigned long)compat_ptr(arg));
|
||||
|
||||
|
||||
/* FIXME: no handler so far */
|
||||
case CDROM_LAST_WRITTEN:
|
||||
/* handled in compat_blkdev_driver_ioctl */
|
||||
case CDROM_SEND_PACKET:
|
||||
default:
|
||||
return -ENOIOCTLCMD;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static unsigned int pkt_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
@ -2684,6 +2706,9 @@ static const struct block_device_operations pktcdvd_ops = {
|
||||
.open = pkt_open,
|
||||
.release = pkt_close,
|
||||
.ioctl = pkt_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.ioctl = pkt_compat_ioctl,
|
||||
#endif
|
||||
.check_events = pkt_check_events,
|
||||
};
|
||||
|
||||
|
@ -893,6 +893,7 @@ static const struct file_operations ipmi_wdog_fops = {
|
||||
.poll = ipmi_poll,
|
||||
.write = ipmi_write,
|
||||
.unlocked_ioctl = ipmi_unlocked_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = ipmi_open,
|
||||
.release = ipmi_close,
|
||||
.fasync = ipmi_fasync,
|
||||
|
@ -678,14 +678,6 @@ static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long pp_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
return pp_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static int pp_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
unsigned int minor = iminor(inode);
|
||||
@ -794,9 +786,7 @@ static const struct file_operations pp_fops = {
|
||||
.write = pp_write,
|
||||
.poll = pp_poll,
|
||||
.unlocked_ioctl = pp_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = pp_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = pp_open,
|
||||
.release = pp_release,
|
||||
};
|
||||
|
@ -2166,6 +2166,7 @@ const struct file_operations random_fops = {
|
||||
.write = random_write,
|
||||
.poll = random_poll,
|
||||
.unlocked_ioctl = random_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.fasync = random_fasync,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
@ -670,20 +670,10 @@ static long vtpmx_fops_ioctl(struct file *f, unsigned int ioctl,
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vtpmx_fops_compat_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
return vtpmx_fops_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations vtpmx_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = vtpmx_fops_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vtpmx_fops_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
|
@ -68,7 +68,7 @@ static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);
|
||||
static const struct file_operations adf_ctl_ops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = adf_ctl_ioctl,
|
||||
.compat_ioctl = adf_ctl_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
struct adf_ctl_drv_info {
|
||||
|
@ -415,9 +415,7 @@ static const struct file_operations dma_buf_fops = {
|
||||
.llseek = dma_buf_llseek,
|
||||
.poll = dma_buf_poll,
|
||||
.unlocked_ioctl = dma_buf_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = dma_buf_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.show_fdinfo = dma_buf_show_fdinfo,
|
||||
};
|
||||
|
||||
|
@ -408,5 +408,5 @@ const struct file_operations sw_sync_debugfs_fops = {
|
||||
.open = sw_sync_debugfs_open,
|
||||
.release = sw_sync_debugfs_release,
|
||||
.unlocked_ioctl = sw_sync_ioctl,
|
||||
.compat_ioctl = sw_sync_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
@ -480,5 +480,5 @@ static const struct file_operations sync_file_fops = {
|
||||
.release = sync_file_release,
|
||||
.poll = sync_file_poll,
|
||||
.unlocked_ioctl = sync_file_ioctl,
|
||||
.compat_ioctl = sync_file_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
@ -1646,14 +1646,6 @@ static long fw_device_op_ioctl(struct file *file,
|
||||
return dispatch_ioctl(file->private_data, cmd, (void __user *)arg);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long fw_device_op_compat_ioctl(struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
return dispatch_ioctl(file->private_data, cmd, compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static int fw_device_op_mmap(struct file *file, struct vm_area_struct *vma)
|
||||
{
|
||||
struct client *client = file->private_data;
|
||||
@ -1795,7 +1787,5 @@ const struct file_operations fw_device_ops = {
|
||||
.mmap = fw_device_op_mmap,
|
||||
.release = fw_device_op_release,
|
||||
.poll = fw_device_op_poll,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = fw_device_op_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
@ -49,7 +49,7 @@ static const char kfd_dev_name[] = "kfd";
|
||||
static const struct file_operations kfd_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = kfd_ioctl,
|
||||
.compat_ioctl = kfd_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = kfd_open,
|
||||
.mmap = kfd_mmap,
|
||||
};
|
||||
|
@ -468,9 +468,7 @@ static const struct file_operations hidraw_ops = {
|
||||
.release = hidraw_release,
|
||||
.unlocked_ioctl = hidraw_ioctl,
|
||||
.fasync = hidraw_fasync,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = hidraw_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
|
@ -854,13 +854,6 @@ ret_unlock:
|
||||
return r;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long hiddev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
return hiddev_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations hiddev_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.read = hiddev_read,
|
||||
@ -870,9 +863,7 @@ static const struct file_operations hiddev_fops = {
|
||||
.release = hiddev_release,
|
||||
.unlocked_ioctl = hiddev_ioctl,
|
||||
.fasync = hiddev_fasync,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = hiddev_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
|
@ -954,6 +954,7 @@ static const struct file_operations watchdog_fops = {
|
||||
.release = watchdog_release,
|
||||
.write = watchdog_write,
|
||||
.unlocked_ioctl = watchdog_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
|
||||
|
@ -1458,6 +1458,7 @@ static const struct file_operations watchdog_fops = {
|
||||
.release = watchdog_close,
|
||||
.write = watchdog_write,
|
||||
.unlocked_ioctl = watchdog_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -832,23 +832,13 @@ stm_char_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long
|
||||
stm_char_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
return stm_char_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#else
|
||||
#define stm_char_compat_ioctl NULL
|
||||
#endif
|
||||
|
||||
static const struct file_operations stm_fops = {
|
||||
.open = stm_char_open,
|
||||
.release = stm_char_release,
|
||||
.write = stm_char_write,
|
||||
.mmap = stm_char_mmap,
|
||||
.unlocked_ioctl = stm_char_ioctl,
|
||||
.compat_ioctl = stm_char_compat_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = no_llseek,
|
||||
};
|
||||
|
||||
|
@ -19,6 +19,7 @@
|
||||
|
||||
#define IDETAPE_VERSION "1.20"
|
||||
|
||||
#include <linux/compat.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/string.h>
|
||||
@ -1407,14 +1408,10 @@ static long do_idetape_chrdev_ioctl(struct file *file,
|
||||
if (tape->drv_write_prot)
|
||||
mtget.mt_gstat |= GMT_WR_PROT(0xffffffff);
|
||||
|
||||
if (copy_to_user(argp, &mtget, sizeof(struct mtget)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
return put_user_mtget(argp, &mtget);
|
||||
case MTIOCPOS:
|
||||
mtpos.mt_blkno = position / tape->user_bs_factor - block_offset;
|
||||
if (copy_to_user(argp, &mtpos, sizeof(struct mtpos)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
return put_user_mtpos(argp, &mtpos);
|
||||
default:
|
||||
if (tape->chrdev_dir == IDETAPE_DIR_READ)
|
||||
ide_tape_discard_merge_buffer(drive, 1);
|
||||
@ -1432,6 +1429,22 @@ static long idetape_chrdev_ioctl(struct file *file,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static long idetape_chrdev_compat_ioctl(struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
long ret;
|
||||
|
||||
if (cmd == MTIOCPOS32)
|
||||
cmd = MTIOCPOS;
|
||||
else if (cmd == MTIOCGET32)
|
||||
cmd = MTIOCGET;
|
||||
|
||||
mutex_lock(&ide_tape_mutex);
|
||||
ret = do_idetape_chrdev_ioctl(file, cmd, arg);
|
||||
mutex_unlock(&ide_tape_mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Do a mode sense page 0 with block descriptor and if it succeeds set the tape
|
||||
* block size with the reported value.
|
||||
@ -1886,6 +1899,8 @@ static const struct file_operations idetape_fops = {
|
||||
.read = idetape_chrdev_read,
|
||||
.write = idetape_chrdev_write,
|
||||
.unlocked_ioctl = idetape_chrdev_ioctl,
|
||||
.compat_ioctl = IS_ENABLED(CONFIG_COMPAT) ?
|
||||
idetape_chrdev_compat_ioctl : NULL,
|
||||
.open = idetape_chrdev_open,
|
||||
.release = idetape_chrdev_release,
|
||||
.llseek = noop_llseek,
|
||||
|
@ -1624,7 +1624,7 @@ static const struct file_operations iio_buffer_fileops = {
|
||||
.owner = THIS_MODULE,
|
||||
.llseek = noop_llseek,
|
||||
.unlocked_ioctl = iio_ioctl,
|
||||
.compat_ioctl = iio_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static int iio_check_unique_scan_index(struct iio_dev *indio_dev)
|
||||
|
@ -1079,7 +1079,7 @@ static const struct file_operations uverbs_fops = {
|
||||
.release = ib_uverbs_close,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = ib_uverbs_ioctl,
|
||||
.compat_ioctl = ib_uverbs_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static const struct file_operations uverbs_mmap_fops = {
|
||||
@ -1090,7 +1090,7 @@ static const struct file_operations uverbs_mmap_fops = {
|
||||
.release = ib_uverbs_close,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = ib_uverbs_ioctl,
|
||||
.compat_ioctl = ib_uverbs_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static int ib_uverbs_get_nl_info(struct ib_device *ibdev, void *client_data,
|
||||
|
@ -950,6 +950,34 @@ capi_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long
|
||||
capi_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (cmd == CAPI_MANUFACTURER_CMD) {
|
||||
struct {
|
||||
compat_ulong_t cmd;
|
||||
compat_uptr_t data;
|
||||
} mcmd32;
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
if (copy_from_user(&mcmd32, compat_ptr(arg), sizeof(mcmd32)))
|
||||
return -EFAULT;
|
||||
|
||||
mutex_lock(&capi_mutex);
|
||||
ret = capi20_manufacturer(mcmd32.cmd, compat_ptr(mcmd32.data));
|
||||
mutex_unlock(&capi_mutex);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
return capi_unlocked_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static int capi_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
struct capidev *cdev;
|
||||
@ -996,6 +1024,9 @@ static const struct file_operations capi_fops =
|
||||
.write = capi_write,
|
||||
.poll = capi_poll,
|
||||
.unlocked_ioctl = capi_unlocked_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = capi_compat_ioctl,
|
||||
#endif
|
||||
.open = capi_open,
|
||||
.release = capi_release,
|
||||
};
|
||||
|
@ -720,9 +720,7 @@ static const struct file_operations lirc_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.write = ir_lirc_transmit_ir,
|
||||
.unlocked_ioctl = ir_lirc_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = ir_lirc_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.read = ir_lirc_read,
|
||||
.poll = ir_lirc_poll,
|
||||
.open = ir_lirc_open,
|
||||
|
@ -473,12 +473,6 @@ static long device_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static long device_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
return device_ioctl(file, cmd, arg);
|
||||
}
|
||||
|
||||
static int device_close(struct inode *inode, struct file *file)
|
||||
{
|
||||
struct cxl *adapter = file->private_data;
|
||||
@ -514,7 +508,7 @@ static const struct file_operations fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = device_open,
|
||||
.unlocked_ioctl = device_ioctl,
|
||||
.compat_ioctl = device_compat_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.release = device_close,
|
||||
};
|
||||
|
||||
|
@ -1215,34 +1215,13 @@ static long genwqe_ioctl(struct file *filp, unsigned int cmd,
|
||||
return rc;
|
||||
}
|
||||
|
||||
#if defined(CONFIG_COMPAT)
|
||||
/**
|
||||
* genwqe_compat_ioctl() - Compatibility ioctl
|
||||
*
|
||||
* Called whenever a 32-bit process running under a 64-bit kernel
|
||||
* performs an ioctl on /dev/genwqe<n>_card.
|
||||
*
|
||||
* @filp: file pointer.
|
||||
* @cmd: command.
|
||||
* @arg: user argument.
|
||||
* Return: zero on success or negative number on failure.
|
||||
*/
|
||||
static long genwqe_compat_ioctl(struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
return genwqe_ioctl(filp, cmd, arg);
|
||||
}
|
||||
#endif /* defined(CONFIG_COMPAT) */
|
||||
|
||||
static const struct file_operations genwqe_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = genwqe_open,
|
||||
.fasync = genwqe_fasync,
|
||||
.mmap = genwqe_mmap,
|
||||
.unlocked_ioctl = genwqe_ioctl,
|
||||
#if defined(CONFIG_COMPAT)
|
||||
.compat_ioctl = genwqe_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.release = genwqe_release,
|
||||
};
|
||||
|
||||
|
@ -532,24 +532,6 @@ out:
|
||||
return rets;
|
||||
}
|
||||
|
||||
/**
|
||||
* mei_compat_ioctl - the compat IOCTL function
|
||||
*
|
||||
* @file: pointer to file structure
|
||||
* @cmd: ioctl command
|
||||
* @data: pointer to mei message structure
|
||||
*
|
||||
* Return: 0 on success , <0 on error
|
||||
*/
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long mei_compat_ioctl(struct file *file,
|
||||
unsigned int cmd, unsigned long data)
|
||||
{
|
||||
return mei_ioctl(file, cmd, (unsigned long)compat_ptr(data));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* mei_poll - the poll function
|
||||
*
|
||||
@ -922,9 +904,7 @@ static const struct file_operations mei_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.read = mei_read,
|
||||
.unlocked_ioctl = mei_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = mei_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = mei_open,
|
||||
.release = mei_release,
|
||||
.write = mei_write,
|
||||
|
@ -968,7 +968,7 @@ static const struct file_operations vmuser_fops = {
|
||||
.release = vmci_host_close,
|
||||
.poll = vmci_host_poll,
|
||||
.unlocked_ioctl = vmci_host_unlocked_ioctl,
|
||||
.compat_ioctl = vmci_host_unlocked_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static struct miscdevice vmci_host_miscdev = {
|
||||
|
@ -1078,36 +1078,6 @@ static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd,
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vol_cdev_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
unsigned long translated_arg = (unsigned long)compat_ptr(arg);
|
||||
|
||||
return vol_cdev_ioctl(file, cmd, translated_arg);
|
||||
}
|
||||
|
||||
static long ubi_cdev_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
unsigned long translated_arg = (unsigned long)compat_ptr(arg);
|
||||
|
||||
return ubi_cdev_ioctl(file, cmd, translated_arg);
|
||||
}
|
||||
|
||||
static long ctrl_cdev_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
unsigned long translated_arg = (unsigned long)compat_ptr(arg);
|
||||
|
||||
return ctrl_cdev_ioctl(file, cmd, translated_arg);
|
||||
}
|
||||
#else
|
||||
#define vol_cdev_compat_ioctl NULL
|
||||
#define ubi_cdev_compat_ioctl NULL
|
||||
#define ctrl_cdev_compat_ioctl NULL
|
||||
#endif
|
||||
|
||||
/* UBI volume character device operations */
|
||||
const struct file_operations ubi_vol_cdev_operations = {
|
||||
.owner = THIS_MODULE,
|
||||
@ -1118,7 +1088,7 @@ const struct file_operations ubi_vol_cdev_operations = {
|
||||
.write = vol_cdev_write,
|
||||
.fsync = vol_cdev_fsync,
|
||||
.unlocked_ioctl = vol_cdev_ioctl,
|
||||
.compat_ioctl = vol_cdev_compat_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
/* UBI character device operations */
|
||||
@ -1126,13 +1096,13 @@ const struct file_operations ubi_cdev_operations = {
|
||||
.owner = THIS_MODULE,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = ubi_cdev_ioctl,
|
||||
.compat_ioctl = ubi_cdev_compat_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
/* UBI control character device operations */
|
||||
const struct file_operations ubi_ctrl_cdev_operations = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = ctrl_cdev_ioctl,
|
||||
.compat_ioctl = ctrl_cdev_compat_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = no_llseek,
|
||||
};
|
||||
|
@ -270,7 +270,7 @@ static void ppp_mp_insert(struct ppp *ppp, struct sk_buff *skb);
|
||||
static struct sk_buff *ppp_mp_reconstruct(struct ppp *ppp);
|
||||
static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb);
|
||||
#endif /* CONFIG_PPP_MULTILINK */
|
||||
static int ppp_set_compress(struct ppp *ppp, unsigned long arg);
|
||||
static int ppp_set_compress(struct ppp *ppp, struct ppp_option_data *data);
|
||||
static void ppp_ccp_peek(struct ppp *ppp, struct sk_buff *skb, int inbound);
|
||||
static void ppp_ccp_closed(struct ppp *ppp);
|
||||
static struct compressor *find_compressor(int type);
|
||||
@ -554,36 +554,66 @@ static __poll_t ppp_poll(struct file *file, poll_table *wait)
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PPP_FILTER
|
||||
static int get_filter(void __user *arg, struct sock_filter **p)
|
||||
static struct bpf_prog *get_filter(struct sock_fprog *uprog)
|
||||
{
|
||||
struct sock_fprog_kern fprog;
|
||||
struct bpf_prog *res = NULL;
|
||||
int err;
|
||||
|
||||
if (!uprog->len)
|
||||
return NULL;
|
||||
|
||||
/* uprog->len is unsigned short, so no overflow here */
|
||||
fprog.len = uprog->len * sizeof(struct sock_filter);
|
||||
fprog.filter = memdup_user(uprog->filter, fprog.len);
|
||||
if (IS_ERR(fprog.filter))
|
||||
return ERR_CAST(fprog.filter);
|
||||
|
||||
err = bpf_prog_create(&res, &fprog);
|
||||
kfree(fprog.filter);
|
||||
|
||||
return err ? ERR_PTR(err) : res;
|
||||
}
|
||||
|
||||
static struct bpf_prog *ppp_get_filter(struct sock_fprog __user *p)
|
||||
{
|
||||
struct sock_fprog uprog;
|
||||
struct sock_filter *code = NULL;
|
||||
int len;
|
||||
|
||||
if (copy_from_user(&uprog, arg, sizeof(uprog)))
|
||||
return -EFAULT;
|
||||
|
||||
if (!uprog.len) {
|
||||
*p = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
len = uprog.len * sizeof(struct sock_filter);
|
||||
code = memdup_user(uprog.filter, len);
|
||||
if (IS_ERR(code))
|
||||
return PTR_ERR(code);
|
||||
|
||||
*p = code;
|
||||
return uprog.len;
|
||||
if (copy_from_user(&uprog, p, sizeof(struct sock_fprog)))
|
||||
return ERR_PTR(-EFAULT);
|
||||
return get_filter(&uprog);
|
||||
}
|
||||
#endif /* CONFIG_PPP_FILTER */
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
struct sock_fprog32 {
|
||||
unsigned short len;
|
||||
compat_caddr_t filter;
|
||||
};
|
||||
|
||||
#define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
|
||||
#define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
|
||||
|
||||
static struct bpf_prog *compat_ppp_get_filter(struct sock_fprog32 __user *p)
|
||||
{
|
||||
struct sock_fprog32 uprog32;
|
||||
struct sock_fprog uprog;
|
||||
|
||||
if (copy_from_user(&uprog32, p, sizeof(struct sock_fprog32)))
|
||||
return ERR_PTR(-EFAULT);
|
||||
uprog.len = uprog32.len;
|
||||
uprog.filter = compat_ptr(uprog32.filter);
|
||||
return get_filter(&uprog);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct ppp_file *pf;
|
||||
struct ppp *ppp;
|
||||
int err = -EFAULT, val, val2, i;
|
||||
struct ppp_idle idle;
|
||||
struct ppp_idle32 idle32;
|
||||
struct ppp_idle64 idle64;
|
||||
struct npioctl npi;
|
||||
int unit, cflags;
|
||||
struct slcompress *vj;
|
||||
@ -679,9 +709,14 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
break;
|
||||
|
||||
case PPPIOCSCOMPRESS:
|
||||
err = ppp_set_compress(ppp, arg);
|
||||
{
|
||||
struct ppp_option_data data;
|
||||
if (copy_from_user(&data, argp, sizeof(data)))
|
||||
err = -EFAULT;
|
||||
else
|
||||
err = ppp_set_compress(ppp, &data);
|
||||
break;
|
||||
|
||||
}
|
||||
case PPPIOCGUNIT:
|
||||
if (put_user(ppp->file.index, p))
|
||||
break;
|
||||
@ -701,10 +736,18 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
err = 0;
|
||||
break;
|
||||
|
||||
case PPPIOCGIDLE:
|
||||
idle.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
|
||||
idle.recv_idle = (jiffies - ppp->last_recv) / HZ;
|
||||
if (copy_to_user(argp, &idle, sizeof(idle)))
|
||||
case PPPIOCGIDLE32:
|
||||
idle32.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
|
||||
idle32.recv_idle = (jiffies - ppp->last_recv) / HZ;
|
||||
if (copy_to_user(argp, &idle32, sizeof(idle32)))
|
||||
break;
|
||||
err = 0;
|
||||
break;
|
||||
|
||||
case PPPIOCGIDLE64:
|
||||
idle64.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
|
||||
idle64.recv_idle = (jiffies - ppp->last_recv) / HZ;
|
||||
if (copy_to_user(argp, &idle64, sizeof(idle64)))
|
||||
break;
|
||||
err = 0;
|
||||
break;
|
||||
@ -753,55 +796,25 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
|
||||
#ifdef CONFIG_PPP_FILTER
|
||||
case PPPIOCSPASS:
|
||||
{
|
||||
struct sock_filter *code;
|
||||
|
||||
err = get_filter(argp, &code);
|
||||
if (err >= 0) {
|
||||
struct bpf_prog *pass_filter = NULL;
|
||||
struct sock_fprog_kern fprog = {
|
||||
.len = err,
|
||||
.filter = code,
|
||||
};
|
||||
|
||||
err = 0;
|
||||
if (fprog.filter)
|
||||
err = bpf_prog_create(&pass_filter, &fprog);
|
||||
if (!err) {
|
||||
ppp_lock(ppp);
|
||||
if (ppp->pass_filter)
|
||||
bpf_prog_destroy(ppp->pass_filter);
|
||||
ppp->pass_filter = pass_filter;
|
||||
ppp_unlock(ppp);
|
||||
}
|
||||
kfree(code);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case PPPIOCSACTIVE:
|
||||
{
|
||||
struct sock_filter *code;
|
||||
struct bpf_prog *filter = ppp_get_filter(argp);
|
||||
struct bpf_prog **which;
|
||||
|
||||
err = get_filter(argp, &code);
|
||||
if (err >= 0) {
|
||||
struct bpf_prog *active_filter = NULL;
|
||||
struct sock_fprog_kern fprog = {
|
||||
.len = err,
|
||||
.filter = code,
|
||||
};
|
||||
|
||||
err = 0;
|
||||
if (fprog.filter)
|
||||
err = bpf_prog_create(&active_filter, &fprog);
|
||||
if (!err) {
|
||||
ppp_lock(ppp);
|
||||
if (ppp->active_filter)
|
||||
bpf_prog_destroy(ppp->active_filter);
|
||||
ppp->active_filter = active_filter;
|
||||
ppp_unlock(ppp);
|
||||
}
|
||||
kfree(code);
|
||||
if (IS_ERR(filter)) {
|
||||
err = PTR_ERR(filter);
|
||||
break;
|
||||
}
|
||||
if (cmd == PPPIOCSPASS)
|
||||
which = &ppp->pass_filter;
|
||||
else
|
||||
which = &ppp->active_filter;
|
||||
ppp_lock(ppp);
|
||||
if (*which)
|
||||
bpf_prog_destroy(*which);
|
||||
*which = filter;
|
||||
ppp_unlock(ppp);
|
||||
err = 0;
|
||||
break;
|
||||
}
|
||||
#endif /* CONFIG_PPP_FILTER */
|
||||
@ -827,6 +840,77 @@ out:
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
struct ppp_option_data32 {
|
||||
compat_uptr_t ptr;
|
||||
u32 length;
|
||||
compat_int_t transmit;
|
||||
};
|
||||
#define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
|
||||
|
||||
static long ppp_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct ppp_file *pf;
|
||||
int err = -ENOIOCTLCMD;
|
||||
void __user *argp = (void __user *)arg;
|
||||
|
||||
mutex_lock(&ppp_mutex);
|
||||
|
||||
pf = file->private_data;
|
||||
if (pf && pf->kind == INTERFACE) {
|
||||
struct ppp *ppp = PF_TO_PPP(pf);
|
||||
switch (cmd) {
|
||||
#ifdef CONFIG_PPP_FILTER
|
||||
case PPPIOCSPASS32:
|
||||
case PPPIOCSACTIVE32:
|
||||
{
|
||||
struct bpf_prog *filter = compat_ppp_get_filter(argp);
|
||||
struct bpf_prog **which;
|
||||
|
||||
if (IS_ERR(filter)) {
|
||||
err = PTR_ERR(filter);
|
||||
break;
|
||||
}
|
||||
if (cmd == PPPIOCSPASS32)
|
||||
which = &ppp->pass_filter;
|
||||
else
|
||||
which = &ppp->active_filter;
|
||||
ppp_lock(ppp);
|
||||
if (*which)
|
||||
bpf_prog_destroy(*which);
|
||||
*which = filter;
|
||||
ppp_unlock(ppp);
|
||||
err = 0;
|
||||
break;
|
||||
}
|
||||
#endif /* CONFIG_PPP_FILTER */
|
||||
case PPPIOCSCOMPRESS32:
|
||||
{
|
||||
struct ppp_option_data32 data32;
|
||||
if (copy_from_user(&data32, argp, sizeof(data32))) {
|
||||
err = -EFAULT;
|
||||
} else {
|
||||
struct ppp_option_data data = {
|
||||
.ptr = compat_ptr(data32.ptr),
|
||||
.length = data32.length,
|
||||
.transmit = data32.transmit
|
||||
};
|
||||
err = ppp_set_compress(ppp, &data);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
mutex_unlock(&ppp_mutex);
|
||||
|
||||
/* all other commands have compatible arguments */
|
||||
if (err == -ENOIOCTLCMD)
|
||||
err = ppp_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
|
||||
return err;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int ppp_unattached_ioctl(struct net *net, struct ppp_file *pf,
|
||||
struct file *file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
@ -895,6 +979,9 @@ static const struct file_operations ppp_device_fops = {
|
||||
.write = ppp_write,
|
||||
.poll = ppp_poll,
|
||||
.unlocked_ioctl = ppp_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = ppp_compat_ioctl,
|
||||
#endif
|
||||
.open = ppp_open,
|
||||
.release = ppp_release,
|
||||
.llseek = noop_llseek,
|
||||
@ -2734,24 +2821,20 @@ ppp_output_wakeup(struct ppp_channel *chan)
|
||||
|
||||
/* Process the PPPIOCSCOMPRESS ioctl. */
|
||||
static int
|
||||
ppp_set_compress(struct ppp *ppp, unsigned long arg)
|
||||
ppp_set_compress(struct ppp *ppp, struct ppp_option_data *data)
|
||||
{
|
||||
int err;
|
||||
int err = -EFAULT;
|
||||
struct compressor *cp, *ocomp;
|
||||
struct ppp_option_data data;
|
||||
void *state, *ostate;
|
||||
unsigned char ccp_option[CCP_MAX_OPTION_LENGTH];
|
||||
|
||||
err = -EFAULT;
|
||||
if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
|
||||
if (data->length > CCP_MAX_OPTION_LENGTH)
|
||||
goto out;
|
||||
if (data.length > CCP_MAX_OPTION_LENGTH)
|
||||
goto out;
|
||||
if (copy_from_user(ccp_option, (void __user *) data.ptr, data.length))
|
||||
if (copy_from_user(ccp_option, data->ptr, data->length))
|
||||
goto out;
|
||||
|
||||
err = -EINVAL;
|
||||
if (data.length < 2 || ccp_option[1] < 2 || ccp_option[1] > data.length)
|
||||
if (data->length < 2 || ccp_option[1] < 2 || ccp_option[1] > data->length)
|
||||
goto out;
|
||||
|
||||
cp = try_then_request_module(
|
||||
@ -2761,8 +2844,8 @@ ppp_set_compress(struct ppp *ppp, unsigned long arg)
|
||||
goto out;
|
||||
|
||||
err = -ENOBUFS;
|
||||
if (data.transmit) {
|
||||
state = cp->comp_alloc(ccp_option, data.length);
|
||||
if (data->transmit) {
|
||||
state = cp->comp_alloc(ccp_option, data->length);
|
||||
if (state) {
|
||||
ppp_xmit_lock(ppp);
|
||||
ppp->xstate &= ~SC_COMP_RUN;
|
||||
@ -2780,7 +2863,7 @@ ppp_set_compress(struct ppp *ppp, unsigned long arg)
|
||||
module_put(cp->owner);
|
||||
|
||||
} else {
|
||||
state = cp->decomp_alloc(ccp_option, data.length);
|
||||
state = cp->decomp_alloc(ccp_option, data->length);
|
||||
if (state) {
|
||||
ppp_recv_lock(ppp);
|
||||
ppp->rstate &= ~SC_DECOMP_RUN;
|
||||
|
@ -1123,14 +1123,6 @@ static long tap_ioctl(struct file *file, unsigned int cmd,
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long tap_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
return tap_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations tap_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = tap_open,
|
||||
@ -1140,9 +1132,7 @@ static const struct file_operations tap_fops = {
|
||||
.poll = tap_poll,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = tap_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = tap_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static int tap_get_user_xdp(struct tap_queue *q, struct xdp_buff *xdp)
|
||||
|
@ -1227,7 +1227,7 @@ static const struct file_operations nvdimm_bus_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = nd_open,
|
||||
.unlocked_ioctl = bus_ioctl,
|
||||
.compat_ioctl = bus_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
@ -1235,7 +1235,7 @@ static const struct file_operations nvdimm_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = nd_open,
|
||||
.unlocked_ioctl = dimm_ioctl,
|
||||
.compat_ioctl = dimm_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
|
@ -2998,7 +2998,7 @@ static const struct file_operations nvme_dev_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = nvme_dev_open,
|
||||
.unlocked_ioctl = nvme_dev_ioctl,
|
||||
.compat_ioctl = nvme_dev_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static ssize_t nvme_sysfs_reset(struct device *dev,
|
||||
|
@ -1025,7 +1025,7 @@ static const struct file_operations switchtec_fops = {
|
||||
.read = switchtec_dev_read,
|
||||
.poll = switchtec_dev_poll,
|
||||
.unlocked_ioctl = switchtec_dev_ioctl,
|
||||
.compat_ioctl = switchtec_dev_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static void link_event_work(struct work_struct *work)
|
||||
|
@ -911,7 +911,7 @@ static const struct file_operations wmi_fops = {
|
||||
.read = wmi_char_read,
|
||||
.open = wmi_char_open,
|
||||
.unlocked_ioctl = wmi_ioctl,
|
||||
.compat_ioctl = wmi_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static int wmi_dev_probe(struct device *dev)
|
||||
|
@ -290,7 +290,7 @@ static const struct file_operations rpmsg_eptdev_fops = {
|
||||
.write_iter = rpmsg_eptdev_write_iter,
|
||||
.poll = rpmsg_eptdev_poll,
|
||||
.unlocked_ioctl = rpmsg_eptdev_ioctl,
|
||||
.compat_ioctl = rpmsg_eptdev_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static ssize_t name_show(struct device *dev, struct device_attribute *attr,
|
||||
@ -451,7 +451,7 @@ static const struct file_operations rpmsg_ctrldev_fops = {
|
||||
.open = rpmsg_ctrldev_open,
|
||||
.release = rpmsg_ctrldev_release,
|
||||
.unlocked_ioctl = rpmsg_ctrldev_ioctl,
|
||||
.compat_ioctl = rpmsg_ctrldev_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static void rpmsg_ctrldev_release_device(struct device *dev)
|
||||
|
@ -10,6 +10,7 @@
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
|
||||
#include <linux/compat.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/rtc.h>
|
||||
#include <linux/sched/signal.h>
|
||||
@ -360,7 +361,6 @@ static long rtc_dev_ioctl(struct file *file,
|
||||
case RTC_IRQP_SET:
|
||||
err = rtc_irq_set_freq(rtc, arg);
|
||||
break;
|
||||
|
||||
case RTC_IRQP_READ:
|
||||
err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
|
||||
break;
|
||||
@ -399,6 +399,34 @@ done:
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
#define RTC_IRQP_SET32 _IOW('p', 0x0c, __u32)
|
||||
#define RTC_IRQP_READ32 _IOR('p', 0x0b, __u32)
|
||||
#define RTC_EPOCH_SET32 _IOW('p', 0x0e, __u32)
|
||||
|
||||
static long rtc_dev_compat_ioctl(struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct rtc_device *rtc = file->private_data;
|
||||
void __user *uarg = compat_ptr(arg);
|
||||
|
||||
switch (cmd) {
|
||||
case RTC_IRQP_READ32:
|
||||
return put_user(rtc->irq_freq, (__u32 __user *)uarg);
|
||||
|
||||
case RTC_IRQP_SET32:
|
||||
/* arg is a plain integer, not pointer */
|
||||
return rtc_dev_ioctl(file, RTC_IRQP_SET, arg);
|
||||
|
||||
case RTC_EPOCH_SET32:
|
||||
/* arg is a plain integer, not pointer */
|
||||
return rtc_dev_ioctl(file, RTC_EPOCH_SET, arg);
|
||||
}
|
||||
|
||||
return rtc_dev_ioctl(file, cmd, (unsigned long)uarg);
|
||||
}
|
||||
#endif
|
||||
|
||||
static int rtc_dev_fasync(int fd, struct file *file, int on)
|
||||
{
|
||||
struct rtc_device *rtc = file->private_data;
|
||||
@ -434,6 +462,9 @@ static const struct file_operations rtc_dev_fops = {
|
||||
.read = rtc_dev_read,
|
||||
.poll = rtc_dev_poll,
|
||||
.unlocked_ioctl = rtc_dev_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = rtc_dev_compat_ioctl,
|
||||
#endif
|
||||
.open = rtc_dev_open,
|
||||
.release = rtc_dev_release,
|
||||
.fasync = rtc_dev_fasync,
|
||||
|
@ -586,6 +586,7 @@ static const struct file_operations ds1374_wdt_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.read = ds1374_wdt_read,
|
||||
.unlocked_ioctl = ds1374_wdt_unlocked_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.write = ds1374_wdt_write,
|
||||
.open = ds1374_wdt_open,
|
||||
.release = ds1374_wdt_release,
|
||||
|
@ -840,6 +840,7 @@ static const struct file_operations wdt_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.read = wdt_read,
|
||||
.unlocked_ioctl = wdt_unlocked_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.write = wdt_write,
|
||||
.open = wdt_open,
|
||||
.release = wdt_release,
|
||||
|
@ -4,6 +4,7 @@
|
||||
*
|
||||
* Copyright (C) 2003-2008 Yoichi Yuasa <yuasa@linux-mips.org>
|
||||
*/
|
||||
#include <linux/compat.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/init.h>
|
||||
@ -66,6 +67,9 @@ static void __iomem *rtc2_base;
|
||||
#define rtc2_read(offset) readw(rtc2_base + (offset))
|
||||
#define rtc2_write(offset, value) writew((value), rtc2_base + (offset))
|
||||
|
||||
/* 32-bit compat for ioctls that nobody else uses */
|
||||
#define RTC_EPOCH_READ32 _IOR('p', 0x0d, __u32)
|
||||
|
||||
static unsigned long epoch = 1970; /* Jan 1 1970 00:00:00 */
|
||||
|
||||
static DEFINE_SPINLOCK(rtc_lock);
|
||||
@ -179,6 +183,10 @@ static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long
|
||||
switch (cmd) {
|
||||
case RTC_EPOCH_READ:
|
||||
return put_user(epoch, (unsigned long __user *)arg);
|
||||
#ifdef CONFIG_64BIT
|
||||
case RTC_EPOCH_READ32:
|
||||
return put_user(epoch, (unsigned int __user *)arg);
|
||||
#endif
|
||||
case RTC_EPOCH_SET:
|
||||
/* Doesn't support before 1900 */
|
||||
if (arg < 1900)
|
||||
|
@ -341,14 +341,14 @@ tapechar_release(struct inode *inode, struct file *filp)
|
||||
*/
|
||||
static int
|
||||
__tapechar_ioctl(struct tape_device *device,
|
||||
unsigned int no, unsigned long data)
|
||||
unsigned int no, void __user *data)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (no == MTIOCTOP) {
|
||||
struct mtop op;
|
||||
|
||||
if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0)
|
||||
if (copy_from_user(&op, data, sizeof(op)) != 0)
|
||||
return -EFAULT;
|
||||
if (op.mt_count < 0)
|
||||
return -EINVAL;
|
||||
@ -392,9 +392,7 @@ __tapechar_ioctl(struct tape_device *device,
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
pos.mt_blkno = rc;
|
||||
if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0)
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
return put_user_mtpos(data, &pos);
|
||||
}
|
||||
if (no == MTIOCGET) {
|
||||
/* MTIOCGET: query the tape drive status. */
|
||||
@ -424,15 +422,12 @@ __tapechar_ioctl(struct tape_device *device,
|
||||
get.mt_blkno = rc;
|
||||
}
|
||||
|
||||
if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0)
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
return put_user_mtget(data, &get);
|
||||
}
|
||||
/* Try the discipline ioctl function. */
|
||||
if (device->discipline->ioctl_fn == NULL)
|
||||
return -EINVAL;
|
||||
return device->discipline->ioctl_fn(device, no, data);
|
||||
return device->discipline->ioctl_fn(device, no, (unsigned long)data);
|
||||
}
|
||||
|
||||
static long
|
||||
@ -445,7 +440,7 @@ tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data)
|
||||
|
||||
device = (struct tape_device *) filp->private_data;
|
||||
mutex_lock(&device->mutex);
|
||||
rc = __tapechar_ioctl(device, no, data);
|
||||
rc = __tapechar_ioctl(device, no, (void __user *)data);
|
||||
mutex_unlock(&device->mutex);
|
||||
return rc;
|
||||
}
|
||||
@ -455,23 +450,17 @@ static long
|
||||
tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
|
||||
{
|
||||
struct tape_device *device = filp->private_data;
|
||||
int rval = -ENOIOCTLCMD;
|
||||
unsigned long argp;
|
||||
long rc;
|
||||
|
||||
/* The 'arg' argument of any ioctl function may only be used for
|
||||
* pointers because of the compat pointer conversion.
|
||||
* Consider this when adding new ioctls.
|
||||
*/
|
||||
argp = (unsigned long) compat_ptr(data);
|
||||
if (device->discipline->ioctl_fn) {
|
||||
mutex_lock(&device->mutex);
|
||||
rval = device->discipline->ioctl_fn(device, no, argp);
|
||||
mutex_unlock(&device->mutex);
|
||||
if (rval == -EINVAL)
|
||||
rval = -ENOIOCTLCMD;
|
||||
}
|
||||
if (no == MTIOCPOS32)
|
||||
no = MTIOCPOS;
|
||||
else if (no == MTIOCGET32)
|
||||
no = MTIOCGET;
|
||||
|
||||
return rval;
|
||||
mutex_lock(&device->mutex);
|
||||
rc = __tapechar_ioctl(device, no, compat_ptr(data));
|
||||
mutex_unlock(&device->mutex);
|
||||
return rc;
|
||||
}
|
||||
#endif /* CONFIG_COMPAT */
|
||||
|
||||
|
@ -156,7 +156,7 @@ static long d7s_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
static const struct file_operations d7s_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = d7s_ioctl,
|
||||
.compat_ioctl = d7s_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = d7s_open,
|
||||
.release = d7s_release,
|
||||
.llseek = noop_llseek,
|
||||
|
@ -715,9 +715,7 @@ static const struct file_operations envctrl_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.read = envctrl_read,
|
||||
.unlocked_ioctl = envctrl_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = envctrl_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = envctrl_open,
|
||||
.release = envctrl_release,
|
||||
.llseek = noop_llseek,
|
||||
|
@ -1049,9 +1049,7 @@ static int tw_chrdev_open(struct inode *inode, struct file *file)
|
||||
static const struct file_operations tw_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = tw_chrdev_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = tw_chrdev_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = tw_chrdev_open,
|
||||
.release = NULL,
|
||||
.llseek = noop_llseek,
|
||||
|
@ -3593,7 +3593,7 @@ static const struct file_operations cxlflash_chr_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = cxlflash_chr_open,
|
||||
.unlocked_ioctl = cxlflash_chr_ioctl,
|
||||
.compat_ioctl = cxlflash_chr_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -613,7 +613,7 @@ static int __init esas2r_init(void)
|
||||
|
||||
/* Handle ioctl calls to "/proc/scsi/esas2r/ATTOnode" */
|
||||
static const struct file_operations esas2r_proc_fops = {
|
||||
.compat_ioctl = esas2r_proc_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.unlocked_ioctl = esas2r_proc_ioctl,
|
||||
};
|
||||
|
||||
|
@ -41,10 +41,6 @@ static int mraid_mm_setup_dma_pools(mraid_mmadp_t *);
|
||||
static void mraid_mm_free_adp_resources(mraid_mmadp_t *);
|
||||
static void mraid_mm_teardown_dma_pools(mraid_mmadp_t *);
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long mraid_mm_compat_ioctl(struct file *, unsigned int, unsigned long);
|
||||
#endif
|
||||
|
||||
MODULE_AUTHOR("LSI Logic Corporation");
|
||||
MODULE_DESCRIPTION("LSI Logic Management Module");
|
||||
MODULE_LICENSE("GPL");
|
||||
@ -68,9 +64,7 @@ static wait_queue_head_t wait_q;
|
||||
static const struct file_operations lsi_fops = {
|
||||
.open = mraid_mm_open,
|
||||
.unlocked_ioctl = mraid_mm_unlocked_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = mraid_mm_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.owner = THIS_MODULE,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
@ -224,7 +218,6 @@ mraid_mm_unlocked_ioctl(struct file *filep, unsigned int cmd,
|
||||
{
|
||||
int err;
|
||||
|
||||
/* inconsistent: mraid_mm_compat_ioctl doesn't take the BKL */
|
||||
mutex_lock(&mraid_mm_mutex);
|
||||
err = mraid_mm_ioctl(filep, cmd, arg);
|
||||
mutex_unlock(&mraid_mm_mutex);
|
||||
@ -1228,25 +1221,6 @@ mraid_mm_init(void)
|
||||
}
|
||||
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
/**
|
||||
* mraid_mm_compat_ioctl - 32bit to 64bit ioctl conversion routine
|
||||
* @filep : file operations pointer (ignored)
|
||||
* @cmd : ioctl command
|
||||
* @arg : user ioctl packet
|
||||
*/
|
||||
static long
|
||||
mraid_mm_compat_ioctl(struct file *filep, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = mraid_mm_ioctl(filep, cmd, arg);
|
||||
|
||||
return err;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* mraid_mm_exit - Module exit point
|
||||
*/
|
||||
|
@ -3973,9 +3973,7 @@ static const struct file_operations pmcraid_fops = {
|
||||
.open = pmcraid_chr_open,
|
||||
.fasync = pmcraid_chr_fasync,
|
||||
.unlocked_ioctl = pmcraid_chr_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = pmcraid_chr_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
|
@ -1702,20 +1702,30 @@ static void sd_rescan(struct device *dev)
|
||||
static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
|
||||
struct gendisk *disk = bdev->bd_disk;
|
||||
struct scsi_disk *sdkp = scsi_disk(disk);
|
||||
struct scsi_device *sdev = sdkp->device;
|
||||
void __user *p = compat_ptr(arg);
|
||||
int error;
|
||||
|
||||
error = scsi_verify_blk_ioctl(bdev, cmd);
|
||||
if (error < 0)
|
||||
return error;
|
||||
|
||||
error = scsi_ioctl_block_when_processing_errors(sdev, cmd,
|
||||
(mode & FMODE_NDELAY) != 0);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
if (is_sed_ioctl(cmd))
|
||||
return sed_ioctl(sdkp->opal_dev, cmd, p);
|
||||
|
||||
/*
|
||||
* Let the static ioctl translation table take care of it.
|
||||
*/
|
||||
if (!sdev->host->hostt->compat_ioctl)
|
||||
return -ENOIOCTLCMD;
|
||||
return sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
|
||||
return sdev->host->hostt->compat_ioctl(sdev, cmd, p);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -447,8 +447,7 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
|
||||
retval = -ENOMEM;
|
||||
goto free_old_hdr;
|
||||
}
|
||||
retval =__copy_from_user
|
||||
(new_hdr, buf, SZ_SG_IO_HDR);
|
||||
retval = get_sg_io_hdr(new_hdr, buf);
|
||||
req_pack_id = new_hdr->pack_id;
|
||||
kfree(new_hdr);
|
||||
if (retval) {
|
||||
@ -589,10 +588,7 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
|
||||
}
|
||||
if (hp->masked_status || hp->host_status || hp->driver_status)
|
||||
hp->info |= SG_INFO_CHECK;
|
||||
if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
|
||||
err = -EFAULT;
|
||||
goto err_out;
|
||||
}
|
||||
err = put_sg_io_hdr(hp, buf);
|
||||
err_out:
|
||||
err2 = sg_finish_rem_req(srp);
|
||||
sg_remove_request(sfp, srp);
|
||||
@ -735,7 +731,7 @@ sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
|
||||
}
|
||||
srp->sg_io_owned = sg_io_owned;
|
||||
hp = &srp->header;
|
||||
if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
|
||||
if (get_sg_io_hdr(hp, buf)) {
|
||||
sg_remove_request(sfp, srp);
|
||||
return -EFAULT;
|
||||
}
|
||||
@ -893,6 +889,33 @@ sg_fill_request_table(Sg_fd *sfp, sg_req_info_t *rinfo)
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
struct compat_sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
|
||||
char req_state;
|
||||
char orphan;
|
||||
char sg_io_owned;
|
||||
char problem;
|
||||
int pack_id;
|
||||
compat_uptr_t usr_ptr;
|
||||
unsigned int duration;
|
||||
int unused;
|
||||
};
|
||||
|
||||
static int put_compat_request_table(struct compat_sg_req_info __user *o,
|
||||
struct sg_req_info *rinfo)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < SG_MAX_QUEUE; i++) {
|
||||
if (copy_to_user(o + i, rinfo + i, offsetof(sg_req_info_t, usr_ptr)) ||
|
||||
put_user((uintptr_t)rinfo[i].usr_ptr, &o[i].usr_ptr) ||
|
||||
put_user(rinfo[i].duration, &o[i].duration) ||
|
||||
put_user(rinfo[i].unused, &o[i].unused))
|
||||
return -EFAULT;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static long
|
||||
sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
|
||||
{
|
||||
@ -1073,9 +1096,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
|
||||
val = (sdp->device ? 1 : 0);
|
||||
return put_user(val, ip);
|
||||
case SG_GET_REQUEST_TABLE:
|
||||
if (!access_ok(p, SZ_SG_REQ_INFO * SG_MAX_QUEUE))
|
||||
return -EFAULT;
|
||||
else {
|
||||
{
|
||||
sg_req_info_t *rinfo;
|
||||
|
||||
rinfo = kcalloc(SG_MAX_QUEUE, SZ_SG_REQ_INFO,
|
||||
@ -1085,8 +1106,13 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
|
||||
read_lock_irqsave(&sfp->rq_list_lock, iflags);
|
||||
sg_fill_request_table(sfp, rinfo);
|
||||
read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
|
||||
result = __copy_to_user(p, rinfo,
|
||||
SZ_SG_REQ_INFO * SG_MAX_QUEUE);
|
||||
#ifdef CONFIG_COMPAT
|
||||
if (in_compat_syscall())
|
||||
result = put_compat_request_table(p, rinfo);
|
||||
else
|
||||
#endif
|
||||
result = copy_to_user(p, rinfo,
|
||||
SZ_SG_REQ_INFO * SG_MAX_QUEUE);
|
||||
result = result ? -EFAULT : 0;
|
||||
kfree(rinfo);
|
||||
return result;
|
||||
@ -1797,7 +1823,14 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
|
||||
struct iovec *iov = NULL;
|
||||
struct iov_iter i;
|
||||
|
||||
res = import_iovec(rw, hp->dxferp, iov_count, 0, &iov, &i);
|
||||
#ifdef CONFIG_COMPAT
|
||||
if (in_compat_syscall())
|
||||
res = compat_import_iovec(rw, hp->dxferp, iov_count,
|
||||
0, &iov, &i);
|
||||
else
|
||||
#endif
|
||||
res = import_iovec(rw, hp->dxferp, iov_count,
|
||||
0, &iov, &i);
|
||||
if (res < 0)
|
||||
return res;
|
||||
|
||||
|
@ -22,6 +22,7 @@ static const char *verstr = "20160209";
|
||||
|
||||
#include <linux/module.h>
|
||||
|
||||
#include <linux/compat.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched/signal.h>
|
||||
@ -3800,14 +3801,11 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
|
||||
if (STp->cleaning_req)
|
||||
mt_status.mt_gstat |= GMT_CLN(0xffffffff);
|
||||
|
||||
i = copy_to_user(p, &mt_status, sizeof(struct mtget));
|
||||
if (i) {
|
||||
retval = (-EFAULT);
|
||||
retval = put_user_mtget(p, &mt_status);
|
||||
if (retval)
|
||||
goto out;
|
||||
}
|
||||
|
||||
STp->recover_reg = 0; /* Clear after read */
|
||||
retval = 0;
|
||||
goto out;
|
||||
} /* End of MTIOCGET */
|
||||
if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
|
||||
@ -3821,9 +3819,7 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
|
||||
goto out;
|
||||
}
|
||||
mt_pos.mt_blkno = blk;
|
||||
i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
|
||||
if (i)
|
||||
retval = (-EFAULT);
|
||||
retval = put_user_mtpos(p, &mt_pos);
|
||||
goto out;
|
||||
}
|
||||
mutex_unlock(&STp->lock);
|
||||
@ -3857,14 +3853,26 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
||||
static long st_compat_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
|
||||
{
|
||||
void __user *p = compat_ptr(arg);
|
||||
struct scsi_tape *STp = file->private_data;
|
||||
struct scsi_device *sdev = STp->device;
|
||||
int ret = -ENOIOCTLCMD;
|
||||
|
||||
/* argument conversion is handled using put_user_mtpos/put_user_mtget */
|
||||
switch (cmd_in) {
|
||||
case MTIOCTOP:
|
||||
return st_ioctl(file, MTIOCTOP, (unsigned long)p);
|
||||
case MTIOCPOS32:
|
||||
return st_ioctl(file, MTIOCPOS, (unsigned long)p);
|
||||
case MTIOCGET32:
|
||||
return st_ioctl(file, MTIOCGET, (unsigned long)p);
|
||||
}
|
||||
|
||||
if (sdev->host->hostt->compat_ioctl) {
|
||||
|
||||
ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
|
||||
ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
|
||||
|
||||
}
|
||||
return ret;
|
||||
|
@ -533,9 +533,7 @@ static long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
||||
static const struct file_operations ion_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = ion_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = ion_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static int debug_shrink_set(void *data, u64 val)
|
||||
|
@ -928,16 +928,6 @@ pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long
|
||||
pi433_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
return pi433_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#else
|
||||
#define pi433_compat_ioctl NULL
|
||||
#endif /* CONFIG_COMPAT */
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int pi433_open(struct inode *inode, struct file *filp)
|
||||
@ -1094,7 +1084,7 @@ static const struct file_operations pi433_fops = {
|
||||
.write = pi433_write,
|
||||
.read = pi433_read,
|
||||
.unlocked_ioctl = pi433_ioctl,
|
||||
.compat_ioctl = pi433_compat_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = pi433_open,
|
||||
.release = pi433_release,
|
||||
.llseek = no_llseek,
|
||||
|
@ -494,7 +494,7 @@ static const struct file_operations vme_user_fops = {
|
||||
.write = vme_user_write,
|
||||
.llseek = vme_user_llseek,
|
||||
.unlocked_ioctl = vme_user_unlocked_ioctl,
|
||||
.compat_ioctl = vme_user_unlocked_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.mmap = vme_user_mmap,
|
||||
};
|
||||
|
||||
|
@ -675,7 +675,7 @@ static const struct file_operations tee_fops = {
|
||||
.open = tee_open,
|
||||
.release = tee_release,
|
||||
.unlocked_ioctl = tee_ioctl,
|
||||
.compat_ioctl = tee_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static void tee_release_device(struct device *dev)
|
||||
|
@ -87,6 +87,7 @@
|
||||
#include <linux/string.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/poll.h>
|
||||
#include <linux/ppp-ioctl.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
@ -2755,6 +2756,7 @@ static long tty_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
int retval = -ENOIOCTLCMD;
|
||||
|
||||
switch (cmd) {
|
||||
case TIOCOUTQ:
|
||||
case TIOCSTI:
|
||||
case TIOCGWINSZ:
|
||||
case TIOCSWINSZ:
|
||||
@ -2810,6 +2812,9 @@ static long tty_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
#endif
|
||||
case TIOCGSOFTCAR:
|
||||
case TIOCSSOFTCAR:
|
||||
|
||||
case PPPIOCGCHAN:
|
||||
case PPPIOCGUNIT:
|
||||
return tty_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
|
||||
case TIOCCONS:
|
||||
case TIOCEXCL:
|
||||
|
@ -734,7 +734,7 @@ static const struct file_operations wdm_fops = {
|
||||
.release = wdm_release,
|
||||
.poll = wdm_poll,
|
||||
.unlocked_ioctl = wdm_ioctl,
|
||||
.compat_ioctl = wdm_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
|
@ -2217,9 +2217,7 @@ static const struct file_operations fops = {
|
||||
.release = usbtmc_release,
|
||||
.flush = usbtmc_flush,
|
||||
.unlocked_ioctl = usbtmc_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = usbtmc_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.fasync = usbtmc_fasync,
|
||||
.poll = usbtmc_poll,
|
||||
.llseek = default_llseek,
|
||||
|
@ -2698,18 +2698,6 @@ static long usbdev_ioctl(struct file *file, unsigned int cmd,
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long usbdev_compat_ioctl(struct file *file, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = usbdev_do_ioctl(file, cmd, compat_ptr(arg));
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* No kernel lock - fine */
|
||||
static __poll_t usbdev_poll(struct file *file,
|
||||
struct poll_table_struct *wait)
|
||||
@ -2733,9 +2721,7 @@ const struct file_operations usbdev_file_operations = {
|
||||
.read = usbdev_read,
|
||||
.poll = usbdev_poll,
|
||||
.unlocked_ioctl = usbdev_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = usbdev_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.mmap = usbdev_mmap,
|
||||
.open = usbdev_open,
|
||||
.release = usbdev_release,
|
||||
|
@ -1352,14 +1352,6 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code,
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long ffs_epfile_compat_ioctl(struct file *file, unsigned code,
|
||||
unsigned long value)
|
||||
{
|
||||
return ffs_epfile_ioctl(file, code, value);
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations ffs_epfile_operations = {
|
||||
.llseek = no_llseek,
|
||||
|
||||
@ -1368,9 +1360,7 @@ static const struct file_operations ffs_epfile_operations = {
|
||||
.read_iter = ffs_epfile_read_iter,
|
||||
.release = ffs_epfile_release,
|
||||
.unlocked_ioctl = ffs_epfile_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = ffs_epfile_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
|
||||
|
@ -1184,15 +1184,6 @@ static long vfio_fops_unl_ioctl(struct file *filep,
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vfio_fops_compat_ioctl(struct file *filep,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
arg = (unsigned long)compat_ptr(arg);
|
||||
return vfio_fops_unl_ioctl(filep, cmd, arg);
|
||||
}
|
||||
#endif /* CONFIG_COMPAT */
|
||||
|
||||
static int vfio_fops_open(struct inode *inode, struct file *filep)
|
||||
{
|
||||
struct vfio_container *container;
|
||||
@ -1275,9 +1266,7 @@ static const struct file_operations vfio_fops = {
|
||||
.read = vfio_fops_read,
|
||||
.write = vfio_fops_write,
|
||||
.unlocked_ioctl = vfio_fops_unl_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vfio_fops_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.mmap = vfio_fops_mmap,
|
||||
};
|
||||
|
||||
@ -1556,15 +1545,6 @@ static long vfio_group_fops_unl_ioctl(struct file *filep,
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vfio_group_fops_compat_ioctl(struct file *filep,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
arg = (unsigned long)compat_ptr(arg);
|
||||
return vfio_group_fops_unl_ioctl(filep, cmd, arg);
|
||||
}
|
||||
#endif /* CONFIG_COMPAT */
|
||||
|
||||
static int vfio_group_fops_open(struct inode *inode, struct file *filep)
|
||||
{
|
||||
struct vfio_group *group;
|
||||
@ -1620,9 +1600,7 @@ static int vfio_group_fops_release(struct inode *inode, struct file *filep)
|
||||
static const struct file_operations vfio_group_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.unlocked_ioctl = vfio_group_fops_unl_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vfio_group_fops_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = vfio_group_fops_open,
|
||||
.release = vfio_group_fops_release,
|
||||
};
|
||||
@ -1687,24 +1665,13 @@ static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)
|
||||
return device->ops->mmap(device->device_data, vma);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vfio_device_fops_compat_ioctl(struct file *filep,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
arg = (unsigned long)compat_ptr(arg);
|
||||
return vfio_device_fops_unl_ioctl(filep, cmd, arg);
|
||||
}
|
||||
#endif /* CONFIG_COMPAT */
|
||||
|
||||
static const struct file_operations vfio_device_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.release = vfio_device_fops_release,
|
||||
.read = vfio_device_fops_read,
|
||||
.write = vfio_device_fops_write,
|
||||
.unlocked_ioctl = vfio_device_fops_unl_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vfio_device_fops_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.mmap = vfio_device_fops_mmap,
|
||||
};
|
||||
|
||||
|
@ -1751,14 +1751,6 @@ static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vhost_net_compat_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
return vhost_net_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static ssize_t vhost_net_chr_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
||||
{
|
||||
struct file *file = iocb->ki_filp;
|
||||
@ -1794,9 +1786,7 @@ static const struct file_operations vhost_net_fops = {
|
||||
.write_iter = vhost_net_chr_write_iter,
|
||||
.poll = vhost_net_chr_poll,
|
||||
.unlocked_ioctl = vhost_net_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vhost_net_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = vhost_net_open,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
@ -1727,21 +1727,11 @@ vhost_scsi_ioctl(struct file *f,
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vhost_scsi_compat_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
return vhost_scsi_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations vhost_scsi_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.release = vhost_scsi_release,
|
||||
.unlocked_ioctl = vhost_scsi_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vhost_scsi_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = vhost_scsi_open,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
@ -304,21 +304,11 @@ static long vhost_test_ioctl(struct file *f, unsigned int ioctl,
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vhost_test_compat_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
return vhost_test_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations vhost_test_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.release = vhost_test_release,
|
||||
.unlocked_ioctl = vhost_test_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vhost_test_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = vhost_test_open,
|
||||
.llseek = noop_llseek,
|
||||
};
|
||||
|
@ -810,23 +810,13 @@ static long vhost_vsock_dev_ioctl(struct file *f, unsigned int ioctl,
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vhost_vsock_dev_compat_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
return vhost_vsock_dev_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct file_operations vhost_vsock_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = vhost_vsock_dev_open,
|
||||
.release = vhost_vsock_dev_release,
|
||||
.llseek = noop_llseek,
|
||||
.unlocked_ioctl = vhost_vsock_dev_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vhost_vsock_dev_compat_ioctl,
|
||||
#endif
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static struct miscdevice vhost_vsock_misc = {
|
||||
|
@ -48,7 +48,7 @@
|
||||
|
||||
******************************************************************************/
|
||||
|
||||
|
||||
#include <linux/compat.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/kernel.h>
|
||||
@ -235,6 +235,13 @@ static int atyfb_pan_display(struct fb_var_screeninfo *var,
|
||||
struct fb_info *info);
|
||||
static int atyfb_blank(int blank, struct fb_info *info);
|
||||
static int atyfb_ioctl(struct fb_info *info, u_int cmd, u_long arg);
|
||||
#ifdef CONFIG_COMPAT
|
||||
static int atyfb_compat_ioctl(struct fb_info *info, u_int cmd, u_long arg)
|
||||
{
|
||||
return atyfb_ioctl(info, cmd, (u_long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __sparc__
|
||||
static int atyfb_mmap(struct fb_info *info, struct vm_area_struct *vma);
|
||||
#endif
|
||||
@ -290,6 +297,9 @@ static struct fb_ops atyfb_ops = {
|
||||
.fb_pan_display = atyfb_pan_display,
|
||||
.fb_blank = atyfb_blank,
|
||||
.fb_ioctl = atyfb_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.fb_compat_ioctl = atyfb_compat_ioctl,
|
||||
#endif
|
||||
.fb_fillrect = atyfb_fillrect,
|
||||
.fb_copyarea = atyfb_copyarea,
|
||||
.fb_imageblit = atyfb_imageblit,
|
||||
|
@ -706,7 +706,7 @@ static const struct file_operations fsl_hv_fops = {
|
||||
.poll = fsl_hv_poll,
|
||||
.read = fsl_hv_read,
|
||||
.unlocked_ioctl = fsl_hv_ioctl,
|
||||
.compat_ioctl = fsl_hv_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static struct miscdevice fsl_hv_misc_dev = {
|
||||
|
@ -221,6 +221,7 @@ static const struct file_operations acq_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = acq_write,
|
||||
.unlocked_ioctl = acq_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = acq_open,
|
||||
.release = acq_close,
|
||||
};
|
||||
|
@ -220,6 +220,7 @@ static const struct file_operations advwdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = advwdt_write,
|
||||
.unlocked_ioctl = advwdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = advwdt_open,
|
||||
.release = advwdt_close,
|
||||
};
|
||||
|
@ -362,6 +362,7 @@ static const struct file_operations ali_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = ali_write,
|
||||
.unlocked_ioctl = ali_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = ali_open,
|
||||
.release = ali_release,
|
||||
};
|
||||
|
@ -294,6 +294,7 @@ static const struct file_operations wdt_fops = {
|
||||
.open = fop_open,
|
||||
.release = fop_close,
|
||||
.unlocked_ioctl = fop_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static struct miscdevice wdt_miscdev = {
|
||||
|
@ -250,6 +250,7 @@ static const struct file_operations ar7_wdt_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.write = ar7_wdt_write,
|
||||
.unlocked_ioctl = ar7_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = ar7_wdt_open,
|
||||
.release = ar7_wdt_release,
|
||||
.llseek = no_llseek,
|
||||
|
@ -213,6 +213,7 @@ static const struct file_operations at91wdt_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = at91_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = at91_wdt_open,
|
||||
.release = at91_wdt_close,
|
||||
.write = at91_wdt_write,
|
||||
|
@ -234,6 +234,7 @@ static const struct file_operations ath79_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = ath79_wdt_write,
|
||||
.unlocked_ioctl = ath79_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = ath79_wdt_open,
|
||||
.release = ath79_wdt_release,
|
||||
};
|
||||
|
@ -221,6 +221,7 @@ static const struct file_operations bcm63xx_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = bcm63xx_wdt_write,
|
||||
.unlocked_ioctl = bcm63xx_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = bcm63xx_wdt_open,
|
||||
.release = bcm63xx_wdt_release,
|
||||
};
|
||||
|
@ -187,6 +187,7 @@ static const struct file_operations cpu5wdt_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = cpu5wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = cpu5wdt_open,
|
||||
.write = cpu5wdt_write,
|
||||
.release = cpu5wdt_release,
|
||||
|
@ -371,6 +371,7 @@ static const struct file_operations eurwdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = eurwdt_write,
|
||||
.unlocked_ioctl = eurwdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = eurwdt_open,
|
||||
.release = eurwdt_release,
|
||||
};
|
||||
|
@ -669,6 +669,7 @@ static const struct file_operations watchdog_fops = {
|
||||
.release = watchdog_release,
|
||||
.write = watchdog_write,
|
||||
.unlocked_ioctl = watchdog_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
};
|
||||
|
||||
static struct miscdevice watchdog_miscdev = {
|
||||
|
@ -248,6 +248,7 @@ static const struct file_operations gef_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = gef_wdt_write,
|
||||
.unlocked_ioctl = gef_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = gef_wdt_open,
|
||||
.release = gef_wdt_release,
|
||||
};
|
||||
|
@ -201,6 +201,7 @@ static const struct file_operations geodewdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = geodewdt_write,
|
||||
.unlocked_ioctl = geodewdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = geodewdt_open,
|
||||
.release = geodewdt_release,
|
||||
};
|
||||
|
@ -259,6 +259,7 @@ static const struct file_operations ibwdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = ibwdt_write,
|
||||
.unlocked_ioctl = ibwdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = ibwdt_open,
|
||||
.release = ibwdt_close,
|
||||
};
|
||||
|
@ -344,6 +344,7 @@ static const struct file_operations asr_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = asr_write,
|
||||
.unlocked_ioctl = asr_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = asr_open,
|
||||
.release = asr_release,
|
||||
};
|
||||
|
@ -152,6 +152,7 @@ static const struct file_operations indydog_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = indydog_write,
|
||||
.unlocked_ioctl = indydog_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = indydog_open,
|
||||
.release = indydog_release,
|
||||
};
|
||||
|
@ -412,6 +412,7 @@ static const struct file_operations intel_scu_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = intel_scu_write,
|
||||
.unlocked_ioctl = intel_scu_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = intel_scu_open,
|
||||
.release = intel_scu_release,
|
||||
};
|
||||
|
@ -202,6 +202,7 @@ static const struct file_operations iop_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = iop_wdt_write,
|
||||
.unlocked_ioctl = iop_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = iop_wdt_open,
|
||||
.release = iop_wdt_release,
|
||||
};
|
||||
|
@ -345,6 +345,7 @@ static const struct file_operations it8712f_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = it8712f_wdt_write,
|
||||
.unlocked_ioctl = it8712f_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = it8712f_wdt_open,
|
||||
.release = it8712f_wdt_release,
|
||||
};
|
||||
|
@ -163,6 +163,7 @@ static const struct file_operations ixp4xx_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = ixp4xx_wdt_write,
|
||||
.unlocked_ioctl = ixp4xx_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = ixp4xx_wdt_open,
|
||||
.release = ixp4xx_wdt_release,
|
||||
};
|
||||
|
@ -183,6 +183,7 @@ static const struct file_operations m54xx_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = m54xx_wdt_write,
|
||||
.unlocked_ioctl = m54xx_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = m54xx_wdt_open,
|
||||
.release = m54xx_wdt_release,
|
||||
};
|
||||
|
@ -361,6 +361,7 @@ static const struct file_operations zf_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = zf_write,
|
||||
.unlocked_ioctl = zf_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = zf_open,
|
||||
.release = zf_close,
|
||||
};
|
||||
|
@ -227,6 +227,7 @@ static const struct file_operations mixcomwd_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = mixcomwd_write,
|
||||
.unlocked_ioctl = mixcomwd_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = mixcomwd_open,
|
||||
.release = mixcomwd_release,
|
||||
};
|
||||
|
@ -181,6 +181,7 @@ static const struct file_operations mtx1_wdt_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.llseek = no_llseek,
|
||||
.unlocked_ioctl = mtx1_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = mtx1_wdt_open,
|
||||
.write = mtx1_wdt_write,
|
||||
.release = mtx1_wdt_release,
|
||||
|
@ -241,6 +241,7 @@ static const struct file_operations mv64x60_wdt_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = mv64x60_wdt_write,
|
||||
.unlocked_ioctl = mv64x60_wdt_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = mv64x60_wdt_open,
|
||||
.release = mv64x60_wdt_release,
|
||||
};
|
||||
|
@ -267,6 +267,7 @@ static const struct file_operations nv_tco_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = nv_tco_write,
|
||||
.unlocked_ioctl = nv_tco_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = nv_tco_open,
|
||||
.release = nv_tco_release,
|
||||
};
|
||||
|
@ -473,6 +473,7 @@ static const struct file_operations pc87413_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = pc87413_write,
|
||||
.unlocked_ioctl = pc87413_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = pc87413_open,
|
||||
.release = pc87413_release,
|
||||
};
|
||||
|
@ -752,6 +752,7 @@ static const struct file_operations pcwd_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = pcwd_write,
|
||||
.unlocked_ioctl = pcwd_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = pcwd_open,
|
||||
.release = pcwd_close,
|
||||
};
|
||||
|
@ -646,6 +646,7 @@ static const struct file_operations pcipcwd_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = pcipcwd_write,
|
||||
.unlocked_ioctl = pcipcwd_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = pcipcwd_open,
|
||||
.release = pcipcwd_release,
|
||||
};
|
||||
|
@ -550,6 +550,7 @@ static const struct file_operations usb_pcwd_fops = {
|
||||
.llseek = no_llseek,
|
||||
.write = usb_pcwd_write,
|
||||
.unlocked_ioctl = usb_pcwd_ioctl,
|
||||
.compat_ioctl = compat_ptr_ioctl,
|
||||
.open = usb_pcwd_open,
|
||||
.release = usb_pcwd_release,
|
||||
};
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user