Skip to content

L
linux
Commit f7719648 authored by Andrew Morton's avatar Andrew Morton Committed by Linus Torvalds
Browse files
Options

[PATCH] compat ioctl consolidation 

From: Arun Sharma <arun.sharma@intel.com>, kevin.tian@intel.com

Move a whole bunch of filesystem ioctl conversion functions out of per-arch
files and into fs/compat_ioctl.c

It moves linux32_dirent to compat.h and renames it as compat_dirent. 
linux32_dirent has been eliminated from ia64.  Other archs should do the
same.

We'll leave old_linux_dirent32 as is, since it seems to be arch specific
(ia64 doesn't use it for example).
parent ca887863
Hide whitespace changes
Inline Side-by-side
Showing with 596 additions and 1379 deletions
arch/ia64/ia32/ia32_ioctl.c
View file @ f7719648
...@@ -26,43 +26,11 @@ ...@@ -26,43 +26,11 @@
_ret; \ _ret; \
}) })
#define P(i) ((void *)(unsigned long)(i))
asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg); asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
#define CODE #define CODE
#include "compat_ioctl.c" #include "compat_ioctl.c"
#define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct linux32_dirent[2])
#define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct linux32_dirent[2])
static long
put_dirent32 (struct dirent *d, struct linux32_dirent *d32)
{
size_t namelen = strlen(d->d_name);
return (put_user(d->d_ino, &d32->d_ino)
|| put_user(d->d_off, &d32->d_off)
|| put_user(d->d_reclen, &d32->d_reclen)
|| copy_to_user(d32->d_name, d->d_name, namelen + 1));
}
static int vfat_ioctl32(unsigned fd, unsigned cmd, void *ptr)
{
int ret;
mm_segment_t oldfs = get_fs();
struct dirent d[2];
set_fs(KERNEL_DS);
ret = sys_ioctl(fd,cmd,(unsigned long)&d);
set_fs(oldfs);
if (!ret) {
ret |= put_dirent32(&d[0], (struct linux32_dirent *)ptr);
ret |= put_dirent32(&d[1], ((struct linux32_dirent *)ptr) + 1);
}
return ret;
}
typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *); typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *);
#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL((cmd),sys_ioctl) #define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL((cmd),sys_ioctl)
...@@ -73,8 +41,6 @@ typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, str ...@@ -73,8 +41,6 @@ typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, str
}; };
IOCTL_TABLE_START IOCTL_TABLE_START
HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32, vfat_ioctl32)
HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32, vfat_ioctl32)
#define DECLARES #define DECLARES
#include "compat_ioctl.c" #include "compat_ioctl.c"
#include <linux/compat_ioctl.h> #include <linux/compat_ioctl.h>
......
arch/ia64/ia32/ia32priv.h
View file @ f7719648
...@@ -249,13 +249,6 @@ typedef struct siginfo32 { ...@@ -249,13 +249,6 @@ typedef struct siginfo32 {
} _sifields; } _sifields;
} siginfo_t32; } siginfo_t32;
struct linux32_dirent {
u32 d_ino;
u32 d_off;
u16 d_reclen;
char d_name[256];
};
struct old_linux32_dirent { struct old_linux32_dirent {
u32 d_ino; u32 d_ino;
u32 d_offset; u32 d_offset;
......
arch/ia64/ia32/sys_ia32.c
View file @ f7719648
...@@ -707,8 +707,8 @@ sys32_settimeofday (struct compat_timeval *tv, struct timezone *tz) ...@@ -707,8 +707,8 @@ sys32_settimeofday (struct compat_timeval *tv, struct timezone *tz)
} }
struct getdents32_callback { struct getdents32_callback {
struct linux32_dirent * current_dir; struct compat_dirent * current_dir;
struct linux32_dirent * previous; struct compat_dirent * previous;
int count; int count;
int error; int error;
}; };
...@@ -722,7 +722,7 @@ static int ...@@ -722,7 +722,7 @@ static int
filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino, filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
unsigned int d_type) unsigned int d_type)
{ {
struct linux32_dirent * dirent; struct compat_dirent * dirent;
struct getdents32_callback * buf = (struct getdents32_callback *) __buf; struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4); int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
...@@ -748,10 +748,10 @@ filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino, ...@@ -748,10 +748,10 @@ filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
} }
asmlinkage long asmlinkage long
sys32_getdents (unsigned int fd, struct linux32_dirent *dirent, unsigned int count) sys32_getdents (unsigned int fd, struct compat_dirent *dirent, unsigned int count)
{ {
struct file * file; struct file * file;
struct linux32_dirent * lastdirent; struct compat_dirent * lastdirent;
struct getdents32_callback buf; struct getdents32_callback buf;
int error; int error;
......
arch/ppc64/kernel/ioctl32.c
View file @ f7719648
...@@ -328,396 +328,6 @@ static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned lon ...@@ -328,396 +328,6 @@ static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned lon
return err; return err;
} }
struct usbdevfs_ctrltransfer32 {
__u8 bRequestType;
__u8 bRequest;
__u16 wValue;
__u16 wIndex;
__u16 wLength;
__u32 timeout; /* in milliseconds */
__u32 data;
};
#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_ctrltransfer kctrl;
struct usbdevfs_ctrltransfer32 *uctrl;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
int err;
uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
if (copy_from_user(&kctrl, uctrl,
(sizeof(struct usbdevfs_ctrltransfer) -
sizeof(void *))))
return -EFAULT;
if (get_user(udata, &uctrl->data))
return -EFAULT;
uptr = (void *) A(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kctrl.wLength > PAGE_SIZE)
return -EINVAL;
kptr = (void *)__get_free_page(GFP_KERNEL);
if ((kctrl.bRequestType & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kctrl.wLength))
goto out;
}
kctrl.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
set_fs(old_fs);
if (err >= 0 &&
((kctrl.bRequestType & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kctrl.wLength))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
struct usbdevfs_bulktransfer32 {
unsigned int ep;
unsigned int len;
unsigned int timeout; /* in milliseconds */
__u32 data;
};
#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_bulktransfer kbulk;
struct usbdevfs_bulktransfer32 *ubulk;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
int err;
ubulk = (struct usbdevfs_bulktransfer32 *) arg;
if (get_user(kbulk.ep, &ubulk->ep) ||
get_user(kbulk.len, &ubulk->len) ||
get_user(kbulk.timeout, &ubulk->timeout) ||
get_user(udata, &ubulk->data))
return -EFAULT;
uptr = (void *) A(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kbulk.len > PAGE_SIZE)
return -EINVAL;
kptr = (void *) __get_free_page(GFP_KERNEL);
if ((kbulk.ep & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kbulk.len))
goto out;
}
kbulk.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
set_fs(old_fs);
if (err >= 0 &&
((kbulk.ep & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kbulk.len))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
/* This needs more work before we can enable it. Unfortunately
* because of the fancy asynchronous way URB status/error is written
* back to userspace, we'll need to fiddle with USB devio internals
* and/or reimplement entirely the frontend of it ourselves. -DaveM
*
* The issue is:
*
* When an URB is submitted via usbdevicefs it is put onto an
* asynchronous queue. When the URB completes, it may be reaped
* via another ioctl. During this reaping the status is written
* back to userspace along with the length of the transfer.
*
* We must translate into 64-bit kernel types so we pass in a kernel
* space copy of the usbdevfs_urb structure. This would mean that we
* must do something to deal with the async entry reaping. First we
* have to deal somehow with this transitory memory we've allocated.
* This is problematic since there are many call sites from which the
* async entries can be destroyed (and thus when we'd need to free up
* this kernel memory). One of which is the close() op of usbdevicefs.
* To handle that we'd need to make our own file_operations struct which
* overrides usbdevicefs's release op with our own which runs usbdevicefs's
* real release op then frees up the kernel memory.
*
* But how to keep track of these kernel buffers? We'd need to either
* keep track of them in some table _or_ know about usbdevicefs internals
* (ie. the exact layout of its file private, which is actually defined
* in linux/usbdevice_fs.h, the layout of the async queues are private to
* devio.c)
*
* There is one possible other solution I considered, also involving knowledge
* of usbdevicefs internals:
*
* After an URB is submitted, we "fix up" the address back to the user
* space one. This would work if the status/length fields written back
* by the async URB completion lines up perfectly in the 32-bit type with
* the 64-bit kernel type. Unfortunately, it does not because the iso
* frame descriptors, at the end of the struct, can be written back.
*
* I think we'll just need to simply duplicate the devio URB engine here.
*/
#if 0
struct usbdevfs_urb32 {
__u8 type;
__u8 endpoint;
__s32 status;
__u32 flags;
__u32 buffer;
__s32 buffer_length;
__s32 actual_length;
__s32 start_frame;
__s32 number_of_packets;
__s32 error_count;
__u32 signr;
__u32 usercontext; /* unused */
struct usbdevfs_iso_packet_desc iso_frame_desc[0];
};
#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
static int get_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (get_user(kurb->type, &uurb->type) ||
__get_user(kurb->endpoint, &uurb->endpoint) ||
__get_user(kurb->status, &uurb->status) ||
__get_user(kurb->flags, &uurb->flags) ||
__get_user(kurb->buffer_length, &uurb->buffer_length) ||
__get_user(kurb->actual_length, &uurb->actual_length) ||
__get_user(kurb->start_frame, &uurb->start_frame) ||
__get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
__get_user(kurb->error_count, &uurb->error_count) ||
__get_user(kurb->signr, &uurb->signr))
return -EFAULT;
kurb->usercontext = 0; /* unused currently */
return 0;
}
/* Just put back the values which usbdevfs actually changes. */
static int put_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (put_user(kurb->status, &uurb->status) ||
__put_user(kurb->actual_length, &uurb->actual_length) ||
__put_user(kurb->error_count, &uurb->error_count))
return -EFAULT;
if (kurb->number_of_packets != 0) {
int i;
for (i = 0; i < kurb->number_of_packets; i++) {
if (__put_user(kurb->iso_frame_desc[i].actual_length,
&uurb->iso_frame_desc[i].actual_length) ||
__put_user(kurb->iso_frame_desc[i].status,
&uurb->iso_frame_desc[i].status))
return -EFAULT;
}
}
return 0;
}
static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
unsigned int totlen;
int i;
if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
kurb->number_of_packets = 0;
return 0;
}
if (kurb->number_of_packets < 1 ||
kurb->number_of_packets > 128)
return -EINVAL;
if (copy_from_user(&kurb->iso_frame_desc[0],
&uurb->iso_frame_desc[0],
sizeof(struct usbdevfs_iso_packet_desc) *
kurb->number_of_packets))
return -EFAULT;
totlen = 0;
for (i = 0; i < kurb->number_of_packets; i++) {
unsigned int this_len;
this_len = kurb->iso_frame_desc[i].length;
if (this_len > 1023)
return -EINVAL;
totlen += this_len;
}
if (totlen > 32768)
return -EINVAL;
kurb->buffer_length = totlen;
return 0;
}
static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_urb *kurb;
struct usbdevfs_urb32 *uurb;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
unsigned int buflen;
int err;
uurb = (struct usbdevfs_urb32 *) arg;
err = -ENOMEM;
kurb = kmalloc(sizeof(struct usbdevfs_urb) +
(sizeof(struct usbdevfs_iso_packet_desc) * 128),
GFP_KERNEL);
if (!kurb)
goto out;
err = -EFAULT;
if (get_urb32(kurb, uurb))
goto out;
err = get_urb32_isoframes(kurb, uurb);
if (err)
goto out;
err = -EFAULT;
if (__get_user(udata, &uurb->buffer))
goto out;
uptr = (void *) A(udata);
err = -ENOMEM;
buflen = kurb->buffer_length;
kptr = kmalloc(buflen, GFP_KERNEL);
if (!kptr)
goto out;
kurb->buffer = kptr;
err = -EFAULT;
if (copy_from_user(kptr, uptr, buflen))
goto out_kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
set_fs(old_fs);
if (err >= 0) {
/* XXX Shit, this doesn't work for async URBs :-( XXX */
if (put_urb32(kurb, uurb)) {
err = -EFAULT;
} else if ((kurb->endpoint & USB_DIR_IN) != 0) {
if (copy_to_user(uptr, kptr, buflen))
err = -EFAULT;
}
}
out_kptr:
kfree(kptr);
out:
kfree(kurb);
return err;
}
#endif
#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
mm_segment_t old_fs;
void *kptr;
int err;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd,
(cmd == USBDEVFS_REAPURB32 ?
USBDEVFS_REAPURB :
USBDEVFS_REAPURBNDELAY),
(unsigned long) &kptr);
set_fs(old_fs);
if (err >= 0 &&
put_user(((u32)(long)kptr), (u32 *) A(arg)))
err = -EFAULT;
return err;
}
struct usbdevfs_disconnectsignal32 {
unsigned int signr;
u32 context;
};
#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_disconnectsignal kdis;
struct usbdevfs_disconnectsignal32 *udis;
mm_segment_t old_fs;
u32 uctx;
int err;
udis = (struct usbdevfs_disconnectsignal32 *) arg;
if (get_user(kdis.signr, &udis->signr) ||
__get_user(uctx, &udis->context))
return -EFAULT;
kdis.context = (void *) (long)uctx;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
set_fs(old_fs);
return err;
}
#define HANDLE_IOCTL(cmd,handler) { cmd, (ioctl_trans_handler_t)handler, 0 }, #define HANDLE_IOCTL(cmd,handler) { cmd, (ioctl_trans_handler_t)handler, 0 },
#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd,sys_ioctl) #define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd,sys_ioctl)
...@@ -734,8 +344,6 @@ IOCTL_TABLE_START ...@@ -734,8 +344,6 @@ IOCTL_TABLE_START
COMPATIBLE_IOCTL(TCSBRKP) COMPATIBLE_IOCTL(TCSBRKP)
COMPATIBLE_IOCTL(TIOCSTART) COMPATIBLE_IOCTL(TIOCSTART)
COMPATIBLE_IOCTL(TIOCSTOP) COMPATIBLE_IOCTL(TIOCSTOP)
COMPATIBLE_IOCTL(TIOCGSERIAL)
COMPATIBLE_IOCTL(TIOCSSERIAL)
COMPATIBLE_IOCTL(TIOCSLTC) COMPATIBLE_IOCTL(TIOCSLTC)
#if 0 #if 0
COMPATIBLE_IOCTL(FBIOBLANK) COMPATIBLE_IOCTL(FBIOBLANK)
...@@ -755,13 +363,6 @@ HANDLE_IOCTL(NCP_IOC_SETOBJECTNAME_32, do_ncp_setobjectname) ...@@ -755,13 +363,6 @@ HANDLE_IOCTL(NCP_IOC_SETOBJECTNAME_32, do_ncp_setobjectname)
HANDLE_IOCTL(NCP_IOC_GETPRIVATEDATA_32, do_ncp_getprivatedata) HANDLE_IOCTL(NCP_IOC_GETPRIVATEDATA_32, do_ncp_getprivatedata)
HANDLE_IOCTL(NCP_IOC_SETPRIVATEDATA_32, do_ncp_setprivatedata) HANDLE_IOCTL(NCP_IOC_SETPRIVATEDATA_32, do_ncp_setprivatedata)
/* USB devfs */
HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
/*HANDLE_IOCTL(USBDEVFS_SUBMITURB32, do_usbdevfs_urb)*/
HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
IOCTL_TABLE_END IOCTL_TABLE_END
int ioctl_table_size = ARRAY_SIZE(ioctl_start); int ioctl_table_size = ARRAY_SIZE(ioctl_start);
arch/sparc64/kernel/ioctl32.c
View file @ f7719648
...@@ -985,402 +985,6 @@ static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg) ...@@ -985,402 +985,6 @@ static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
#endif #endif
/* HERE! */
struct usbdevfs_ctrltransfer32 {
__u8 bRequestType;
__u8 bRequest;
__u16 wValue;
__u16 wIndex;
__u16 wLength;
__u32 timeout; /* in milliseconds */
__u32 data;
};
#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_ctrltransfer kctrl;
struct usbdevfs_ctrltransfer32 *uctrl;
mm_segment_t old_fs;
__u32 udata;
void __user *uptr;
void *kptr;
int err;
uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
if (copy_from_user(&kctrl, uctrl,
(sizeof(struct usbdevfs_ctrltransfer) -
sizeof(void *))))
return -EFAULT;
if (get_user(udata, &uctrl->data))
return -EFAULT;
uptr = A(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kctrl.wLength > PAGE_SIZE)
return -EINVAL;
kptr = (void *)__get_free_page(GFP_KERNEL);
if ((kctrl.bRequestType & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kctrl.wLength))
goto out;
}
kctrl.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
set_fs(old_fs);
if (err >= 0 &&
((kctrl.bRequestType & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kctrl.wLength))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
struct usbdevfs_bulktransfer32 {
unsigned int ep;
unsigned int len;
unsigned int timeout; /* in milliseconds */
__u32 data;
};
#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_bulktransfer kbulk;
struct usbdevfs_bulktransfer32 *ubulk;
mm_segment_t old_fs;
__u32 udata;
void __user *uptr;
void *kptr;
int err;
ubulk = (struct usbdevfs_bulktransfer32 *) arg;
if (get_user(kbulk.ep, &ubulk->ep) ||
get_user(kbulk.len, &ubulk->len) ||
get_user(kbulk.timeout, &ubulk->timeout) ||
get_user(udata, &ubulk->data))
return -EFAULT;
uptr = A(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kbulk.len > PAGE_SIZE)
return -EINVAL;
kptr = (void *) __get_free_page(GFP_KERNEL);
if ((kbulk.ep & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kbulk.len))
goto out;
}
kbulk.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
set_fs(old_fs);
if (err >= 0 &&
((kbulk.ep & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kbulk.len))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
/* This needs more work before we can enable it. Unfortunately
* because of the fancy asynchronous way URB status/error is written
* back to userspace, we'll need to fiddle with USB devio internals
* and/or reimplement entirely the frontend of it ourselves. -DaveM
*
* The issue is:
*
* When an URB is submitted via usbdevicefs it is put onto an
* asynchronous queue. When the URB completes, it may be reaped
* via another ioctl. During this reaping the status is written
* back to userspace along with the length of the transfer.
*
* We must translate into 64-bit kernel types so we pass in a kernel
* space copy of the usbdevfs_urb structure. This would mean that we
* must do something to deal with the async entry reaping. First we
* have to deal somehow with this transitory memory we've allocated.
* This is problematic since there are many call sites from which the
* async entries can be destroyed (and thus when we'd need to free up
* this kernel memory). One of which is the close() op of usbdevicefs.
* To handle that we'd need to make our own file_operations struct which
* overrides usbdevicefs's release op with our own which runs usbdevicefs's
* real release op then frees up the kernel memory.
*
* But how to keep track of these kernel buffers? We'd need to either
* keep track of them in some table _or_ know about usbdevicefs internals
* (ie. the exact layout of its file private, which is actually defined
* in linux/usbdevice_fs.h, the layout of the async queues are private to
* devio.c)
*
* There is one possible other solution I considered, also involving knowledge
* of usbdevicefs internals:
*
* After an URB is submitted, we "fix up" the address back to the user
* space one. This would work if the status/length fields written back
* by the async URB completion lines up perfectly in the 32-bit type with
* the 64-bit kernel type. Unfortunately, it does not because the iso
* frame descriptors, at the end of the struct, can be written back.
*
* I think we'll just need to simply duplicate the devio URB engine here.
*/
#if 0
struct usbdevfs_urb32 {
__u8 type;
__u8 endpoint;
__s32 status;
__u32 flags;
__u32 buffer;
__s32 buffer_length;
__s32 actual_length;
__s32 start_frame;
__s32 number_of_packets;
__s32 error_count;
__u32 signr;
__u32 usercontext; /* unused */
struct usbdevfs_iso_packet_desc iso_frame_desc[0];
};
#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
static int get_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (get_user(kurb->type, &uurb->type) ||
__get_user(kurb->endpoint, &uurb->endpoint) ||
__get_user(kurb->status, &uurb->status) ||
__get_user(kurb->flags, &uurb->flags) ||
__get_user(kurb->buffer_length, &uurb->buffer_length) ||
__get_user(kurb->actual_length, &uurb->actual_length) ||
__get_user(kurb->start_frame, &uurb->start_frame) ||
__get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
__get_user(kurb->error_count, &uurb->error_count) ||
__get_user(kurb->signr, &uurb->signr))
return -EFAULT;
kurb->usercontext = 0; /* unused currently */
return 0;
}
/* Just put back the values which usbdevfs actually changes. */
static int put_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (put_user(kurb->status, &uurb->status) ||
__put_user(kurb->actual_length, &uurb->actual_length) ||
__put_user(kurb->error_count, &uurb->error_count))
return -EFAULT;
if (kurb->number_of_packets != 0) {
int i;
for (i = 0; i < kurb->number_of_packets; i++) {
if (__put_user(kurb->iso_frame_desc[i].actual_length,
&uurb->iso_frame_desc[i].actual_length) ||
__put_user(kurb->iso_frame_desc[i].status,
&uurb->iso_frame_desc[i].status))
return -EFAULT;
}
}
return 0;
}
static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
unsigned int totlen;
int i;
if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
kurb->number_of_packets = 0;
return 0;
}
if (kurb->number_of_packets < 1 ||
kurb->number_of_packets > 128)
return -EINVAL;
if (copy_from_user(&kurb->iso_frame_desc[0],
&uurb->iso_frame_desc[0],
sizeof(struct usbdevfs_iso_packet_desc) *
kurb->number_of_packets))
return -EFAULT;
totlen = 0;
for (i = 0; i < kurb->number_of_packets; i++) {
unsigned int this_len;
this_len = kurb->iso_frame_desc[i].length;
if (this_len > 1023)
return -EINVAL;
totlen += this_len;
}
if (totlen > 32768)
return -EINVAL;
kurb->buffer_length = totlen;
return 0;
}
static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_urb *kurb;
struct usbdevfs_urb32 *uurb;
mm_segment_t old_fs;
__u32 udata;
void __user *uptr;
void *kptr;
unsigned int buflen;
int err;
uurb = (struct usbdevfs_urb32 *) arg;
err = -ENOMEM;
kurb = kmalloc(sizeof(struct usbdevfs_urb) +
(sizeof(struct usbdevfs_iso_packet_desc) * 128),
GFP_KERNEL);
if (!kurb)
goto out;
err = -EFAULT;
if (get_urb32(kurb, uurb))
goto out;
err = get_urb32_isoframes(kurb, uurb);
if (err)
goto out;
err = -EFAULT;
if (__get_user(udata, &uurb->buffer))
goto out;
uptr = A(udata);
err = -ENOMEM;
buflen = kurb->buffer_length;
kptr = kmalloc(buflen, GFP_KERNEL);
if (!kptr)
goto out;
kurb->buffer = kptr;
err = -EFAULT;
if (copy_from_user(kptr, uptr, buflen))
goto out_kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
set_fs(old_fs);
if (err >= 0) {
/* XXX Shit, this doesn't work for async URBs :-( XXX */
if (put_urb32(kurb, uurb)) {
err = -EFAULT;
} else if ((kurb->endpoint & USB_DIR_IN) != 0) {
if (copy_to_user(uptr, kptr, buflen))
err = -EFAULT;
}
}
out_kptr:
kfree(kptr);
out:
kfree(kurb);
return err;
}
#endif
#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
mm_segment_t old_fs;
void *kptr;
int err;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd,
(cmd == USBDEVFS_REAPURB32 ?
USBDEVFS_REAPURB :
USBDEVFS_REAPURBNDELAY),
(unsigned long) &kptr);
set_fs(old_fs);
if (err >= 0 &&
put_user(((u32)(long)kptr), (u32 __user *) A(arg)))
err = -EFAULT;
return err;
}
struct usbdevfs_disconnectsignal32 {
unsigned int signr;
u32 context;
};
#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_disconnectsignal kdis;
struct usbdevfs_disconnectsignal32 *udis;
mm_segment_t old_fs;
u32 uctx;
int err;
udis = (struct usbdevfs_disconnectsignal32 *) arg;
if (get_user(kdis.signr, &udis->signr) ||
__get_user(uctx, &udis->context))
return -EFAULT;
kdis.context = (void *) (long)uctx;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
set_fs(old_fs);
return err;
}
typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *); typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *);
#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL((cmd),sys_ioctl) #define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL((cmd),sys_ioctl)
...@@ -1397,8 +1001,6 @@ IOCTL_TABLE_START ...@@ -1397,8 +1001,6 @@ IOCTL_TABLE_START
COMPATIBLE_IOCTL(TCSBRKP) COMPATIBLE_IOCTL(TCSBRKP)
COMPATIBLE_IOCTL(TIOCSTART) COMPATIBLE_IOCTL(TIOCSTART)
COMPATIBLE_IOCTL(TIOCSTOP) COMPATIBLE_IOCTL(TIOCSTOP)
COMPATIBLE_IOCTL(TIOCGSERIAL)
COMPATIBLE_IOCTL(TIOCSSERIAL)
COMPATIBLE_IOCTL(TIOCSLTC) COMPATIBLE_IOCTL(TIOCSLTC)
COMPATIBLE_IOCTL(FBIOGTYPE) COMPATIBLE_IOCTL(FBIOGTYPE)
COMPATIBLE_IOCTL(FBIOSATTR) COMPATIBLE_IOCTL(FBIOSATTR)
...@@ -1467,9 +1069,6 @@ COMPATIBLE_IOCTL(AUDIO_GETDEV) ...@@ -1467,9 +1069,6 @@ COMPATIBLE_IOCTL(AUDIO_GETDEV)
COMPATIBLE_IOCTL(AUDIO_GETDEV_SUNOS) COMPATIBLE_IOCTL(AUDIO_GETDEV_SUNOS)
COMPATIBLE_IOCTL(AUDIO_FLUSH) COMPATIBLE_IOCTL(AUDIO_FLUSH)
COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI) COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
/* Raw devices */
COMPATIBLE_IOCTL(RAW_SETBIND)
COMPATIBLE_IOCTL(RAW_GETBIND)
/* NCP ioctls which do not need any translations */ /* NCP ioctls which do not need any translations */
COMPATIBLE_IOCTL(NCP_IOC_CONN_LOGGED_IN) COMPATIBLE_IOCTL(NCP_IOC_CONN_LOGGED_IN)
COMPATIBLE_IOCTL(NCP_IOC_SIGN_INIT) COMPATIBLE_IOCTL(NCP_IOC_SIGN_INIT)
...@@ -1575,12 +1174,6 @@ HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl) ...@@ -1575,12 +1174,6 @@ HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl)
HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl) HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl)
HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl) HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl)
#endif #endif
HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
/*HANDLE_IOCTL(USBDEVFS_SUBMITURB32, do_usbdevfs_urb)*/
HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
/* take care of sizeof(sizeof()) breakage */ /* take care of sizeof(sizeof()) breakage */
IOCTL_TABLE_END IOCTL_TABLE_END
......
arch/x86_64/ia32/ia32_ioctl.c
View file @ f7719648
...@@ -38,87 +38,6 @@ static int tiocgdev(unsigned fd, unsigned cmd, unsigned int *ptr) ...@@ -38,87 +38,6 @@ static int tiocgdev(unsigned fd, unsigned cmd, unsigned int *ptr)
return put_user(new_encode_dev(tty_devnum(real_tty)), ptr); return put_user(new_encode_dev(tty_devnum(real_tty)), ptr);
} }
struct raw32_config_request
{
compat_int_t raw_minor;
__u64 block_major;
__u64 block_minor;
} __attribute__((packed));
static int raw_ioctl(unsigned fd, unsigned cmd, void *ptr)
{
int ret;
switch (cmd) {
case RAW_SETBIND:
case RAW_GETBIND: {
struct raw_config_request req;
struct raw32_config_request *user_req = ptr;
mm_segment_t oldfs = get_fs();
if (get_user(req.raw_minor, &user_req->raw_minor) ||
get_user(req.block_major, &user_req->block_major) ||
get_user(req.block_minor, &user_req->block_minor))
return -EFAULT;
set_fs(KERNEL_DS);
ret = sys_ioctl(fd,cmd,(unsigned long)&req);
set_fs(oldfs);
break;
}
default:
ret = sys_ioctl(fd,cmd,(unsigned long)ptr);
break;
}
return ret;
}
#define REISERFS_IOC_UNPACK32 _IOW(0xCD,1,int)
static int reiserfs_ioctl32(unsigned fd, unsigned cmd, unsigned long ptr)
{
if (cmd == REISERFS_IOC_UNPACK32)
cmd = REISERFS_IOC_UNPACK;
return sys_ioctl(fd,cmd,ptr);
}
struct dirent32 {
compat_int_t d_ino;
compat_off_t d_off;
unsigned short d_reclen;
char d_name[256]; /* We must not include limits.h! */
};
#define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct dirent32 [2])
#define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct dirent32 [2])
static int put_dirent32(struct dirent *src, struct dirent32 *dst)
{
int ret;
ret = put_user(src->d_ino, &dst->d_ino);
ret |= __put_user(src->d_off, &dst->d_off);
ret |= __put_user(src->d_reclen, &dst->d_reclen);
if (__copy_to_user(&dst->d_name, src->d_name, src->d_reclen))
ret |= -EFAULT;
return ret;
}
static int vfat_ioctl32(unsigned fd, unsigned cmd, void *ptr)
{
int ret;
mm_segment_t oldfs = get_fs();
struct dirent d[2];
set_fs(KERNEL_DS);
ret = sys_ioctl(fd,cmd,(unsigned long)&d);
set_fs(oldfs);
if (!ret) {
ret |= put_dirent32(&d[0], (struct dirent32 *)ptr);
ret |= put_dirent32(&d[1], ((struct dirent32 *)ptr) + 1);
}
return ret;
}
#define RTC_IRQP_READ32 _IOR('p', 0x0b, unsigned int) /* Read IRQ rate */ #define RTC_IRQP_READ32 _IOR('p', 0x0b, unsigned int) /* Read IRQ rate */
#define RTC_IRQP_SET32 _IOW('p', 0x0c, unsigned int) /* Set IRQ rate */ #define RTC_IRQP_SET32 _IOW('p', 0x0c, unsigned int) /* Set IRQ rate */
#define RTC_EPOCH_READ32 _IOR('p', 0x0d, unsigned) /* Read epoch */ #define RTC_EPOCH_READ32 _IOR('p', 0x0d, unsigned) /* Read epoch */
...@@ -158,436 +77,6 @@ static int rtc32_ioctl(unsigned fd, unsigned cmd, unsigned long arg) ...@@ -158,436 +77,6 @@ static int rtc32_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
return sys_ioctl(fd,cmd,arg); return sys_ioctl(fd,cmd,arg);
} }
struct serial_struct32 {
compat_int_t type;
compat_int_t line;
compat_uint_t port;
compat_int_t irq;
compat_int_t flags;
compat_int_t xmit_fifo_size;
compat_int_t custom_divisor;
compat_int_t baud_base;
unsigned short close_delay;
char io_type;
char reserved_char[1];
compat_int_t hub6;
unsigned short closing_wait; /* time to wait before closing */
unsigned short closing_wait2; /* no longer used... */
compat_uint_t iomem_base;
unsigned short iomem_reg_shift;
unsigned int port_high;
compat_int_t reserved[1];
};
static int serial_struct_ioctl(unsigned fd, unsigned cmd, void *ptr)
{
typedef struct serial_struct SS;
struct serial_struct32 *ss32 = ptr;
int err;
struct serial_struct ss;
mm_segment_t oldseg = get_fs();
if (cmd == TIOCSSERIAL) {
if (copy_from_user(&ss, ss32, sizeof(struct serial_struct32)))
return -EFAULT;
memmove(&ss.iomem_reg_shift, ((char*)&ss.iomem_base)+4,
sizeof(SS)-offsetof(SS,iomem_reg_shift));
ss.iomem_base = (void *)((unsigned long)ss.iomem_base & 0xffffffff);
}
set_fs(KERNEL_DS);
err = sys_ioctl(fd,cmd,(unsigned long)(&ss));
set_fs(oldseg);
if (cmd == TIOCGSERIAL && err >= 0) {
if (__copy_to_user(ss32,&ss,offsetof(SS,iomem_base)) ||
__put_user((unsigned long)ss.iomem_base >> 32 ?
0xffffffff : (unsigned)(unsigned long)ss.iomem_base,
&ss32->iomem_base) ||
__put_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift) ||
__put_user(ss.port_high, &ss32->port_high))
return -EFAULT;
}
return err;
}
struct usbdevfs_ctrltransfer32 {
u8 bRequestType;
u8 bRequest;
u16 wValue;
u16 wIndex;
u16 wLength;
u32 timeout; /* in milliseconds */
compat_caddr_t data;
};
#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_ctrltransfer kctrl;
struct usbdevfs_ctrltransfer32 *uctrl;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
int err;
uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
if (copy_from_user(&kctrl, uctrl,
(sizeof(struct usbdevfs_ctrltransfer) -
sizeof(void *))))
return -EFAULT;
if (get_user(udata, &uctrl->data))
return -EFAULT;
uptr = compat_ptr(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kctrl.wLength > PAGE_SIZE)
return -EINVAL;
kptr = (void *)__get_free_page(GFP_KERNEL);
if ((kctrl.bRequestType & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kctrl.wLength))
goto out;
}
kctrl.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
set_fs(old_fs);
if (err >= 0 &&
((kctrl.bRequestType & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kctrl.wLength))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
struct usbdevfs_bulktransfer32 {
compat_uint_t ep;
compat_uint_t len;
compat_uint_t timeout; /* in milliseconds */
compat_caddr_t data;
};
#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_bulktransfer kbulk;
struct usbdevfs_bulktransfer32 *ubulk;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
int err;
ubulk = (struct usbdevfs_bulktransfer32 *) arg;
if (get_user(kbulk.ep, &ubulk->ep) ||
get_user(kbulk.len, &ubulk->len) ||
get_user(kbulk.timeout, &ubulk->timeout) ||
get_user(udata, &ubulk->data))
return -EFAULT;
uptr = compat_ptr(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kbulk.len > PAGE_SIZE)
return -EINVAL;
kptr = (void *) __get_free_page(GFP_KERNEL);
if ((kbulk.ep & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kbulk.len))
goto out;
}
kbulk.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
set_fs(old_fs);
if (err >= 0 &&
((kbulk.ep & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kbulk.len))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
/* This needs more work before we can enable it. Unfortunately
* because of the fancy asynchronous way URB status/error is written
* back to userspace, we'll need to fiddle with USB devio internals
* and/or reimplement entirely the frontend of it ourselves. -DaveM
*
* The issue is:
*
* When an URB is submitted via usbdevicefs it is put onto an
* asynchronous queue. When the URB completes, it may be reaped
* via another ioctl. During this reaping the status is written
* back to userspace along with the length of the transfer.
*
* We must translate into 64-bit kernel types so we pass in a kernel
* space copy of the usbdevfs_urb structure. This would mean that we
* must do something to deal with the async entry reaping. First we
* have to deal somehow with this transitory memory we've allocated.
* This is problematic since there are many call sites from which the
* async entries can be destroyed (and thus when we'd need to free up
* this kernel memory). One of which is the close() op of usbdevicefs.
* To handle that we'd need to make our own file_operations struct which
* overrides usbdevicefs's release op with our own which runs usbdevicefs's
* real release op then frees up the kernel memory.
*
* But how to keep track of these kernel buffers? We'd need to either
* keep track of them in some table _or_ know about usbdevicefs internals
* (ie. the exact layout of its file private, which is actually defined
* in linux/usbdevice_fs.h, the layout of the async queues are private to
* devio.c)
*
* There is one possible other solution I considered, also involving knowledge
* of usbdevicefs internals:
*
* After an URB is submitted, we "fix up" the address back to the user
* space one. This would work if the status/length fields written back
* by the async URB completion lines up perfectly in the 32-bit type with
* the 64-bit kernel type. Unfortunately, it does not because the iso
* frame descriptors, at the end of the struct, can be written back.
*
* I think we'll just need to simply duplicate the devio URB engine here.
*/
#if 0
struct usbdevfs_urb32 {
unsigned char type;
unsigned char endpoint;
compat_int_t status;
compat_uint_t flags;
compat_caddr_t buffer;
compat_int_t buffer_length;
compat_int_t actual_length;
compat_int_t start_frame;
compat_int_t number_of_packets;
compat_int_t error_count;
compat_uint_t signr;
compat_caddr_t usercontext; /* unused */
struct usbdevfs_iso_packet_desc iso_frame_desc[0];
};
#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
static int get_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (get_user(kurb->type, &uurb->type) ||
__get_user(kurb->endpoint, &uurb->endpoint) ||
__get_user(kurb->status, &uurb->status) ||
__get_user(kurb->flags, &uurb->flags) ||
__get_user(kurb->buffer_length, &uurb->buffer_length) ||
__get_user(kurb->actual_length, &uurb->actual_length) ||
__get_user(kurb->start_frame, &uurb->start_frame) ||
__get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
__get_user(kurb->error_count, &uurb->error_count) ||
__get_user(kurb->signr, &uurb->signr))
return -EFAULT;
kurb->usercontext = 0; /* unused currently */
return 0;
}
/* Just put back the values which usbdevfs actually changes. */
static int put_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (put_user(kurb->status, &uurb->status) ||
__put_user(kurb->actual_length, &uurb->actual_length) ||
__put_user(kurb->error_count, &uurb->error_count))
return -EFAULT;
if (kurb->number_of_packets != 0) {
int i;
for (i = 0; i < kurb->number_of_packets; i++) {
if (__put_user(kurb->iso_frame_desc[i].actual_length,
&uurb->iso_frame_desc[i].actual_length) ||
__put_user(kurb->iso_frame_desc[i].status,
&uurb->iso_frame_desc[i].status))
return -EFAULT;
}
}
return 0;
}
static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
unsigned int totlen;
int i;
if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
kurb->number_of_packets = 0;
return 0;
}
if (kurb->number_of_packets < 1 ||
kurb->number_of_packets > 128)
return -EINVAL;
if (copy_from_user(&kurb->iso_frame_desc[0],
&uurb->iso_frame_desc[0],
sizeof(struct usbdevfs_iso_packet_desc) *
kurb->number_of_packets))
return -EFAULT;
totlen = 0;
for (i = 0; i < kurb->number_of_packets; i++) {
unsigned int this_len;
this_len = kurb->iso_frame_desc[i].length;
if (this_len > 1023)
return -EINVAL;
totlen += this_len;
}
if (totlen > 32768)
return -EINVAL;
kurb->buffer_length = totlen;
return 0;
}
static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_urb *kurb;
struct usbdevfs_urb32 *uurb;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
unsigned int buflen;
int err;
uurb = (struct usbdevfs_urb32 *) arg;
err = -ENOMEM;
kurb = kmalloc(sizeof(struct usbdevfs_urb) +
(sizeof(struct usbdevfs_iso_packet_desc) * 128),
GFP_KERNEL);
if (!kurb)
goto out;
err = -EFAULT;
if (get_urb32(kurb, uurb))
goto out;
err = get_urb32_isoframes(kurb, uurb);
if (err)
goto out;
err = -EFAULT;
if (__get_user(udata, &uurb->buffer))
goto out;
uptr = compat_ptr(udata);
buflen = kurb->buffer_length;
err = verify_area(VERIFY_WRITE, uptr, buflen);
if (err)
goto out;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
set_fs(old_fs);
if (err >= 0) {
/* RED-PEN Shit, this doesn't work for async URBs :-( XXX */
if (put_urb32(kurb, uurb)) {
err = -EFAULT;
}
}
out:
kfree(kurb);
return err;
}
#endif
#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
mm_segment_t old_fs;
void *kptr;
int err;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd,
(cmd == USBDEVFS_REAPURB32 ?
USBDEVFS_REAPURB :
USBDEVFS_REAPURBNDELAY),
(unsigned long) &kptr);
set_fs(old_fs);
if (err >= 0 &&
put_user((u32)(u64)kptr, (u32 *)arg))
err = -EFAULT;
return err;
}
struct usbdevfs_disconnectsignal32 {
compat_int_t signr;
compat_caddr_t context;
};
#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_disconnectsignal kdis;
struct usbdevfs_disconnectsignal32 *udis;
mm_segment_t old_fs;
u32 uctx;
int err;
udis = (struct usbdevfs_disconnectsignal32 *) arg;
if (get_user(kdis.signr, &udis->signr) ||
__get_user(uctx, &udis->context))
return -EFAULT;
kdis.context = (void *) (long)uctx;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
set_fs(old_fs);
return err;
}
/* /proc/mtrr ioctls */ /* /proc/mtrr ioctls */
...@@ -726,27 +215,12 @@ COMPATIBLE_IOCTL(FIOQSIZE) ...@@ -726,27 +215,12 @@ COMPATIBLE_IOCTL(FIOQSIZE)
/* And these ioctls need translation */ /* And these ioctls need translation */
HANDLE_IOCTL(TIOCGDEV, tiocgdev) HANDLE_IOCTL(TIOCGDEV, tiocgdev)
HANDLE_IOCTL(TIOCGSERIAL, serial_struct_ioctl)
HANDLE_IOCTL(TIOCSSERIAL, serial_struct_ioctl)
/* Raw devices */
HANDLE_IOCTL(RAW_SETBIND, raw_ioctl)
/* realtime device */ /* realtime device */
HANDLE_IOCTL(RTC_IRQP_READ, rtc32_ioctl) HANDLE_IOCTL(RTC_IRQP_READ, rtc32_ioctl)
HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl) HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl)
HANDLE_IOCTL(RTC_IRQP_SET32, rtc32_ioctl) HANDLE_IOCTL(RTC_IRQP_SET32, rtc32_ioctl)
HANDLE_IOCTL(RTC_EPOCH_READ32, rtc32_ioctl) HANDLE_IOCTL(RTC_EPOCH_READ32, rtc32_ioctl)
HANDLE_IOCTL(RTC_EPOCH_SET32, rtc32_ioctl) HANDLE_IOCTL(RTC_EPOCH_SET32, rtc32_ioctl)
HANDLE_IOCTL(REISERFS_IOC_UNPACK32, reiserfs_ioctl32)
/* VFAT */
HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32, vfat_ioctl32)
HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32, vfat_ioctl32)
HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
/*HANDLE_IOCTL(USBDEVFS_SUBMITURB32, do_usbdevfs_urb)*/
HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
/* take care of sizeof(sizeof()) breakage */ /* take care of sizeof(sizeof()) breakage */
/* mtrr */ /* mtrr */
HANDLE_IOCTL(MTRRIOC32_ADD_ENTRY, mtrr_ioctl32) HANDLE_IOCTL(MTRRIOC32_ADD_ENTRY, mtrr_ioctl32)
......
fs/compat_ioctl.c
View file @ f7719648
...@@ -106,6 +106,7 @@ ...@@ -106,6 +106,7 @@
#include <linux/nbd.h> #include <linux/nbd.h>
#include <linux/random.h> #include <linux/random.h>
#include <linux/filter.h> #include <linux/filter.h>
#include <linux/msdos_fs.h>
#undef INCLUDES #undef INCLUDES
#endif #endif
...@@ -2302,6 +2303,572 @@ static int mtd_rw_oob(unsigned int fd, unsigned int cmd, unsigned long arg) ...@@ -2302,6 +2303,572 @@ static int mtd_rw_oob(unsigned int fd, unsigned int cmd, unsigned long arg)
return err; return err;
} }
#define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
#define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
static long
put_dirent32 (struct dirent *d, struct compat_dirent *d32)
{
int ret;
if ((ret = verify_area(VERIFY_WRITE, d32,
sizeof(struct compat_dirent))))
return ret;
__put_user(d->d_ino, &d32->d_ino);
__put_user(d->d_off, &d32->d_off);
__put_user(d->d_reclen, &d32->d_reclen);
__copy_to_user(d32->d_name, d->d_name, d->d_reclen);
return ret;
}
static int vfat_ioctl32(unsigned fd, unsigned cmd, void *ptr)
{
int ret;
mm_segment_t oldfs = get_fs();
struct dirent d[2];
switch(cmd)
{
case VFAT_IOCTL_READDIR_BOTH32:
cmd = VFAT_IOCTL_READDIR_BOTH;
break;
case VFAT_IOCTL_READDIR_SHORT32:
cmd = VFAT_IOCTL_READDIR_SHORT;
break;
}
set_fs(KERNEL_DS);
ret = sys_ioctl(fd,cmd,(unsigned long)&d);
set_fs(oldfs);
if (ret >= 0) {
ret |= put_dirent32(&d[0], (struct compat_dirent *)ptr);
ret |= put_dirent32(&d[1], ((struct compat_dirent *)ptr) + 1);
}
return ret;
}
#define REISERFS_IOC_UNPACK32 _IOW(0xCD,1,int)
static int reiserfs_ioctl32(unsigned fd, unsigned cmd, unsigned long ptr)
{
if (cmd == REISERFS_IOC_UNPACK32)
cmd = REISERFS_IOC_UNPACK;
return sys_ioctl(fd,cmd,ptr);
}
struct raw32_config_request
{
compat_int_t raw_minor;
__u64 block_major;
__u64 block_minor;
} __attribute__((packed));
static int get_raw32_request(struct raw_config_request *req, struct raw32_config_request *user_req)
{
__u32 lo_maj, hi_maj, lo_min, hi_min;
int ret;
if ((ret = verify_area(VERIFY_READ, user_req,
sizeof(struct raw32_config_request))))
return ret;
__get_user(req->raw_minor, &user_req->raw_minor);
__get_user(lo_maj, (__u32*)&user_req->block_major);
__get_user(hi_maj, ((__u32*)(&user_req->block_major) + 1));
__get_user(lo_min, (__u32*)&user_req->block_minor);
__get_user(hi_min, ((__u32*)(&user_req->block_minor) + 1));
req->block_major = lo_maj | (((__u64)hi_maj) << 32);
req->block_minor = lo_min | (((__u64)lo_min) << 32);
return ret;
}
static int set_raw32_request(struct raw_config_request *req, struct raw32_config_request *user_req)
{
int ret;
if ((ret = verify_area(VERIFY_WRITE, user_req,
sizeof(struct raw32_config_request))))
return ret;
__put_user(req->raw_minor, &user_req->raw_minor);
__put_user((__u32)(req->block_major), (__u32*)&user_req->block_major);
__put_user((__u32)(req->block_major >> 32), ((__u32*)(&user_req->block_major) + 1));
__put_user((__u32)(req->block_minor), (__u32*)&user_req->block_minor);
__put_user((__u32)(req->block_minor >> 32), ((__u32*)(&user_req->block_minor) + 1));
return ret;
}
static int raw_ioctl(unsigned fd, unsigned cmd, void *ptr)
{
int ret;
switch (cmd) {
case RAW_SETBIND:
case RAW_GETBIND: {
struct raw_config_request req;
struct raw32_config_request *user_req = ptr;
mm_segment_t oldfs = get_fs();
if ((ret = get_raw32_request(&req, user_req)))
return ret;
set_fs(KERNEL_DS);
ret = sys_ioctl(fd,cmd,(unsigned long)&req);
set_fs(oldfs);
if ((!ret) && (cmd == RAW_GETBIND)) {
ret = set_raw32_request(&req, user_req);
}
break;
}
default:
ret = sys_ioctl(fd,cmd,(unsigned long)ptr);
break;
}
return ret;
}
struct serial_struct32 {
compat_int_t type;
compat_int_t line;
compat_uint_t port;
compat_int_t irq;
compat_int_t flags;
compat_int_t xmit_fifo_size;
compat_int_t custom_divisor;
compat_int_t baud_base;
unsigned short close_delay;
char io_type;
char reserved_char[1];
compat_int_t hub6;
unsigned short closing_wait; /* time to wait before closing */
unsigned short closing_wait2; /* no longer used... */
compat_uint_t iomem_base;
unsigned short iomem_reg_shift;
unsigned int port_high;
compat_int_t reserved[1];
};
static int serial_struct_ioctl(unsigned fd, unsigned cmd, void *ptr)
{
typedef struct serial_struct SS;
typedef struct serial_struct32 SS32;
struct serial_struct32 *ss32 = ptr;
int err;
struct serial_struct ss;
mm_segment_t oldseg = get_fs();
__u32 udata;
if (cmd == TIOCSSERIAL) {
if (verify_area(VERIFY_READ, ss32, sizeof(SS32)))
return -EFAULT;
__copy_from_user(&ss, ss32, offsetof(SS32, iomem_base));
__get_user(udata, &ss32->iomem_base);
ss.iomem_base = compat_ptr(udata);
__get_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift);
__get_user(ss.port_high, &ss32->port_high);
ss.iomap_base = 0UL;
}
set_fs(KERNEL_DS);
err = sys_ioctl(fd,cmd,(unsigned long)(&ss));
set_fs(oldseg);
if (cmd == TIOCGSERIAL && err >= 0) {
if (verify_area(VERIFY_WRITE, ss32, sizeof(SS32)))
return -EFAULT;
__copy_to_user(ss32,&ss,offsetof(SS32,iomem_base));
__put_user((unsigned long)ss.iomem_base >> 32 ?
0xffffffff : (unsigned)(unsigned long)ss.iomem_base,
&ss32->iomem_base);
__put_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift);
__put_user(ss.port_high, &ss32->port_high);
}
return err;
}
struct usbdevfs_ctrltransfer32 {
u8 bRequestType;
u8 bRequest;
u16 wValue;
u16 wIndex;
u16 wLength;
u32 timeout; /* in milliseconds */
compat_caddr_t data;
};
#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_ctrltransfer kctrl;
struct usbdevfs_ctrltransfer32 *uctrl;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
int err;
uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
if (copy_from_user(&kctrl, uctrl,
(sizeof(struct usbdevfs_ctrltransfer32) -
sizeof(compat_caddr_t))))
return -EFAULT;
if (get_user(udata, &uctrl->data))
return -EFAULT;
uptr = compat_ptr(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kctrl.wLength > PAGE_SIZE)
return -EINVAL;
kptr = (void *)__get_free_page(GFP_KERNEL);
if ((kctrl.bRequestType & USB_DIR_IN) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kctrl.wLength))
goto out;
}
kctrl.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
set_fs(old_fs);
if (err >= 0 &&
((kctrl.bRequestType & USB_DIR_IN) != 0)) {
if (copy_to_user(uptr, kptr, kctrl.wLength))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
struct usbdevfs_bulktransfer32 {
compat_uint_t ep;
compat_uint_t len;
compat_uint_t timeout; /* in milliseconds */
compat_caddr_t data;
};
#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_bulktransfer kbulk;
struct usbdevfs_bulktransfer32 *ubulk;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
int err;
ubulk = (struct usbdevfs_bulktransfer32 *) arg;
if (get_user(kbulk.ep, &ubulk->ep) ||
get_user(kbulk.len, &ubulk->len) ||
get_user(kbulk.timeout, &ubulk->timeout) ||
get_user(udata, &ubulk->data))
return -EFAULT;
uptr = compat_ptr(udata);
/* In usbdevice_fs, it limits the control buffer to a page,
* for simplicity so do we.
*/
if (!uptr || kbulk.len > PAGE_SIZE)
return -EINVAL;
kptr = (void *) __get_free_page(GFP_KERNEL);
if ((kbulk.ep & 0x80) == 0) {
err = -EFAULT;
if (copy_from_user(kptr, uptr, kbulk.len))
goto out;
}
kbulk.data = kptr;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
set_fs(old_fs);
if (err >= 0 &&
((kbulk.ep & 0x80) != 0)) {
if (copy_to_user(uptr, kptr, kbulk.len))
err = -EFAULT;
}
out:
free_page((unsigned long) kptr);
return err;
}
/* This needs more work before we can enable it. Unfortunately
* because of the fancy asynchronous way URB status/error is written
* back to userspace, we'll need to fiddle with USB devio internals
* and/or reimplement entirely the frontend of it ourselves. -DaveM
*
* The issue is:
*
* When an URB is submitted via usbdevicefs it is put onto an
* asynchronous queue. When the URB completes, it may be reaped
* via another ioctl. During this reaping the status is written
* back to userspace along with the length of the transfer.
*
* We must translate into 64-bit kernel types so we pass in a kernel
* space copy of the usbdevfs_urb structure. This would mean that we
* must do something to deal with the async entry reaping. First we
* have to deal somehow with this transitory memory we've allocated.
* This is problematic since there are many call sites from which the
* async entries can be destroyed (and thus when we'd need to free up
* this kernel memory). One of which is the close() op of usbdevicefs.
* To handle that we'd need to make our own file_operations struct which
* overrides usbdevicefs's release op with our own which runs usbdevicefs's
* real release op then frees up the kernel memory.
*
* But how to keep track of these kernel buffers? We'd need to either
* keep track of them in some table _or_ know about usbdevicefs internals
* (ie. the exact layout of its file private, which is actually defined
* in linux/usbdevice_fs.h, the layout of the async queues are private to
* devio.c)
*
* There is one possible other solution I considered, also involving knowledge
* of usbdevicefs internals:
*
* After an URB is submitted, we "fix up" the address back to the user
* space one. This would work if the status/length fields written back
* by the async URB completion lines up perfectly in the 32-bit type with
* the 64-bit kernel type. Unfortunately, it does not because the iso
* frame descriptors, at the end of the struct, can be written back.
*
* I think we'll just need to simply duplicate the devio URB engine here.
*/
#if 0
struct usbdevfs_urb32 {
unsigned char type;
unsigned char endpoint;
compat_int_t status;
compat_uint_t flags;
compat_caddr_t buffer;
compat_int_t buffer_length;
compat_int_t actual_length;
compat_int_t start_frame;
compat_int_t number_of_packets;
compat_int_t error_count;
compat_uint_t signr;
compat_caddr_t usercontext; /* unused */
struct usbdevfs_iso_packet_desc iso_frame_desc[0];
};
#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
static int get_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (get_user(kurb->type, &uurb->type) ||
__get_user(kurb->endpoint, &uurb->endpoint) ||
__get_user(kurb->status, &uurb->status) ||
__get_user(kurb->flags, &uurb->flags) ||
__get_user(kurb->buffer_length, &uurb->buffer_length) ||
__get_user(kurb->actual_length, &uurb->actual_length) ||
__get_user(kurb->start_frame, &uurb->start_frame) ||
__get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
__get_user(kurb->error_count, &uurb->error_count) ||
__get_user(kurb->signr, &uurb->signr))
return -EFAULT;
kurb->usercontext = 0; /* unused currently */
return 0;
}
/* Just put back the values which usbdevfs actually changes. */
static int put_urb32(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
if (put_user(kurb->status, &uurb->status) ||
__put_user(kurb->actual_length, &uurb->actual_length) ||
__put_user(kurb->error_count, &uurb->error_count))
return -EFAULT;
if (kurb->number_of_packets != 0) {
int i;
for (i = 0; i < kurb->number_of_packets; i++) {
if (__put_user(kurb->iso_frame_desc[i].actual_length,
&uurb->iso_frame_desc[i].actual_length) ||
__put_user(kurb->iso_frame_desc[i].status,
&uurb->iso_frame_desc[i].status))
return -EFAULT;
}
}
return 0;
}
static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
struct usbdevfs_urb32 *uurb)
{
unsigned int totlen;
int i;
if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
kurb->number_of_packets = 0;
return 0;
}
if (kurb->number_of_packets < 1 ||
kurb->number_of_packets > 128)
return -EINVAL;
if (copy_from_user(&kurb->iso_frame_desc[0],
&uurb->iso_frame_desc[0],
sizeof(struct usbdevfs_iso_packet_desc) *
kurb->number_of_packets))
return -EFAULT;
totlen = 0;
for (i = 0; i < kurb->number_of_packets; i++) {
unsigned int this_len;
this_len = kurb->iso_frame_desc[i].length;
if (this_len > 1023)
return -EINVAL;
totlen += this_len;
}
if (totlen > 32768)
return -EINVAL;
kurb->buffer_length = totlen;
return 0;
}
static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_urb *kurb;
struct usbdevfs_urb32 *uurb;
mm_segment_t old_fs;
__u32 udata;
void *uptr, *kptr;
unsigned int buflen;
int err;
uurb = (struct usbdevfs_urb32 *) arg;
err = -ENOMEM;
kurb = kmalloc(sizeof(struct usbdevfs_urb) +
(sizeof(struct usbdevfs_iso_packet_desc) * 128),
GFP_KERNEL);
if (!kurb)
goto out;
err = -EFAULT;
if (get_urb32(kurb, uurb))
goto out;
err = get_urb32_isoframes(kurb, uurb);
if (err)
goto out;
err = -EFAULT;
if (__get_user(udata, &uurb->buffer))
goto out;
uptr = compat_ptr(udata);
buflen = kurb->buffer_length;
err = verify_area(VERIFY_WRITE, uptr, buflen);
if (err)
goto out;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
set_fs(old_fs);
if (err >= 0) {
/* RED-PEN Shit, this doesn't work for async URBs :-( XXX */
if (put_urb32(kurb, uurb)) {
err = -EFAULT;
}
}
out:
kfree(kurb);
return err;
}
#endif
#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
{
mm_segment_t old_fs;
void *kptr;
int err;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd,
(cmd == USBDEVFS_REAPURB32 ?
USBDEVFS_REAPURB :
USBDEVFS_REAPURBNDELAY),
(unsigned long) &kptr);
set_fs(old_fs);
if (err >= 0 &&
put_user((u32)(u64)kptr, (u32 *)arg))
err = -EFAULT;
return err;
}
struct usbdevfs_disconnectsignal32 {
compat_int_t signr;
compat_caddr_t context;
};
#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct usbdevfs_disconnectsignal kdis;
struct usbdevfs_disconnectsignal32 *udis;
mm_segment_t old_fs;
u32 uctx;
int err;
udis = (struct usbdevfs_disconnectsignal32 *) arg;
if (get_user(kdis.signr, &udis->signr) ||
__get_user(uctx, &udis->context))
return -EFAULT;
kdis.context = (void *) (long)uctx;
old_fs = get_fs();
set_fs(KERNEL_DS);
err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
set_fs(old_fs);
return err;
}
#undef CODE #undef CODE
#endif #endif
...@@ -2443,6 +3010,22 @@ HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl) ...@@ -2443,6 +3010,22 @@ HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl)
HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget) HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget)
HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset) HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset)
HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64) HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64)
/* vfat */
HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32, vfat_ioctl32)
HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32, vfat_ioctl32)
HANDLE_IOCTL(REISERFS_IOC_UNPACK32, reiserfs_ioctl32)
/* Raw devices */
HANDLE_IOCTL(RAW_SETBIND, raw_ioctl)
HANDLE_IOCTL(RAW_GETBIND, raw_ioctl)
/* Serial */
HANDLE_IOCTL(TIOCGSERIAL, serial_struct_ioctl)
HANDLE_IOCTL(TIOCSSERIAL, serial_struct_ioctl)
/* Usbdevfs */
HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
/*HANDLE_IOCTL(USBDEVFS_SUBMITURB32, do_usbdevfs_urb)*/
HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb)
HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
#undef DECLARES #undef DECLARES
#endif #endif
include/linux/compat.h
View file @ f7719648
...@@ -90,5 +90,12 @@ struct compat_statfs64 { ...@@ -90,5 +90,12 @@ struct compat_statfs64 {
__u32 f_spare[5]; __u32 f_spare[5];
}; };
struct compat_dirent {
u32 d_ino;
compat_off_t d_off;
u16 d_reclen;
char d_name[256];
};
#endif /* CONFIG_COMPAT */ #endif /* CONFIG_COMPAT */
#endif /* _LINUX_COMPAT_H */ #endif /* _LINUX_COMPAT_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7