static int compat_cdrom_generic_command(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
struct cdrom_generic_command __user *cgc;
struct compat_cdrom_generic_command __user *cgc32;
u32 data;
unsigned char dir;
int itmp;
cgc = compat_alloc_user_space(sizeof(*cgc));
cgc32 = compat_ptr(arg);
if (copy_in_user(&cgc->cmd, &cgc32->cmd, sizeof(cgc->cmd)) ||
get_user(data, &cgc32->buffer) ||
put_user(compat_ptr(data), &cgc->buffer) ||
copy_in_user(&cgc->buflen, &cgc32->buflen,
(sizeof(unsigned int) + sizeof(int))) ||
get_user(data, &cgc32->sense) ||
put_user(compat_ptr(data), &cgc->sense) ||
get_user(dir, &cgc32->data_direction) ||
put_user(dir, &cgc->data_direction) ||
get_user(itmp, &cgc32->quiet) ||
put_user(itmp, &cgc->quiet) ||
get_user(itmp, &cgc32->timeout) ||
put_user(itmp, &cgc->timeout) ||
get_user(data, &cgc32->reserved[0]) ||
put_user(compat_ptr(data), &cgc->reserved[0]))
return -EFAULT;
return __blkdev_driver_ioctl(bdev, mode, cmd, (unsigned long)cgc);
}
long compat_put_v4l2_format_data(struct v4l2_format *kp, struct v4l2_format32 __user *up)
{
long ret = 0;
ret = put_user(kp->type, &up->type);
switch (kp->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
case V4L2_BUF_TYPE_VIDEO_OUTPUT:
ret |= copy_in_user(&up->fmt.pix, &kp->fmt.pix, sizeof(struct v4l2_pix_format));
break;
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
ret |= copy_in_user(&up->fmt.pix_mp, &kp->fmt.pix_mp, sizeof(struct v4l2_pix_format_mplane));
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
ret |= compat_put_v4l2_window(&kp->fmt.win, &up->fmt.win);
break;
case V4L2_BUF_TYPE_VBI_CAPTURE:
case V4L2_BUF_TYPE_VBI_OUTPUT:
ret |= copy_in_user(&up->fmt.vbi, &kp->fmt.vbi, sizeof(struct v4l2_vbi_format));
break;
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
ret |= copy_in_user(&up->fmt.sliced, &kp->fmt.sliced, sizeof(struct v4l2_sliced_vbi_format));
break;
default:
printk(KERN_INFO "compat_ioctl32: unexpected VIDIOC_FMT type %d\n",kp->type);
ret = -EINVAL;
}
return ret;
}
static int get_v4l2_plane32(struct v4l2_plane *up, struct v4l2_plane32 *up32,
enum v4l2_memory memory)
{
void __user *up_pln;
compat_long_t p;
if (copy_in_user(up, up32, 2 * sizeof(__u32)) ||
copy_in_user(&up->data_offset, &up32->data_offset,
sizeof(__u32)))
return -EFAULT;
if (memory == V4L2_MEMORY_USERPTR) {
if (get_user(p, &up32->m.userptr))
return -EFAULT;
up_pln = compat_ptr(p);
if (put_user((unsigned long)up_pln, &up->m.userptr))
return -EFAULT;
} else {
if (copy_in_user(&up->m.mem_offset, &up32->m.mem_offset,
sizeof(__u32)))
return -EFAULT;
}
return 0;
}
static int fbiogscursor(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct fbcursor __user *p = compat_alloc_user_space(sizeof(*p));
struct fbcursor32 __user *argp = (void __user *)arg;
compat_uptr_t addr;
int ret;
ret = copy_in_user(p, argp,
2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
ret |= copy_in_user(&p->size, &argp->size, sizeof(struct fbcurpos));
ret |= copy_in_user(&p->cmap, &argp->cmap, 2 * sizeof(int));
ret |= get_user(addr, &argp->cmap.red);
ret |= put_user(compat_ptr(addr), &p->cmap.red);
ret |= get_user(addr, &argp->cmap.green);
ret |= put_user(compat_ptr(addr), &p->cmap.green);
ret |= get_user(addr, &argp->cmap.blue);
ret |= put_user(compat_ptr(addr), &p->cmap.blue);
ret |= get_user(addr, &argp->mask);
ret |= put_user(compat_ptr(addr), &p->mask);
ret |= get_user(addr, &argp->image);
ret |= put_user(compat_ptr(addr), &p->image);
if (ret)
return -EFAULT;
return sys_ioctl (fd, FBIOSCURSOR, (unsigned long)p);
}
long compat_get_v4l2_event_data(struct v4l2_event __user *pdata, struct v4l2_event32 __user *pdata32)
{
long ret = 0;
compat_uint_t type;
compat_uint_t pending;
compat_uint_t sequence;
struct timespec timestamp;
compat_uint_t id;
if (!access_ok(VERIFY_READ, pdata32, sizeof(struct v4l2_event32)))
return -EFAULT;
ret = get_user(type, &pdata32->type);
ret |= put_user(type, &pdata->type);
ret |= copy_in_user(&pdata->u, &pdata32->u, sizeof(pdata->u));
ret |= get_user(pending, &pdata32->pending);
ret |= put_user(pending, &pdata->pending);
ret |= get_user(sequence, &pdata32->sequence);
ret |= put_user(sequence, &pdata->sequence);
ret |= get_compat_timespec(×tamp, &pdata32->timestamp);
/* ret |= put_compat_timespec(×tamp, &pdata->timestamp); */
ret |= copy_to_user(&pdata->timestamp, ×tamp, sizeof(timestamp));
ret |= get_user(id, &pdata32->id);
ret |= put_user(id, &pdata->id);
ret |= copy_in_user(pdata->reserved, pdata32->reserved, 8 * sizeof(__u32));
return ret;
}
long compat_put_v4l2_event_data(struct v4l2_event *kp, struct v4l2_event32 __user *up)
{
long ret = 0;
ret = put_user(kp->type, &up->type);
ret |= copy_in_user(&up->u, &kp->u, sizeof(kp->u));
ret |= put_user(kp->pending, &up->pending);
ret |= put_user(kp->sequence, &up->sequence);
ret |= put_compat_timespec(&kp->timestamp, &up->timestamp);
ret |= put_user(kp->id, &up->id);
ret |= copy_in_user(up->reserved, kp->reserved, 8 * sizeof(__u32));
return ret;
}
static int compat_cdrom_read_audio(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
struct cdrom_read_audio __user *cdread_audio;
struct compat_cdrom_read_audio __user *cdread_audio32;
__u32 data;
void __user *datap;
cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio));
cdread_audio32 = compat_ptr(arg);
if (copy_in_user(&cdread_audio->addr,
&cdread_audio32->addr,
(sizeof(*cdread_audio32) -
sizeof(compat_caddr_t))))
return -EFAULT;
if (get_user(data, &cdread_audio32->buf))
return -EFAULT;
datap = compat_ptr(data);
if (put_user(datap, &cdread_audio->buf))
return -EFAULT;
return __blkdev_driver_ioctl(bdev, mode, cmd,
(unsigned long)cdread_audio);
}
static int compat_cdrom_read_audio(struct inode *inode, struct file *file,
struct gendisk *disk, unsigned int cmd, unsigned long arg)
{
struct cdrom_read_audio __user *cdread_audio;
struct compat_cdrom_read_audio __user *cdread_audio32;
__u32 data;
void __user *datap;
cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio));
cdread_audio32 = compat_ptr(arg);
if (copy_in_user(&cdread_audio->addr,
&cdread_audio32->addr,
(sizeof(*cdread_audio32) -
sizeof(compat_caddr_t))))
return -EFAULT;
if (get_user(data, &cdread_audio32->buf))
return -EFAULT;
datap = compat_ptr(data);
if (put_user(datap, &cdread_audio->buf))
return -EFAULT;
return blkdev_driver_ioctl(inode, file, disk, cmd,
(unsigned long)cdread_audio);
}
long adf_compat_post_config(struct file *file,
struct adf_post_config32 __user *arg)
{
struct adf_post_config32 cfg32;
struct adf_post_config __user *cfg;
int ret;
if (copy_from_user(&cfg32, arg, sizeof(cfg32)))
return -EFAULT;
cfg = compat_alloc_user_space(sizeof(*cfg));
if (!access_ok(VERIFY_WRITE, cfg, sizeof(*cfg)))
return -EFAULT;
if (put_user(cfg32.n_interfaces, &cfg->n_interfaces) ||
put_user(compat_ptr(cfg32.interfaces),
&cfg->interfaces) ||
put_user(cfg32.n_bufs, &cfg->n_bufs) ||
put_user(compat_ptr(cfg32.bufs), &cfg->bufs) ||
put_user(cfg32.custom_data_size,
&cfg->custom_data_size) ||
put_user(compat_ptr(cfg32.custom_data),
&cfg->custom_data))
return -EFAULT;
ret = adf_file_ioctl(file, ADF_POST_CONFIG, (unsigned long)cfg);
if (ret < 0)
return ret;
if (copy_in_user(&arg->complete_fence, &cfg->complete_fence,
sizeof(cfg->complete_fence)))
return -EFAULT;
return 0;
}
static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
{
if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) ||
copy_from_user(&kp->w, &up->w, sizeof(up->w)) ||
get_user(kp->field, &up->field) ||
get_user(kp->chromakey, &up->chromakey) ||
get_user(kp->clipcount, &up->clipcount))
return -EFAULT;
if (kp->clipcount > 2048)
return -EINVAL;
if (kp->clipcount) {
struct v4l2_clip32 __user *uclips;
struct v4l2_clip __user *kclips;
int n = kp->clipcount;
compat_caddr_t p;
if (get_user(p, &up->clips))
return -EFAULT;
uclips = compat_ptr(p);
kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
kp->clips = kclips;
while (--n >= 0) {
if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
return -EFAULT;
if (put_user(n ? kclips + 1 : NULL, &kclips->next))
return -EFAULT;
uclips += 1;
kclips += 1;
}
} else
kp->clips = NULL;
return 0;
}
static int compat_get_qseecom_update_key_userinfo_req(
struct compat_qseecom_update_key_userinfo_req __user *data32,
struct qseecom_update_key_userinfo_req __user *data)
{
int err = 0;
compat_uint_t usage;
err = copy_in_user(data->current_hash32, data32->current_hash32,
QSEECOM_HASH_SIZE);
err |= copy_in_user(data->new_hash32, data32->new_hash32,
QSEECOM_HASH_SIZE);
err |= get_user(usage, &data32->usage);
err |= put_user(usage, &data->usage);
return err;
}
static int compat_get_qseecom_load_img_req(
struct compat_qseecom_load_img_req __user *data32,
struct qseecom_load_img_req __user *data)
{
int err;
compat_ulong_t mdt_len;
compat_ulong_t img_len;
compat_long_t ifd_data_fd;
compat_ulong_t app_arch;
compat_int_t app_id;
err = get_user(mdt_len, &data32->mdt_len);
err |= put_user(mdt_len, &data->mdt_len);
err |= get_user(img_len, &data32->img_len);
err |= put_user(img_len, &data->img_len);
err |= get_user(ifd_data_fd, &data32->ifd_data_fd);
err |= put_user(ifd_data_fd, &data->ifd_data_fd);
err |= copy_in_user(data->img_name, data32->img_name,
MAX_APP_NAME_SIZE);
err |= get_user(app_arch, &data32->app_arch);
err |= put_user(app_arch, &data->app_arch);
err |= get_user(app_id, &data32->app_id);
err |= put_user(app_id, &data->app_id);
return err;
}
static int put_v4l2_plane32(struct v4l2_plane *up, struct v4l2_plane32 *up32,
enum v4l2_memory memory)
{
if (copy_in_user(up32, up, 2 * sizeof(__u32)) ||
copy_in_user(&up32->data_offset, &up->data_offset,
sizeof(__u32)))
return -EFAULT;
/* For MMAP, driver might've set up the offset, so copy it back.
* USERPTR stays the same (was userspace-provided), so no copying. */
if (memory == V4L2_MEMORY_MMAP)
if (copy_in_user(&up32->m.mem_offset, &up->m.mem_offset,
sizeof(__u32)))
return -EFAULT;
return 0;
}
STATIC unsigned long xfs_ioctl32_geom_v1(unsigned long arg)
{
compat_xfs_fsop_geom_v1_t __user *p32 = (void __user *)arg;
xfs_fsop_geom_v1_t __user *p = compat_alloc_user_space(sizeof(*p));
if (copy_in_user(p, p32, sizeof(*p32)))
return -EFAULT;
return (unsigned long)p;
}
static int compat_put_v4l2_window(struct v4l2_window *kp, struct v4l2_window32 __user *up)
{
if (copy_in_user(&up->w, &kp->w, sizeof(kp->w)) ||
put_user(kp->field, &up->field) ||
put_user(kp->chromakey, &up->chromakey) ||
put_user(kp->clipcount, &up->clipcount))
return -EFAULT;
return 0;
}
long adf_compat_get_device_data(struct file *file,
struct adf_device_data32 __user *arg)
{
struct adf_device_data32 data32;
struct adf_device_data __user *data;
int ret;
if (copy_from_user(&data32, arg, sizeof(data32)))
return -EFAULT;
data = compat_alloc_user_space(sizeof(*data));
if (!access_ok(VERIFY_WRITE, data, sizeof(*data)))
return -EFAULT;
if (put_user(data32.n_attachments, &data->n_attachments) ||
put_user(compat_ptr(data32.attachments),
&data->attachments) ||
put_user(data32.n_allowed_attachments,
&data->n_allowed_attachments) ||
put_user(compat_ptr(data32.allowed_attachments),
&data->allowed_attachments) ||
put_user(data32.custom_data_size,
&data->custom_data_size) ||
put_user(compat_ptr(data32.custom_data),
&data->custom_data))
return -EFAULT;
ret = adf_file_ioctl(file, ADF_GET_DEVICE_DATA32, (unsigned long)data);
if (ret < 0)
return ret;
if (copy_in_user(arg->name, data->name, sizeof(arg->name)) ||
copy_in_user(&arg->n_attachments, &data->n_attachments,
sizeof(arg->n_attachments)) ||
copy_in_user(&arg->n_allowed_attachments,
&data->n_allowed_attachments,
sizeof(arg->n_allowed_attachments)) ||
copy_in_user(&arg->custom_data_size,
&data->custom_data_size,
sizeof(arg->custom_data_size)))
return -EFAULT;
return 0;
}
STATIC unsigned long xfs_ioctl32_fshandle(unsigned long arg)
{
compat_xfs_fsop_handlereq_t __user *p32 = (void __user *)arg;
xfs_fsop_handlereq_t __user *p = compat_alloc_user_space(sizeof(*p));
u32 addr;
if (copy_in_user(&p->fd, &p32->fd, sizeof(__u32)) ||
get_user(addr, &p32->path) ||
put_user(compat_ptr(addr), &p->path) ||
copy_in_user(&p->oflags, &p32->oflags, sizeof(__u32)) ||
get_user(addr, &p32->ihandle) ||
put_user(compat_ptr(addr), &p->ihandle) ||
copy_in_user(&p->ihandlen, &p32->ihandlen, sizeof(__u32)) ||
get_user(addr, &p32->ohandle) ||
put_user(compat_ptr(addr), &p->ohandle) ||
get_user(addr, &p32->ohandlen) ||
put_user(compat_ptr(addr), &p->ohandlen))
return -EFAULT;
return (unsigned long)p;
}
static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up)
{
struct v4l2_ext_control __user *ucontrols;
struct v4l2_ext_control __user *kcontrols;
int n;
compat_caddr_t p;
if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_ext_controls32)) ||
get_user(kp->ctrl_class, &up->ctrl_class) ||
get_user(kp->count, &up->count) ||
get_user(kp->error_idx, &up->error_idx) ||
copy_from_user(kp->reserved, up->reserved, sizeof(kp->reserved)))
return -EFAULT;
n = kp->count;
if (n == 0) {
kp->controls = NULL;
return 0;
}
if (get_user(p, &up->controls))
return -EFAULT;
ucontrols = compat_ptr(p);
if (!access_ok(VERIFY_READ, ucontrols, n * sizeof(struct v4l2_ext_control)))
return -EFAULT;
kcontrols = compat_alloc_user_space(n * sizeof(struct v4l2_ext_control));
kp->controls = kcontrols;
while (--n >= 0) {
if (copy_in_user(&kcontrols->id, &ucontrols->id, sizeof(__u32)))
return -EFAULT;
if (copy_in_user(&kcontrols->reserved2, &ucontrols->reserved2, sizeof(ucontrols->reserved2)))
return -EFAULT;
/* Note: if the void * part of the union ever becomes relevant
then we need to know the type of the control in order to do
the right thing here. Luckily, that is not yet an issue. */
if (copy_in_user(&kcontrols->value, &ucontrols->value, sizeof(ucontrols->value)))
return -EFAULT;
ucontrols++;
kcontrols++;
}
return 0;
}
static int compat_get_qseecom_save_partition_hash_req(
struct compat_qseecom_save_partition_hash_req __user *data32,
struct qseecom_save_partition_hash_req __user *data)
{
int err;
compat_int_t partition_id;
err = get_user(partition_id, &data32->partition_id);
err |= put_user(partition_id, &data->partition_id);
err |= copy_in_user(data->digest, data32->digest,
SHA256_DIGEST_LENGTH);
return err;
}
static int compat_get_qseecom_create_key_req(
struct compat_qseecom_create_key_req __user *data32,
struct qseecom_create_key_req __user *data)
{
int err;
compat_uint_t usage;
err = copy_in_user(data->hash32, data32->hash32, QSEECOM_HASH_SIZE);
err |= get_user(usage, &data32->usage);
err |= put_user(usage, &data->usage);
return err;
}
long adf_compat_get_overlay_engine_data(struct file *file,
struct adf_overlay_engine_data32 __user *arg)
{
struct adf_overlay_engine_data32 data32;
struct adf_overlay_engine_data __user *data;
int ret;
if (copy_from_user(&data32, arg, sizeof(data32)))
return -EFAULT;
data = compat_alloc_user_space(sizeof(*data));
if (!access_ok(VERIFY_WRITE, data, sizeof(*data)))
return -EFAULT;
if (put_user(data32.n_supported_formats, &data->n_supported_formats) ||
put_user(compat_ptr(data32.supported_formats),
&data->supported_formats) ||
put_user(data32.custom_data_size,
&data->custom_data_size) ||
put_user(compat_ptr(data32.custom_data),
&data->custom_data))
return -EFAULT;
ret = adf_file_ioctl(file, ADF_GET_OVERLAY_ENGINE_DATA,
(unsigned long)data);
if (ret < 0)
return ret;
if (copy_in_user(arg->name, data->name, sizeof(arg->name)) ||
copy_in_user(&arg->n_supported_formats,
&data->n_supported_formats,
sizeof(arg->n_supported_formats)) ||
copy_in_user(&arg->custom_data_size,
&data->custom_data_size,
sizeof(arg->custom_data_size)))
return -EFAULT;
return 0;
}
long compat_put_hwisp_stream_buf_info(hwisp_stream_buf_info_t *kp, hwisp_stream_buf_info_t32 __user *up)
{
long ret = 0;
ret = put_user(kp->user_buffer_handle, &up->user_buffer_handle);
ret |= put_user(kp->y_addr_phy, &up->y_addr_phy);
ret |= put_user(kp->u_addr_phy, &up->u_addr_phy);
ret |= put_user(kp->v_addr_phy, &up->v_addr_phy);
ret |= put_user(kp->y_addr_iommu, &up->y_addr_iommu);
ret |= put_user(kp->u_addr_iommu, &up->u_addr_iommu);
ret |= put_user(kp->v_addr_iommu, &up->v_addr_iommu);
ret |= put_user(kp->ion_fd, &up->ion_fd);
ret |= put_user(kp->ion_vc_hdl, &up->ion_vc_hdl);
ret |= put_user(kp->ion_vaddr, &up->ion_vaddr);
ret |= put_compat_timeval(&kp->timestamp, &up->timestamp);
ret |= copy_in_user(&up->port, &kp->port, sizeof(ovisp23_port_info_t));
return ret;
}
static int fbiogetputcmap(unsigned int fd, unsigned int cmd, unsigned long arg)
{
struct fbcmap32 __user *argp = (void __user *)arg;
struct fbcmap __user *p = compat_alloc_user_space(sizeof(*p));
u32 addr;
int ret;
ret = copy_in_user(p, argp, 2 * sizeof(int));
ret |= get_user(addr, &argp->red);
ret |= put_user(compat_ptr(addr), &p->red);
ret |= get_user(addr, &argp->green);
ret |= put_user(compat_ptr(addr), &p->green);
ret |= get_user(addr, &argp->blue);
ret |= put_user(compat_ptr(addr), &p->blue);
if (ret)
return -EFAULT;
return sys_ioctl(fd, (cmd == FBIOPUTCMAP32) ? FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC, (unsigned long)p);
}
static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up)
{
struct v4l2_ext_control32 __user *ucontrols;
struct v4l2_ext_control __user *kcontrols;
int n;
compat_caddr_t p;
if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_ext_controls32)) ||
get_user(kp->ctrl_class, &up->ctrl_class) ||
get_user(kp->count, &up->count) ||
get_user(kp->error_idx, &up->error_idx) ||
copy_from_user(kp->reserved, up->reserved, sizeof(kp->reserved)))
return -EFAULT;
n = kp->count;
if (n == 0) {
kp->controls = NULL;
return 0;
}
if (get_user(p, &up->controls))
return -EFAULT;
ucontrols = compat_ptr(p);
if (!access_ok(VERIFY_READ, ucontrols,
n * sizeof(struct v4l2_ext_control32)))
return -EFAULT;
kcontrols = compat_alloc_user_space(n * sizeof(struct v4l2_ext_control));
kp->controls = kcontrols;
while (--n >= 0) {
if (copy_in_user(kcontrols, ucontrols, sizeof(*ucontrols)))
return -EFAULT;
if (ctrl_is_pointer(kcontrols->id)) {
void __user *s;
if (get_user(p, &ucontrols->string))
return -EFAULT;
s = compat_ptr(p);
if (put_user(s, &kcontrols->string))
return -EFAULT;
}
ucontrols++;
kcontrols++;
}
return 0;
}
STATIC unsigned long
xfs_ioctl32_bulkstat(
unsigned long arg)
{
xfs_fsop_bulkreq32_t __user *p32 = (void __user *)arg;
xfs_fsop_bulkreq_t __user *p = compat_alloc_user_space(sizeof(*p));
u32 addr;
if (get_user(addr, &p32->lastip) ||
put_user(compat_ptr(addr), &p->lastip) ||
copy_in_user(&p->icount, &p32->icount, sizeof(s32)) ||
get_user(addr, &p32->ubuffer) ||
put_user(compat_ptr(addr), &p->ubuffer) ||
get_user(addr, &p32->ocount) ||
put_user(compat_ptr(addr), &p->ocount))
return -EFAULT;
return (unsigned long)p;
}
long compat_sys_msgsnd(int first, int second, int third, void __user *uptr)
{
struct msgbuf __user *p;
struct compat_msgbuf __user *up = uptr;
long type;
if (first < 0)
return -EINVAL;
if (second < 0 || (second >= MAXBUF - sizeof(struct msgbuf)))
return -EINVAL;
p = compat_alloc_user_space(second + sizeof(struct msgbuf));
if (get_user(type, &up->mtype) ||
put_user(type, &p->mtype) ||
copy_in_user(p->mtext, up->mtext, second))
return -EFAULT;
return sys_msgsnd(first, p, second, third);
}
/* just account for different alignment */
STATIC unsigned long
xfs_ioctl32_flock(
unsigned long arg)
{
xfs_flock64_32_t __user *p32 = (void __user *)arg;
xfs_flock64_t __user *p = compat_alloc_user_space(sizeof(*p));
if (copy_in_user(&p->l_type, &p32->l_type, sizeof(s16)) ||
copy_in_user(&p->l_whence, &p32->l_whence, sizeof(s16)) ||
copy_in_user(&p->l_start, &p32->l_start, sizeof(s64)) ||
copy_in_user(&p->l_len, &p32->l_len, sizeof(s64)) ||
copy_in_user(&p->l_sysid, &p32->l_sysid, sizeof(s32)) ||
copy_in_user(&p->l_pid, &p32->l_pid, sizeof(u32)) ||
copy_in_user(&p->l_pad, &p32->l_pad, 4*sizeof(u32)))
return -EFAULT;
return (unsigned long)p;
}
static inline int _snd_ioctl32_hwdep_dsp_image(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
{
struct snd_hwdep_dsp_image __user *data, *dst;
struct snd_hwdep_dsp_image32 __user *data32, *src;
compat_caddr_t ptr;
data32 = compat_ptr(arg);
data = compat_alloc_user_space(sizeof(*data));
/* index and name */
if (copy_in_user(data, data32, 4 + 64))
return -EFAULT;
if (__get_user(ptr, &data32->image) ||
__put_user(compat_ptr(ptr), &data->image))
return -EFAULT;
src = data32;
dst = data;
COPY_CVT(length);
COPY_CVT(driver_data);
return file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
}
static int
xfs_ioctl32_bulkstat(
unsigned int fd,
unsigned int cmd,
unsigned long arg,
struct file * file)
{
xfs_fsop_bulkreq32_t __user *p32 = (void __user *)arg;
xfs_fsop_bulkreq_t __user *p = compat_alloc_user_space(sizeof(*p));
u32 addr;
if (get_user(addr, &p32->lastip) ||
put_user(compat_ptr(addr), &p->lastip) ||
copy_in_user(&p->icount, &p32->icount, sizeof(s32)) ||
get_user(addr, &p32->ubuffer) ||
put_user(compat_ptr(addr), &p->ubuffer) ||
get_user(addr, &p32->ocount) ||
put_user(compat_ptr(addr), &p->ocount))
return -EFAULT;
return sys_ioctl(fd, cmd, (unsigned long)p);
}
static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
{
drm32_version_t __user *uversion = (drm32_version_t __user *)arg;
drm_version_t __user *p = compat_alloc_user_space(sizeof(*p));
compat_uptr_t addr;
int n;
int ret;
if (clear_user(p, 3 * sizeof(int)) ||
get_user(n, &uversion->name_len) ||
put_user(n, &p->name_len) ||
get_user(addr, &uversion->name) ||
put_user(compat_ptr(addr), &p->name) ||
get_user(n, &uversion->date_len) ||
put_user(n, &p->date_len) ||
get_user(addr, &uversion->date) ||
put_user(compat_ptr(addr), &p->date) ||
get_user(n, &uversion->desc_len) ||
put_user(n, &p->desc_len) ||
get_user(addr, &uversion->desc) ||
put_user(compat_ptr(addr), &p->desc))
return -EFAULT;
ret = sys_ioctl(fd, DRM_IOCTL_VERSION, (unsigned long)p);
if (ret)
return ret;
if (copy_in_user(uversion, p, 3 * sizeof(int)) ||
get_user(n, &p->name_len) ||
put_user(n, &uversion->name_len) ||
get_user(n, &p->date_len) ||
put_user(n, &uversion->date_len) ||
get_user(n, &p->desc_len) ||
put_user(n, &uversion->desc_len))
return -EFAULT;
return 0;
}