linux/fs/compat_ioctl.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
   4 *
   5 * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
   6 * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
   7 * Copyright (C) 2001,2002  Andi Kleen, SuSE Labs 
   8 * Copyright (C) 2003       Pavel Machek (pavel@ucw.cz)
   9 *
  10 * These routines maintain argument size conversion between 32bit and 64bit
  11 * ioctls.
  12 */
  13
  14#include <linux/joystick.h>
  15
  16#include <linux/types.h>
  17#include <linux/compat.h>
  18#include <linux/kernel.h>
  19#include <linux/capability.h>
  20#include <linux/compiler.h>
  21#include <linux/sched.h>
  22#include <linux/smp.h>
  23#include <linux/ioctl.h>
  24#include <linux/if.h>
  25#include <linux/raid/md_u.h>
  26#include <linux/falloc.h>
  27#include <linux/file.h>
  28#include <linux/ppp-ioctl.h>
  29#include <linux/if_pppox.h>
  30#include <linux/mtio.h>
  31#include <linux/tty.h>
  32#include <linux/vt_kern.h>
  33#include <linux/raw.h>
  34#include <linux/blkdev.h>
  35#include <linux/rtc.h>
  36#include <linux/pci.h>
  37#include <linux/serial.h>
  38#include <linux/ctype.h>
  39#include <linux/syscalls.h>
  40#include <linux/gfp.h>
  41#include <linux/cec.h>
  42
  43#include "internal.h"
  44
  45#include <net/bluetooth/bluetooth.h>
  46#include <net/bluetooth/hci_sock.h>
  47#include <net/bluetooth/rfcomm.h>
  48
  49#include <linux/capi.h>
  50#include <linux/gigaset_dev.h>
  51
  52#ifdef CONFIG_BLOCK
  53#include <linux/cdrom.h>
  54#include <linux/fd.h>
  55#include <scsi/scsi.h>
  56#include <scsi/scsi_ioctl.h>
  57#include <scsi/sg.h>
  58#endif
  59
  60#include <linux/uaccess.h>
  61#include <linux/watchdog.h>
  62
  63#include <linux/soundcard.h>
  64
  65#include <linux/hiddev.h>
  66
  67
  68#include <linux/sort.h>
  69
  70#ifdef CONFIG_SPARC
  71#include <linux/fb.h>
  72#include <asm/fbio.h>
  73#endif
  74
  75#define convert_in_user(srcptr, dstptr)                 \
  76({                                                      \
  77        typeof(*srcptr) val;                            \
  78                                                        \
  79        get_user(val, srcptr) || put_user(val, dstptr); \
  80})
  81
  82static int do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  83{
  84        int err;
  85
  86        err = security_file_ioctl(file, cmd, arg);
  87        if (err)
  88                return err;
  89
  90        return vfs_ioctl(file, cmd, arg);
  91}
  92
  93#ifdef CONFIG_BLOCK
  94typedef struct sg_io_hdr32 {
  95        compat_int_t interface_id;      /* [i] 'S' for SCSI generic (required) */
  96        compat_int_t dxfer_direction;   /* [i] data transfer direction  */
  97        unsigned char cmd_len;          /* [i] SCSI command length ( <= 16 bytes) */
  98        unsigned char mx_sb_len;                /* [i] max length to write to sbp */
  99        unsigned short iovec_count;     /* [i] 0 implies no scatter gather */
 100        compat_uint_t dxfer_len;                /* [i] byte count of data transfer */
 101        compat_uint_t dxferp;           /* [i], [*io] points to data transfer memory
 102                                              or scatter gather list */
 103        compat_uptr_t cmdp;             /* [i], [*i] points to command to perform */
 104        compat_uptr_t sbp;              /* [i], [*o] points to sense_buffer memory */
 105        compat_uint_t timeout;          /* [i] MAX_UINT->no timeout (unit: millisec) */
 106        compat_uint_t flags;            /* [i] 0 -> default, see SG_FLAG... */
 107        compat_int_t pack_id;           /* [i->o] unused internally (normally) */
 108        compat_uptr_t usr_ptr;          /* [i->o] unused internally */
 109        unsigned char status;           /* [o] scsi status */
 110        unsigned char masked_status;    /* [o] shifted, masked scsi status */
 111        unsigned char msg_status;               /* [o] messaging level data (optional) */
 112        unsigned char sb_len_wr;                /* [o] byte count actually written to sbp */
 113        unsigned short host_status;     /* [o] errors from host adapter */
 114        unsigned short driver_status;   /* [o] errors from software driver */
 115        compat_int_t resid;             /* [o] dxfer_len - actual_transferred */
 116        compat_uint_t duration;         /* [o] time taken by cmd (unit: millisec) */
 117        compat_uint_t info;             /* [o] auxiliary information */
 118} sg_io_hdr32_t;  /* 64 bytes long (on sparc32) */
 119
 120typedef struct sg_iovec32 {
 121        compat_uint_t iov_base;
 122        compat_uint_t iov_len;
 123} sg_iovec32_t;
 124
 125static int sg_build_iovec(sg_io_hdr_t __user *sgio, void __user *dxferp, u16 iovec_count)
 126{
 127        sg_iovec_t __user *iov = (sg_iovec_t __user *) (sgio + 1);
 128        sg_iovec32_t __user *iov32 = dxferp;
 129        int i;
 130
 131        for (i = 0; i < iovec_count; i++) {
 132                u32 base, len;
 133
 134                if (get_user(base, &iov32[i].iov_base) ||
 135                    get_user(len, &iov32[i].iov_len) ||
 136                    put_user(compat_ptr(base), &iov[i].iov_base) ||
 137                    put_user(len, &iov[i].iov_len))
 138                        return -EFAULT;
 139        }
 140
 141        if (put_user(iov, &sgio->dxferp))
 142                return -EFAULT;
 143        return 0;
 144}
 145
 146static int sg_ioctl_trans(struct file *file, unsigned int cmd,
 147                        sg_io_hdr32_t __user *sgio32)
 148{
 149        sg_io_hdr_t __user *sgio;
 150        u16 iovec_count;
 151        u32 data;
 152        void __user *dxferp;
 153        int err;
 154        int interface_id;
 155
 156        if (get_user(interface_id, &sgio32->interface_id))
 157                return -EFAULT;
 158        if (interface_id != 'S')
 159                return do_ioctl(file, cmd, (unsigned long)sgio32);
 160
 161        if (get_user(iovec_count, &sgio32->iovec_count))
 162                return -EFAULT;
 163
 164        {
 165                void __user *top = compat_alloc_user_space(0);
 166                void __user *new = compat_alloc_user_space(sizeof(sg_io_hdr_t) +
 167                                       (iovec_count * sizeof(sg_iovec_t)));
 168                if (new > top)
 169                        return -EINVAL;
 170
 171                sgio = new;
 172        }
 173
 174        /* Ok, now construct.  */
 175        if (copy_in_user(&sgio->interface_id, &sgio32->interface_id,
 176                         (2 * sizeof(int)) +
 177                         (2 * sizeof(unsigned char)) +
 178                         (1 * sizeof(unsigned short)) +
 179                         (1 * sizeof(unsigned int))))
 180                return -EFAULT;
 181
 182        if (get_user(data, &sgio32->dxferp))
 183                return -EFAULT;
 184        dxferp = compat_ptr(data);
 185        if (iovec_count) {
 186                if (sg_build_iovec(sgio, dxferp, iovec_count))
 187                        return -EFAULT;
 188        } else {
 189                if (put_user(dxferp, &sgio->dxferp))
 190                        return -EFAULT;
 191        }
 192
 193        {
 194                unsigned char __user *cmdp;
 195                unsigned char __user *sbp;
 196
 197                if (get_user(data, &sgio32->cmdp))
 198                        return -EFAULT;
 199                cmdp = compat_ptr(data);
 200
 201                if (get_user(data, &sgio32->sbp))
 202                        return -EFAULT;
 203                sbp = compat_ptr(data);
 204
 205                if (put_user(cmdp, &sgio->cmdp) ||
 206                    put_user(sbp, &sgio->sbp))
 207                        return -EFAULT;
 208        }
 209
 210        if (copy_in_user(&sgio->timeout, &sgio32->timeout,
 211                         3 * sizeof(int)))
 212                return -EFAULT;
 213
 214        if (get_user(data, &sgio32->usr_ptr))
 215                return -EFAULT;
 216        if (put_user(compat_ptr(data), &sgio->usr_ptr))
 217                return -EFAULT;
 218
 219        err = do_ioctl(file, cmd, (unsigned long) sgio);
 220
 221        if (err >= 0) {
 222                void __user *datap;
 223
 224                if (copy_in_user(&sgio32->pack_id, &sgio->pack_id,
 225                                 sizeof(int)) ||
 226                    get_user(datap, &sgio->usr_ptr) ||
 227                    put_user((u32)(unsigned long)datap,
 228                             &sgio32->usr_ptr) ||
 229                    copy_in_user(&sgio32->status, &sgio->status,
 230                                 (4 * sizeof(unsigned char)) +
 231                                 (2 * sizeof(unsigned short)) +
 232                                 (3 * sizeof(int))))
 233                        err = -EFAULT;
 234        }
 235
 236        return err;
 237}
 238
 239struct compat_sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
 240        char req_state;
 241        char orphan;
 242        char sg_io_owned;
 243        char problem;
 244        int pack_id;
 245        compat_uptr_t usr_ptr;
 246        unsigned int duration;
 247        int unused;
 248};
 249
 250static int sg_grt_trans(struct file *file,
 251                unsigned int cmd, struct compat_sg_req_info __user *o)
 252{
 253        int err, i;
 254        sg_req_info_t __user *r;
 255        r = compat_alloc_user_space(sizeof(sg_req_info_t)*SG_MAX_QUEUE);
 256        err = do_ioctl(file, cmd, (unsigned long)r);
 257        if (err < 0)
 258                return err;
 259        for (i = 0; i < SG_MAX_QUEUE; i++) {
 260                void __user *ptr;
 261                int d;
 262
 263                if (copy_in_user(o + i, r + i, offsetof(sg_req_info_t, usr_ptr)) ||
 264                    get_user(ptr, &r[i].usr_ptr) ||
 265                    get_user(d, &r[i].duration) ||
 266                    put_user((u32)(unsigned long)(ptr), &o[i].usr_ptr) ||
 267                    put_user(d, &o[i].duration))
 268                        return -EFAULT;
 269        }
 270        return err;
 271}
 272#endif /* CONFIG_BLOCK */
 273
 274struct sock_fprog32 {
 275        unsigned short  len;
 276        compat_caddr_t  filter;
 277};
 278
 279#define PPPIOCSPASS32   _IOW('t', 71, struct sock_fprog32)
 280#define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
 281
 282static int ppp_sock_fprog_ioctl_trans(struct file *file,
 283                unsigned int cmd, struct sock_fprog32 __user *u_fprog32)
 284{
 285        struct sock_fprog __user *u_fprog64 = compat_alloc_user_space(sizeof(struct sock_fprog));
 286        void __user *fptr64;
 287        u32 fptr32;
 288        u16 flen;
 289
 290        if (get_user(flen, &u_fprog32->len) ||
 291            get_user(fptr32, &u_fprog32->filter))
 292                return -EFAULT;
 293
 294        fptr64 = compat_ptr(fptr32);
 295
 296        if (put_user(flen, &u_fprog64->len) ||
 297            put_user(fptr64, &u_fprog64->filter))
 298                return -EFAULT;
 299
 300        if (cmd == PPPIOCSPASS32)
 301                cmd = PPPIOCSPASS;
 302        else
 303                cmd = PPPIOCSACTIVE;
 304
 305        return do_ioctl(file, cmd, (unsigned long) u_fprog64);
 306}
 307
 308struct ppp_option_data32 {
 309        compat_caddr_t  ptr;
 310        u32                     length;
 311        compat_int_t            transmit;
 312};
 313#define PPPIOCSCOMPRESS32       _IOW('t', 77, struct ppp_option_data32)
 314
 315struct ppp_idle32 {
 316        compat_time_t xmit_idle;
 317        compat_time_t recv_idle;
 318};
 319#define PPPIOCGIDLE32           _IOR('t', 63, struct ppp_idle32)
 320
 321static int ppp_gidle(struct file *file, unsigned int cmd,
 322                struct ppp_idle32 __user *idle32)
 323{
 324        struct ppp_idle __user *idle;
 325        __kernel_time_t xmit, recv;
 326        int err;
 327
 328        idle = compat_alloc_user_space(sizeof(*idle));
 329
 330        err = do_ioctl(file, PPPIOCGIDLE, (unsigned long) idle);
 331
 332        if (!err) {
 333                if (get_user(xmit, &idle->xmit_idle) ||
 334                    get_user(recv, &idle->recv_idle) ||
 335                    put_user(xmit, &idle32->xmit_idle) ||
 336                    put_user(recv, &idle32->recv_idle))
 337                        err = -EFAULT;
 338        }
 339        return err;
 340}
 341
 342static int ppp_scompress(struct file *file, unsigned int cmd,
 343        struct ppp_option_data32 __user *odata32)
 344{
 345        struct ppp_option_data __user *odata;
 346        __u32 data;
 347        void __user *datap;
 348
 349        odata = compat_alloc_user_space(sizeof(*odata));
 350
 351        if (get_user(data, &odata32->ptr))
 352                return -EFAULT;
 353
 354        datap = compat_ptr(data);
 355        if (put_user(datap, &odata->ptr))
 356                return -EFAULT;
 357
 358        if (copy_in_user(&odata->length, &odata32->length,
 359                         sizeof(__u32) + sizeof(int)))
 360                return -EFAULT;
 361
 362        return do_ioctl(file, PPPIOCSCOMPRESS, (unsigned long) odata);
 363}
 364
 365#ifdef CONFIG_BLOCK
 366struct mtget32 {
 367        compat_long_t   mt_type;
 368        compat_long_t   mt_resid;
 369        compat_long_t   mt_dsreg;
 370        compat_long_t   mt_gstat;
 371        compat_long_t   mt_erreg;
 372        compat_daddr_t  mt_fileno;
 373        compat_daddr_t  mt_blkno;
 374};
 375#define MTIOCGET32      _IOR('m', 2, struct mtget32)
 376
 377struct mtpos32 {
 378        compat_long_t   mt_blkno;
 379};
 380#define MTIOCPOS32      _IOR('m', 3, struct mtpos32)
 381
 382static int mt_ioctl_trans(struct file *file,
 383                unsigned int cmd, void __user *argp)
 384{
 385        /* NULL initialization to make gcc shut up */
 386        struct mtget __user *get = NULL;
 387        struct mtget32 __user *umget32;
 388        struct mtpos __user *pos = NULL;
 389        struct mtpos32 __user *upos32;
 390        unsigned long kcmd;
 391        void *karg;
 392        int err = 0;
 393
 394        switch(cmd) {
 395        case MTIOCPOS32:
 396                kcmd = MTIOCPOS;
 397                pos = compat_alloc_user_space(sizeof(*pos));
 398                karg = pos;
 399                break;
 400        default:        /* MTIOCGET32 */
 401                kcmd = MTIOCGET;
 402                get = compat_alloc_user_space(sizeof(*get));
 403                karg = get;
 404                break;
 405        }
 406        if (karg == NULL)
 407                return -EFAULT;
 408        err = do_ioctl(file, kcmd, (unsigned long)karg);
 409        if (err)
 410                return err;
 411        switch (cmd) {
 412        case MTIOCPOS32:
 413                upos32 = argp;
 414                err = convert_in_user(&pos->mt_blkno, &upos32->mt_blkno);
 415                break;
 416        case MTIOCGET32:
 417                umget32 = argp;
 418                err = convert_in_user(&get->mt_type, &umget32->mt_type);
 419                err |= convert_in_user(&get->mt_resid, &umget32->mt_resid);
 420                err |= convert_in_user(&get->mt_dsreg, &umget32->mt_dsreg);
 421                err |= convert_in_user(&get->mt_gstat, &umget32->mt_gstat);
 422                err |= convert_in_user(&get->mt_erreg, &umget32->mt_erreg);
 423                err |= convert_in_user(&get->mt_fileno, &umget32->mt_fileno);
 424                err |= convert_in_user(&get->mt_blkno, &umget32->mt_blkno);
 425                break;
 426        }
 427        return err ? -EFAULT: 0;
 428}
 429
 430#endif /* CONFIG_BLOCK */
 431
 432/* Bluetooth ioctls */
 433#define HCIUARTSETPROTO         _IOW('U', 200, int)
 434#define HCIUARTGETPROTO         _IOR('U', 201, int)
 435#define HCIUARTGETDEVICE        _IOR('U', 202, int)
 436#define HCIUARTSETFLAGS         _IOW('U', 203, int)
 437#define HCIUARTGETFLAGS         _IOR('U', 204, int)
 438
 439#define RTC_IRQP_READ32         _IOR('p', 0x0b, compat_ulong_t)
 440#define RTC_IRQP_SET32          _IOW('p', 0x0c, compat_ulong_t)
 441#define RTC_EPOCH_READ32        _IOR('p', 0x0d, compat_ulong_t)
 442#define RTC_EPOCH_SET32         _IOW('p', 0x0e, compat_ulong_t)
 443
 444static int rtc_ioctl(struct file *file,
 445                unsigned cmd, void __user *argp)
 446{
 447        unsigned long __user *valp = compat_alloc_user_space(sizeof(*valp));
 448        int ret;
 449
 450        if (valp == NULL)
 451                return -EFAULT;
 452        switch (cmd) {
 453        case RTC_IRQP_READ32:
 454        case RTC_EPOCH_READ32:
 455                ret = do_ioctl(file, (cmd == RTC_IRQP_READ32) ?
 456                                        RTC_IRQP_READ : RTC_EPOCH_READ,
 457                                        (unsigned long)valp);
 458                if (ret)
 459                        return ret;
 460                return convert_in_user(valp, (unsigned int __user *)argp);
 461        case RTC_IRQP_SET32:
 462                return do_ioctl(file, RTC_IRQP_SET, (unsigned long)argp);
 463        case RTC_EPOCH_SET32:
 464                return do_ioctl(file, RTC_EPOCH_SET, (unsigned long)argp);
 465        }
 466
 467        return -ENOIOCTLCMD;
 468}
 469
 470/* on ia32 l_start is on a 32-bit boundary */
 471#if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
 472struct space_resv_32 {
 473        __s16           l_type;
 474        __s16           l_whence;
 475        __s64           l_start __attribute__((packed));
 476                        /* len == 0 means until end of file */
 477        __s64           l_len __attribute__((packed));
 478        __s32           l_sysid;
 479        __u32           l_pid;
 480        __s32           l_pad[4];       /* reserve area */
 481};
 482
 483#define FS_IOC_RESVSP_32                _IOW ('X', 40, struct space_resv_32)
 484#define FS_IOC_RESVSP64_32      _IOW ('X', 42, struct space_resv_32)
 485
 486/* just account for different alignment */
 487static int compat_ioctl_preallocate(struct file *file,
 488                        struct space_resv_32    __user *p32)
 489{
 490        struct space_resv       __user *p = compat_alloc_user_space(sizeof(*p));
 491
 492        if (copy_in_user(&p->l_type,    &p32->l_type,   sizeof(s16)) ||
 493            copy_in_user(&p->l_whence,  &p32->l_whence, sizeof(s16)) ||
 494            copy_in_user(&p->l_start,   &p32->l_start,  sizeof(s64)) ||
 495            copy_in_user(&p->l_len,     &p32->l_len,    sizeof(s64)) ||
 496            copy_in_user(&p->l_sysid,   &p32->l_sysid,  sizeof(s32)) ||
 497            copy_in_user(&p->l_pid,     &p32->l_pid,    sizeof(u32)) ||
 498            copy_in_user(&p->l_pad,     &p32->l_pad,    4*sizeof(u32)))
 499                return -EFAULT;
 500
 501        return ioctl_preallocate(file, p);
 502}
 503#endif
 504
 505/*
 506 * simple reversible transform to make our table more evenly
 507 * distributed after sorting.
 508 */
 509#define XFORM(i) (((i) ^ ((i) << 27) ^ ((i) << 17)) & 0xffffffff)
 510
 511#define COMPATIBLE_IOCTL(cmd) XFORM((u32)cmd),
 512/* ioctl should not be warned about even if it's not implemented.
 513   Valid reasons to use this:
 514   - It is implemented with ->compat_ioctl on some device, but programs
 515   call it on others too.
 516   - The ioctl is not implemented in the native kernel, but programs
 517   call it commonly anyways.
 518   Most other reasons are not valid. */
 519#define IGNORE_IOCTL(cmd) COMPATIBLE_IOCTL(cmd)
 520
 521static unsigned int ioctl_pointer[] = {
 522/* compatible ioctls first */
 523/* Little t */
 524COMPATIBLE_IOCTL(TIOCOUTQ)
 525/* Little f */
 526COMPATIBLE_IOCTL(FIOCLEX)
 527COMPATIBLE_IOCTL(FIONCLEX)
 528COMPATIBLE_IOCTL(FIOASYNC)
 529COMPATIBLE_IOCTL(FIONBIO)
 530COMPATIBLE_IOCTL(FIONREAD)  /* This is also TIOCINQ */
 531COMPATIBLE_IOCTL(FS_IOC_FIEMAP)
 532/* 0x00 */
 533COMPATIBLE_IOCTL(FIBMAP)
 534COMPATIBLE_IOCTL(FIGETBSZ)
 535/* 'X' - originally XFS but some now in the VFS */
 536COMPATIBLE_IOCTL(FIFREEZE)
 537COMPATIBLE_IOCTL(FITHAW)
 538COMPATIBLE_IOCTL(FITRIM)
 539#ifdef CONFIG_BLOCK
 540/* Big S */
 541COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN)
 542COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK)
 543COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK)
 544COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY)
 545COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER)
 546COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND)
 547COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST)
 548COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI)
 549#endif
 550/* Big V (don't complain on serial console) */
 551IGNORE_IOCTL(VT_OPENQRY)
 552IGNORE_IOCTL(VT_GETMODE)
 553/* Little p (/dev/rtc, /dev/envctrl, etc.) */
 554COMPATIBLE_IOCTL(RTC_AIE_ON)
 555COMPATIBLE_IOCTL(RTC_AIE_OFF)
 556COMPATIBLE_IOCTL(RTC_UIE_ON)
 557COMPATIBLE_IOCTL(RTC_UIE_OFF)
 558COMPATIBLE_IOCTL(RTC_PIE_ON)
 559COMPATIBLE_IOCTL(RTC_PIE_OFF)
 560COMPATIBLE_IOCTL(RTC_WIE_ON)
 561COMPATIBLE_IOCTL(RTC_WIE_OFF)
 562COMPATIBLE_IOCTL(RTC_ALM_SET)
 563COMPATIBLE_IOCTL(RTC_ALM_READ)
 564COMPATIBLE_IOCTL(RTC_RD_TIME)
 565COMPATIBLE_IOCTL(RTC_SET_TIME)
 566COMPATIBLE_IOCTL(RTC_WKALM_SET)
 567COMPATIBLE_IOCTL(RTC_WKALM_RD)
 568/*
 569 * These two are only for the sbus rtc driver, but
 570 * hwclock tries them on every rtc device first when
 571 * running on sparc.  On other architectures the entries
 572 * are useless but harmless.
 573 */
 574COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
 575COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
 576/* Little m */
 577COMPATIBLE_IOCTL(MTIOCTOP)
 578/* Socket level stuff */
 579COMPATIBLE_IOCTL(FIOQSIZE)
 580#ifdef CONFIG_BLOCK
 581/* md calls this on random blockdevs */
 582IGNORE_IOCTL(RAID_VERSION)
 583/* qemu/qemu-img might call these two on plain files for probing */
 584IGNORE_IOCTL(CDROM_DRIVE_STATUS)
 585IGNORE_IOCTL(FDGETPRM32)
 586/* SG stuff */
 587COMPATIBLE_IOCTL(SG_SET_TIMEOUT)
 588COMPATIBLE_IOCTL(SG_GET_TIMEOUT)
 589COMPATIBLE_IOCTL(SG_EMULATED_HOST)
 590COMPATIBLE_IOCTL(SG_GET_TRANSFORM)
 591COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE)
 592COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE)
 593COMPATIBLE_IOCTL(SG_GET_SCSI_ID)
 594COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA)
 595COMPATIBLE_IOCTL(SG_GET_LOW_DMA)
 596COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID)
 597COMPATIBLE_IOCTL(SG_GET_PACK_ID)
 598COMPATIBLE_IOCTL(SG_GET_NUM_WAITING)
 599COMPATIBLE_IOCTL(SG_SET_DEBUG)
 600COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE)
 601COMPATIBLE_IOCTL(SG_GET_COMMAND_Q)
 602COMPATIBLE_IOCTL(SG_SET_COMMAND_Q)
 603COMPATIBLE_IOCTL(SG_GET_VERSION_NUM)
 604COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN)
 605COMPATIBLE_IOCTL(SG_SCSI_RESET)
 606COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE)
 607COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN)
 608COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN)
 609#endif
 610/* PPP stuff */
 611COMPATIBLE_IOCTL(PPPIOCGFLAGS)
 612COMPATIBLE_IOCTL(PPPIOCSFLAGS)
 613COMPATIBLE_IOCTL(PPPIOCGASYNCMAP)
 614COMPATIBLE_IOCTL(PPPIOCSASYNCMAP)
 615COMPATIBLE_IOCTL(PPPIOCGUNIT)
 616COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP)
 617COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP)
 618COMPATIBLE_IOCTL(PPPIOCGMRU)
 619COMPATIBLE_IOCTL(PPPIOCSMRU)
 620COMPATIBLE_IOCTL(PPPIOCSMAXCID)
 621COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP)
 622COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP)
 623COMPATIBLE_IOCTL(PPPIOCXFERUNIT)
 624/* PPPIOCSCOMPRESS is translated */
 625COMPATIBLE_IOCTL(PPPIOCGNPMODE)
 626COMPATIBLE_IOCTL(PPPIOCSNPMODE)
 627COMPATIBLE_IOCTL(PPPIOCGDEBUG)
 628COMPATIBLE_IOCTL(PPPIOCSDEBUG)
 629/* PPPIOCSPASS is translated */
 630/* PPPIOCSACTIVE is translated */
 631/* PPPIOCGIDLE is translated */
 632COMPATIBLE_IOCTL(PPPIOCNEWUNIT)
 633COMPATIBLE_IOCTL(PPPIOCATTACH)
 634COMPATIBLE_IOCTL(PPPIOCDETACH)
 635COMPATIBLE_IOCTL(PPPIOCSMRRU)
 636COMPATIBLE_IOCTL(PPPIOCCONNECT)
 637COMPATIBLE_IOCTL(PPPIOCDISCONN)
 638COMPATIBLE_IOCTL(PPPIOCATTCHAN)
 639COMPATIBLE_IOCTL(PPPIOCGCHAN)
 640COMPATIBLE_IOCTL(PPPIOCGL2TPSTATS)
 641/* Big A */
 642/* sparc only */
 643/* Big Q for sound/OSS */
 644COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET)
 645COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC)
 646COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO)
 647COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE)
 648COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT)
 649COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT)
 650COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE)
 651COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR)
 652COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI)
 653COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES)
 654COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS)
 655COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS)
 656COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO)
 657COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD)
 658COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL)
 659COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE)
 660COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC)
 661COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND)
 662COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME)
 663COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID)
 664COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL)
 665COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE)
 666/* Big T for sound/OSS */
 667COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE)
 668COMPATIBLE_IOCTL(SNDCTL_TMR_START)
 669COMPATIBLE_IOCTL(SNDCTL_TMR_STOP)
 670COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE)
 671COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO)
 672COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE)
 673COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME)
 674COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT)
 675/* Little m for sound/OSS */
 676COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME)
 677COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE)
 678COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD)
 679/* Big P for sound/OSS */
 680COMPATIBLE_IOCTL(SNDCTL_DSP_RESET)
 681COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC)
 682COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED)
 683COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO)
 684COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE)
 685COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS)
 686COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER)
 687COMPATIBLE_IOCTL(SNDCTL_DSP_POST)
 688COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE)
 689COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT)
 690COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS)
 691COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT)
 692COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE)
 693COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE)
 694COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK)
 695COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS)
 696COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER)
 697COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER)
 698COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR)
 699COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR)
 700/* SNDCTL_DSP_MAPINBUF,  XXX needs translation */
 701/* SNDCTL_DSP_MAPOUTBUF,  XXX needs translation */
 702COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO)
 703COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX)
 704COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY)
 705COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE)
 706COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE)
 707COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS)
 708COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS)
 709COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER)
 710/* Big C for sound/OSS */
 711COMPATIBLE_IOCTL(SNDCTL_COPR_RESET)
 712COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD)
 713COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA)
 714COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE)
 715COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA)
 716COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE)
 717COMPATIBLE_IOCTL(SNDCTL_COPR_RUN)
 718COMPATIBLE_IOCTL(SNDCTL_COPR_HALT)
 719COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG)
 720COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG)
 721/* Big M for sound/OSS */
 722COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME)
 723COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS)
 724COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE)
 725COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH)
 726COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM)
 727COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER)
 728COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE)
 729COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC)
 730COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD)
 731COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX)
 732COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM)
 733COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV)
 734COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN)
 735COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN)
 736COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1)
 737COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2)
 738COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3)
 739COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1))
 740COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2))
 741COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3))
 742COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN))
 743COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT))
 744COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO))
 745COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO))
 746COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR))
 747COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE)
 748/* SOUND_MIXER_READ_ENHANCE,  same value as READ_MUTE */
 749/* SOUND_MIXER_READ_LOUD,  same value as READ_MUTE */
 750COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC)
 751COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK)
 752COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK)
 753COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS)
 754COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS)
 755COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME)
 756COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS)
 757COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE)
 758COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH)
 759COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM)
 760COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER)
 761COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE)
 762COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC)
 763COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD)
 764COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX)
 765COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM)
 766COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV)
 767COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN)
 768COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN)
 769COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1)
 770COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2)
 771COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3)
 772COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1))
 773COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2))
 774COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3))
 775COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN))
 776COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT))
 777COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO))
 778COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO))
 779COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR))
 780COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE)
 781/* SOUND_MIXER_WRITE_ENHANCE,  same value as WRITE_MUTE */
 782/* SOUND_MIXER_WRITE_LOUD,  same value as WRITE_MUTE */
 783COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC)
 784COMPATIBLE_IOCTL(SOUND_MIXER_INFO)
 785COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO)
 786COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS)
 787COMPATIBLE_IOCTL(SOUND_MIXER_AGC)
 788COMPATIBLE_IOCTL(SOUND_MIXER_3DSE)
 789COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1)
 790COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2)
 791COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3)
 792COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4)
 793COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5)
 794COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS)
 795COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS)
 796COMPATIBLE_IOCTL(OSS_GETVERSION)
 797/* Raw devices */
 798COMPATIBLE_IOCTL(RAW_SETBIND)
 799COMPATIBLE_IOCTL(RAW_GETBIND)
 800/* Watchdog */
 801COMPATIBLE_IOCTL(WDIOC_GETSUPPORT)
 802COMPATIBLE_IOCTL(WDIOC_GETSTATUS)
 803COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS)
 804COMPATIBLE_IOCTL(WDIOC_GETTEMP)
 805COMPATIBLE_IOCTL(WDIOC_SETOPTIONS)
 806COMPATIBLE_IOCTL(WDIOC_KEEPALIVE)
 807COMPATIBLE_IOCTL(WDIOC_SETTIMEOUT)
 808COMPATIBLE_IOCTL(WDIOC_GETTIMEOUT)
 809COMPATIBLE_IOCTL(WDIOC_SETPRETIMEOUT)
 810COMPATIBLE_IOCTL(WDIOC_GETPRETIMEOUT)
 811/* Big R */
 812COMPATIBLE_IOCTL(RNDGETENTCNT)
 813COMPATIBLE_IOCTL(RNDADDTOENTCNT)
 814COMPATIBLE_IOCTL(RNDGETPOOL)
 815COMPATIBLE_IOCTL(RNDADDENTROPY)
 816COMPATIBLE_IOCTL(RNDZAPENTCNT)
 817COMPATIBLE_IOCTL(RNDCLEARPOOL)
 818/* Bluetooth */
 819COMPATIBLE_IOCTL(HCIDEVUP)
 820COMPATIBLE_IOCTL(HCIDEVDOWN)
 821COMPATIBLE_IOCTL(HCIDEVRESET)
 822COMPATIBLE_IOCTL(HCIDEVRESTAT)
 823COMPATIBLE_IOCTL(HCIGETDEVLIST)
 824COMPATIBLE_IOCTL(HCIGETDEVINFO)
 825COMPATIBLE_IOCTL(HCIGETCONNLIST)
 826COMPATIBLE_IOCTL(HCIGETCONNINFO)
 827COMPATIBLE_IOCTL(HCIGETAUTHINFO)
 828COMPATIBLE_IOCTL(HCISETRAW)
 829COMPATIBLE_IOCTL(HCISETSCAN)
 830COMPATIBLE_IOCTL(HCISETAUTH)
 831COMPATIBLE_IOCTL(HCISETENCRYPT)
 832COMPATIBLE_IOCTL(HCISETPTYPE)
 833COMPATIBLE_IOCTL(HCISETLINKPOL)
 834COMPATIBLE_IOCTL(HCISETLINKMODE)
 835COMPATIBLE_IOCTL(HCISETACLMTU)
 836COMPATIBLE_IOCTL(HCISETSCOMTU)
 837COMPATIBLE_IOCTL(HCIBLOCKADDR)
 838COMPATIBLE_IOCTL(HCIUNBLOCKADDR)
 839COMPATIBLE_IOCTL(HCIINQUIRY)
 840COMPATIBLE_IOCTL(HCIUARTSETPROTO)
 841COMPATIBLE_IOCTL(HCIUARTGETPROTO)
 842COMPATIBLE_IOCTL(HCIUARTGETDEVICE)
 843COMPATIBLE_IOCTL(HCIUARTSETFLAGS)
 844COMPATIBLE_IOCTL(HCIUARTGETFLAGS)
 845COMPATIBLE_IOCTL(RFCOMMCREATEDEV)
 846COMPATIBLE_IOCTL(RFCOMMRELEASEDEV)
 847COMPATIBLE_IOCTL(RFCOMMGETDEVLIST)
 848COMPATIBLE_IOCTL(RFCOMMGETDEVINFO)
 849COMPATIBLE_IOCTL(RFCOMMSTEALDLC)
 850/* CAPI */
 851COMPATIBLE_IOCTL(CAPI_REGISTER)
 852COMPATIBLE_IOCTL(CAPI_GET_MANUFACTURER)
 853COMPATIBLE_IOCTL(CAPI_GET_VERSION)
 854COMPATIBLE_IOCTL(CAPI_GET_SERIAL)
 855COMPATIBLE_IOCTL(CAPI_GET_PROFILE)
 856COMPATIBLE_IOCTL(CAPI_MANUFACTURER_CMD)
 857COMPATIBLE_IOCTL(CAPI_GET_ERRCODE)
 858COMPATIBLE_IOCTL(CAPI_INSTALLED)
 859COMPATIBLE_IOCTL(CAPI_GET_FLAGS)
 860COMPATIBLE_IOCTL(CAPI_SET_FLAGS)
 861COMPATIBLE_IOCTL(CAPI_CLR_FLAGS)
 862COMPATIBLE_IOCTL(CAPI_NCCI_OPENCOUNT)
 863COMPATIBLE_IOCTL(CAPI_NCCI_GETUNIT)
 864/* Misc. */
 865COMPATIBLE_IOCTL(0x41545900)            /* ATYIO_CLKR */
 866COMPATIBLE_IOCTL(0x41545901)            /* ATYIO_CLKW */
 867COMPATIBLE_IOCTL(PCIIOC_CONTROLLER)
 868COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO)
 869COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM)
 870COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE)
 871/* hiddev */
 872COMPATIBLE_IOCTL(HIDIOCGVERSION)
 873COMPATIBLE_IOCTL(HIDIOCAPPLICATION)
 874COMPATIBLE_IOCTL(HIDIOCGDEVINFO)
 875COMPATIBLE_IOCTL(HIDIOCGSTRING)
 876COMPATIBLE_IOCTL(HIDIOCINITREPORT)
 877COMPATIBLE_IOCTL(HIDIOCGREPORT)
 878COMPATIBLE_IOCTL(HIDIOCSREPORT)
 879COMPATIBLE_IOCTL(HIDIOCGREPORTINFO)
 880COMPATIBLE_IOCTL(HIDIOCGFIELDINFO)
 881COMPATIBLE_IOCTL(HIDIOCGUSAGE)
 882COMPATIBLE_IOCTL(HIDIOCSUSAGE)
 883COMPATIBLE_IOCTL(HIDIOCGUCODE)
 884COMPATIBLE_IOCTL(HIDIOCGFLAG)
 885COMPATIBLE_IOCTL(HIDIOCSFLAG)
 886COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINDEX)
 887COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINFO)
 888/* joystick */
 889COMPATIBLE_IOCTL(JSIOCGVERSION)
 890COMPATIBLE_IOCTL(JSIOCGAXES)
 891COMPATIBLE_IOCTL(JSIOCGBUTTONS)
 892COMPATIBLE_IOCTL(JSIOCGNAME(0))
 893
 894/* fat 'r' ioctls. These are handled by fat with ->compat_ioctl,
 895   but we don't want warnings on other file systems. So declare
 896   them as compatible here. */
 897#define VFAT_IOCTL_READDIR_BOTH32       _IOR('r', 1, struct compat_dirent[2])
 898#define VFAT_IOCTL_READDIR_SHORT32      _IOR('r', 2, struct compat_dirent[2])
 899
 900IGNORE_IOCTL(VFAT_IOCTL_READDIR_BOTH32)
 901IGNORE_IOCTL(VFAT_IOCTL_READDIR_SHORT32)
 902
 903#ifdef CONFIG_SPARC
 904/* Sparc framebuffers, handled in sbusfb_compat_ioctl() */
 905IGNORE_IOCTL(FBIOGTYPE)
 906IGNORE_IOCTL(FBIOSATTR)
 907IGNORE_IOCTL(FBIOGATTR)
 908IGNORE_IOCTL(FBIOSVIDEO)
 909IGNORE_IOCTL(FBIOGVIDEO)
 910IGNORE_IOCTL(FBIOSCURPOS)
 911IGNORE_IOCTL(FBIOGCURPOS)
 912IGNORE_IOCTL(FBIOGCURMAX)
 913IGNORE_IOCTL(FBIOPUTCMAP32)
 914IGNORE_IOCTL(FBIOGETCMAP32)
 915IGNORE_IOCTL(FBIOSCURSOR32)
 916IGNORE_IOCTL(FBIOGCURSOR32)
 917#endif
 918};
 919
 920/*
 921 * Convert common ioctl arguments based on their command number
 922 *
 923 * Please do not add any code in here. Instead, implement
 924 * a compat_ioctl operation in the place that handleѕ the
 925 * ioctl for the native case.
 926 */
 927static long do_ioctl_trans(unsigned int cmd,
 928                 unsigned long arg, struct file *file)
 929{
 930        void __user *argp = compat_ptr(arg);
 931
 932        switch (cmd) {
 933        case PPPIOCGIDLE32:
 934                return ppp_gidle(file, cmd, argp);
 935        case PPPIOCSCOMPRESS32:
 936                return ppp_scompress(file, cmd, argp);
 937        case PPPIOCSPASS32:
 938        case PPPIOCSACTIVE32:
 939                return ppp_sock_fprog_ioctl_trans(file, cmd, argp);
 940#ifdef CONFIG_BLOCK
 941        case SG_IO:
 942                return sg_ioctl_trans(file, cmd, argp);
 943        case SG_GET_REQUEST_TABLE:
 944                return sg_grt_trans(file, cmd, argp);
 945        case MTIOCGET32:
 946        case MTIOCPOS32:
 947                return mt_ioctl_trans(file, cmd, argp);
 948#endif
 949        /* Not implemented in the native kernel */
 950        case RTC_IRQP_READ32:
 951        case RTC_IRQP_SET32:
 952        case RTC_EPOCH_READ32:
 953        case RTC_EPOCH_SET32:
 954                return rtc_ioctl(file, cmd, argp);
 955        }
 956
 957        /*
 958         * These take an integer instead of a pointer as 'arg',
 959         * so we must not do a compat_ptr() translation.
 960         */
 961        switch (cmd) {
 962        /* RAID */
 963        case HOT_REMOVE_DISK:
 964        case HOT_ADD_DISK:
 965        case SET_DISK_FAULTY:
 966        case SET_BITMAP_FILE:
 967                return vfs_ioctl(file, cmd, arg);
 968        }
 969
 970        return -ENOIOCTLCMD;
 971}
 972
 973static int compat_ioctl_check_table(unsigned int xcmd)
 974{
 975        int i;
 976        const int max = ARRAY_SIZE(ioctl_pointer) - 1;
 977
 978        BUILD_BUG_ON(max >= (1 << 16));
 979
 980        /* guess initial offset into table, assuming a
 981           normalized distribution */
 982        i = ((xcmd >> 16) * max) >> 16;
 983
 984        /* do linear search up first, until greater or equal */
 985        while (ioctl_pointer[i] < xcmd && i < max)
 986                i++;
 987
 988        /* then do linear search down */
 989        while (ioctl_pointer[i] > xcmd && i > 0)
 990                i--;
 991
 992        return ioctl_pointer[i] == xcmd;
 993}
 994
 995COMPAT_SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd,
 996                       compat_ulong_t, arg32)
 997{
 998        unsigned long arg = arg32;
 999        struct fd f = fdget(fd);
1000        int error = -EBADF;
1001        if (!f.file)
1002                goto out;
1003
1004        /* RED-PEN how should LSM module know it's handling 32bit? */
1005        error = security_file_ioctl(f.file, cmd, arg);
1006        if (error)
1007                goto out_fput;
1008
1009        /*
1010         * To allow the compat_ioctl handlers to be self contained
1011         * we need to check the common ioctls here first.
1012         * Just handle them with the standard handlers below.
1013         */
1014        switch (cmd) {
1015        case FIOCLEX:
1016        case FIONCLEX:
1017        case FIONBIO:
1018        case FIOASYNC:
1019        case FIOQSIZE:
1020                break;
1021
1022#if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
1023        case FS_IOC_RESVSP_32:
1024        case FS_IOC_RESVSP64_32:
1025                error = compat_ioctl_preallocate(f.file, compat_ptr(arg));
1026                goto out_fput;
1027#else
1028        case FS_IOC_RESVSP:
1029        case FS_IOC_RESVSP64:
1030                error = ioctl_preallocate(f.file, compat_ptr(arg));
1031                goto out_fput;
1032#endif
1033
1034        case FICLONE:
1035        case FICLONERANGE:
1036        case FIDEDUPERANGE:
1037        case FS_IOC_FIEMAP:
1038                goto do_ioctl;
1039
1040        case FIBMAP:
1041        case FIGETBSZ:
1042        case FIONREAD:
1043                if (S_ISREG(file_inode(f.file)->i_mode))
1044                        break;
1045                /*FALL THROUGH*/
1046
1047        default:
1048                if (f.file->f_op->compat_ioctl) {
1049                        error = f.file->f_op->compat_ioctl(f.file, cmd, arg);
1050                        if (error != -ENOIOCTLCMD)
1051                                goto out_fput;
1052                }
1053
1054                if (!f.file->f_op->unlocked_ioctl)
1055                        goto do_ioctl;
1056                break;
1057        }
1058
1059        if (compat_ioctl_check_table(XFORM(cmd)))
1060                goto found_handler;
1061
1062        error = do_ioctl_trans(cmd, arg, f.file);
1063        if (error == -ENOIOCTLCMD)
1064                error = -ENOTTY;
1065
1066        goto out_fput;
1067
1068 found_handler:
1069        arg = (unsigned long)compat_ptr(arg);
1070 do_ioctl:
1071        error = do_vfs_ioctl(f.file, fd, cmd, arg);
1072 out_fput:
1073        fdput(f);
1074 out:
1075        return error;
1076}
1077
1078static int __init init_sys32_ioctl_cmp(const void *p, const void *q)
1079{
1080        unsigned int a, b;
1081        a = *(unsigned int *)p;
1082        b = *(unsigned int *)q;
1083        if (a > b)
1084                return 1;
1085        if (a < b)
1086                return -1;
1087        return 0;
1088}
1089
1090static int __init init_sys32_ioctl(void)
1091{
1092        sort(ioctl_pointer, ARRAY_SIZE(ioctl_pointer), sizeof(*ioctl_pointer),
1093                init_sys32_ioctl_cmp, NULL);
1094        return 0;
1095}
1096__initcall(init_sys32_ioctl);
1097