2 * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
4 * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com)
5 * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
6 * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs
7 * Copyright (C) 2003 Pavel Machek (pavel@suse.cz)
9 * These routines maintain argument size conversion between 32bit and 64bit
13 #include <linux/joystick.h>
15 #include <linux/types.h>
16 #include <linux/compat.h>
17 #include <linux/kernel.h>
18 #include <linux/capability.h>
19 #include <linux/compiler.h>
20 #include <linux/sched.h>
21 #include <linux/smp.h>
22 #include <linux/smp_lock.h>
23 #include <linux/ioctl.h>
25 #include <linux/if_bridge.h>
26 #include <linux/slab.h>
27 #include <linux/raid/md_u.h>
29 #include <linux/route.h>
30 #include <linux/in6.h>
31 #include <linux/ipv6_route.h>
32 #include <linux/skbuff.h>
33 #include <linux/netlink.h>
35 #include <linux/falloc.h>
37 #include <linux/file.h>
38 #include <linux/ppp_defs.h>
39 #include <linux/if_ppp.h>
40 #include <linux/if_pppox.h>
41 #include <linux/mtio.h>
42 #include <linux/auto_fs.h>
43 #include <linux/auto_fs4.h>
44 #include <linux/tty.h>
45 #include <linux/vt_kern.h>
47 #include <linux/videodev.h>
48 #include <linux/netdevice.h>
49 #include <linux/raw.h>
50 #include <linux/smb_fs.h>
51 #include <linux/blkdev.h>
52 #include <linux/elevator.h>
53 #include <linux/rtc.h>
54 #include <linux/pci.h>
55 #include <linux/module.h>
56 #include <linux/serial.h>
57 #include <linux/if_tun.h>
58 #include <linux/ctype.h>
59 #include <linux/syscalls.h>
60 #include <linux/i2c.h>
61 #include <linux/i2c-dev.h>
62 #include <linux/atalk.h>
64 #include <net/bluetooth/bluetooth.h>
65 #include <net/bluetooth/hci.h>
66 #include <net/bluetooth/rfcomm.h>
68 #include <linux/capi.h>
69 #include <linux/gigaset_dev.h>
72 #include <linux/loop.h>
73 #include <scsi/scsi.h>
74 #include <scsi/scsi_ioctl.h>
78 #include <asm/uaccess.h>
79 #include <linux/ethtool.h>
80 #include <linux/mii.h>
81 #include <linux/if_bonding.h>
82 #include <linux/watchdog.h>
84 #include <linux/soundcard.h>
86 #include <linux/ppdev.h>
88 #include <linux/atm.h>
89 #include <linux/atmarp.h>
90 #include <linux/atmclip.h>
91 #include <linux/atmdev.h>
92 #include <linux/atmioc.h>
93 #include <linux/atmlec.h>
94 #include <linux/atmmpc.h>
95 #include <linux/atmsvc.h>
96 #include <linux/atm_tcp.h>
97 #include <linux/sonet.h>
98 #include <linux/atm_suni.h>
100 #include <linux/usb.h>
101 #include <linux/usbdevice_fs.h>
102 #include <linux/nbd.h>
103 #include <linux/random.h>
104 #include <linux/filter.h>
105 #include <linux/pktcdvd.h>
107 #include <linux/hiddev.h>
109 #include <linux/dvb/audio.h>
110 #include <linux/dvb/dmx.h>
111 #include <linux/dvb/frontend.h>
112 #include <linux/dvb/video.h>
115 #include <asm/fbio.h>
118 static int do_ioctl32_pointer(unsigned int fd
, unsigned int cmd
,
119 unsigned long arg
, struct file
*f
)
121 return sys_ioctl(fd
, cmd
, (unsigned long)compat_ptr(arg
));
124 static int w_long(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
126 mm_segment_t old_fs
= get_fs();
131 err
= sys_ioctl(fd
, cmd
, (unsigned long)&val
);
133 if (!err
&& put_user(val
, (u32 __user
*)compat_ptr(arg
)))
138 static int rw_long(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
140 mm_segment_t old_fs
= get_fs();
141 u32 __user
*argptr
= compat_ptr(arg
);
145 if(get_user(val
, argptr
))
148 err
= sys_ioctl(fd
, cmd
, (unsigned long)&val
);
150 if (!err
&& put_user(val
, argptr
))
155 struct compat_video_event
{
157 compat_time_t timestamp
;
160 unsigned int frame_rate
;
164 static int do_video_get_event(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
166 struct video_event kevent
;
167 mm_segment_t old_fs
= get_fs();
171 err
= sys_ioctl(fd
, cmd
, (unsigned long) &kevent
);
175 struct compat_video_event __user
*up
= compat_ptr(arg
);
177 err
= put_user(kevent
.type
, &up
->type
);
178 err
|= put_user(kevent
.timestamp
, &up
->timestamp
);
179 err
|= put_user(kevent
.u
.size
.w
, &up
->u
.size
.w
);
180 err
|= put_user(kevent
.u
.size
.h
, &up
->u
.size
.h
);
181 err
|= put_user(kevent
.u
.size
.aspect_ratio
,
182 &up
->u
.size
.aspect_ratio
);
190 struct compat_video_still_picture
{
191 compat_uptr_t iFrame
;
195 static int do_video_stillpicture(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
197 struct compat_video_still_picture __user
*up
;
198 struct video_still_picture __user
*up_native
;
203 up
= (struct compat_video_still_picture __user
*) arg
;
204 err
= get_user(fp
, &up
->iFrame
);
205 err
|= get_user(size
, &up
->size
);
210 compat_alloc_user_space(sizeof(struct video_still_picture
));
212 err
= put_user(compat_ptr(fp
), &up_native
->iFrame
);
213 err
|= put_user(size
, &up_native
->size
);
217 err
= sys_ioctl(fd
, cmd
, (unsigned long) up_native
);
222 struct compat_video_spu_palette
{
224 compat_uptr_t palette
;
227 static int do_video_set_spu_palette(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
229 struct compat_video_spu_palette __user
*up
;
230 struct video_spu_palette __user
*up_native
;
234 up
= (struct compat_video_spu_palette __user
*) arg
;
235 err
= get_user(palp
, &up
->palette
);
236 err
|= get_user(length
, &up
->length
);
238 up_native
= compat_alloc_user_space(sizeof(struct video_spu_palette
));
239 err
= put_user(compat_ptr(palp
), &up_native
->palette
);
240 err
|= put_user(length
, &up_native
->length
);
244 err
= sys_ioctl(fd
, cmd
, (unsigned long) up_native
);
250 static int do_siocgstamp(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
252 struct compat_timeval __user
*up
= compat_ptr(arg
);
254 mm_segment_t old_fs
= get_fs();
258 err
= sys_ioctl(fd
, cmd
, (unsigned long)&ktv
);
261 err
= put_user(ktv
.tv_sec
, &up
->tv_sec
);
262 err
|= __put_user(ktv
.tv_usec
, &up
->tv_usec
);
267 static int do_siocgstampns(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
269 struct compat_timespec __user
*up
= compat_ptr(arg
);
271 mm_segment_t old_fs
= get_fs();
275 err
= sys_ioctl(fd
, cmd
, (unsigned long)&kts
);
278 err
= put_user(kts
.tv_sec
, &up
->tv_sec
);
279 err
|= __put_user(kts
.tv_nsec
, &up
->tv_nsec
);
285 compat_ulong_t mem_start
;
286 compat_ulong_t mem_end
;
287 unsigned short base_addr
;
294 #define IFHWADDRLEN 6
297 char ifrn_name
[IFNAMSIZ
]; /* if name, e.g. "en0" */
300 struct sockaddr ifru_addr
;
301 struct sockaddr ifru_dstaddr
;
302 struct sockaddr ifru_broadaddr
;
303 struct sockaddr ifru_netmask
;
304 struct sockaddr ifru_hwaddr
;
306 compat_int_t ifru_ivalue
;
307 compat_int_t ifru_mtu
;
308 struct ifmap32 ifru_map
;
309 char ifru_slave
[IFNAMSIZ
]; /* Just fits the size */
310 char ifru_newname
[IFNAMSIZ
];
311 compat_caddr_t ifru_data
;
312 /* XXXX? ifru_settings should be here */
317 compat_int_t ifc_len
; /* size of buffer */
318 compat_caddr_t ifcbuf
;
321 static int dev_ifname32(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
323 struct ifreq __user
*uifr
;
326 uifr
= compat_alloc_user_space(sizeof(struct ifreq
));
327 if (copy_in_user(uifr
, compat_ptr(arg
), sizeof(struct ifreq32
)))
330 err
= sys_ioctl(fd
, SIOCGIFNAME
, (unsigned long)uifr
);
334 if (copy_in_user(compat_ptr(arg
), uifr
, sizeof(struct ifreq32
)))
340 static int dev_ifconf(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
342 struct ifconf32 ifc32
;
344 struct ifconf __user
*uifc
;
345 struct ifreq32 __user
*ifr32
;
346 struct ifreq __user
*ifr
;
350 if (copy_from_user(&ifc32
, compat_ptr(arg
), sizeof(struct ifconf32
)))
353 if (ifc32
.ifcbuf
== 0) {
357 uifc
= compat_alloc_user_space(sizeof(struct ifconf
));
359 size_t len
=((ifc32
.ifc_len
/ sizeof (struct ifreq32
)) + 1) *
360 sizeof (struct ifreq
);
361 uifc
= compat_alloc_user_space(sizeof(struct ifconf
) + len
);
363 ifr
= ifc
.ifc_req
= (void __user
*)(uifc
+ 1);
364 ifr32
= compat_ptr(ifc32
.ifcbuf
);
365 for (i
= 0; i
< ifc32
.ifc_len
; i
+= sizeof (struct ifreq32
)) {
366 if (copy_in_user(ifr
, ifr32
, sizeof(struct ifreq32
)))
372 if (copy_to_user(uifc
, &ifc
, sizeof(struct ifconf
)))
375 err
= sys_ioctl (fd
, SIOCGIFCONF
, (unsigned long)uifc
);
379 if (copy_from_user(&ifc
, uifc
, sizeof(struct ifconf
)))
383 ifr32
= compat_ptr(ifc32
.ifcbuf
);
385 i
+ sizeof (struct ifreq32
) <= ifc32
.ifc_len
&& j
< ifc
.ifc_len
;
386 i
+= sizeof (struct ifreq32
), j
+= sizeof (struct ifreq
)) {
387 if (copy_in_user(ifr32
, ifr
, sizeof (struct ifreq32
)))
393 if (ifc32
.ifcbuf
== 0) {
394 /* Translate from 64-bit structure multiple to
398 i
= ((i
/ sizeof(struct ifreq
)) * sizeof(struct ifreq32
));
403 if (copy_to_user(compat_ptr(arg
), &ifc32
, sizeof(struct ifconf32
)))
409 static int ethtool_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
411 struct ifreq __user
*ifr
;
412 struct ifreq32 __user
*ifr32
;
416 ifr
= compat_alloc_user_space(sizeof(*ifr
));
417 ifr32
= compat_ptr(arg
);
419 if (copy_in_user(&ifr
->ifr_name
, &ifr32
->ifr_name
, IFNAMSIZ
))
422 if (get_user(data
, &ifr32
->ifr_ifru
.ifru_data
))
425 datap
= compat_ptr(data
);
426 if (put_user(datap
, &ifr
->ifr_ifru
.ifru_data
))
429 return sys_ioctl(fd
, cmd
, (unsigned long) ifr
);
432 static int bond_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
435 struct ifreq __user
*uifr
;
436 struct ifreq32 __user
*ifr32
= compat_ptr(arg
);
443 case SIOCBONDENSLAVE
:
444 case SIOCBONDRELEASE
:
445 case SIOCBONDSETHWADDR
:
446 case SIOCBONDCHANGEACTIVE
:
447 if (copy_from_user(&kifr
, ifr32
, sizeof(struct ifreq32
)))
452 err
= sys_ioctl (fd
, cmd
, (unsigned long)&kifr
);
456 case SIOCBONDSLAVEINFOQUERY
:
457 case SIOCBONDINFOQUERY
:
458 uifr
= compat_alloc_user_space(sizeof(*uifr
));
459 if (copy_in_user(&uifr
->ifr_name
, &ifr32
->ifr_name
, IFNAMSIZ
))
462 if (get_user(data
, &ifr32
->ifr_ifru
.ifru_data
))
465 datap
= compat_ptr(data
);
466 if (put_user(datap
, &uifr
->ifr_ifru
.ifru_data
))
469 return sys_ioctl (fd
, cmd
, (unsigned long)uifr
);
475 static int siocdevprivate_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
477 struct ifreq __user
*u_ifreq64
;
478 struct ifreq32 __user
*u_ifreq32
= compat_ptr(arg
);
479 char tmp_buf
[IFNAMSIZ
];
483 if (copy_from_user(&tmp_buf
[0], &(u_ifreq32
->ifr_ifrn
.ifrn_name
[0]),
486 if (__get_user(data32
, &u_ifreq32
->ifr_ifru
.ifru_data
))
488 data64
= compat_ptr(data32
);
490 u_ifreq64
= compat_alloc_user_space(sizeof(*u_ifreq64
));
492 /* Don't check these user accesses, just let that get trapped
493 * in the ioctl handler instead.
495 if (copy_to_user(&u_ifreq64
->ifr_ifrn
.ifrn_name
[0], &tmp_buf
[0],
498 if (__put_user(data64
, &u_ifreq64
->ifr_ifru
.ifru_data
))
501 return sys_ioctl(fd
, cmd
, (unsigned long) u_ifreq64
);
504 static int dev_ifsioc(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
507 struct ifreq32 __user
*uifr32
;
508 struct ifmap32 __user
*uifmap32
;
512 uifr32
= compat_ptr(arg
);
513 uifmap32
= &uifr32
->ifr_ifru
.ifru_map
;
516 err
= copy_from_user(&ifr
, uifr32
, sizeof(ifr
.ifr_name
));
517 err
|= __get_user(ifr
.ifr_map
.mem_start
, &uifmap32
->mem_start
);
518 err
|= __get_user(ifr
.ifr_map
.mem_end
, &uifmap32
->mem_end
);
519 err
|= __get_user(ifr
.ifr_map
.base_addr
, &uifmap32
->base_addr
);
520 err
|= __get_user(ifr
.ifr_map
.irq
, &uifmap32
->irq
);
521 err
|= __get_user(ifr
.ifr_map
.dma
, &uifmap32
->dma
);
522 err
|= __get_user(ifr
.ifr_map
.port
, &uifmap32
->port
);
527 if (copy_from_user(&ifr
, uifr32
, sizeof(*uifr32
)))
529 ifr
.ifr_data
= compat_ptr(uifr32
->ifr_ifru
.ifru_data
);
532 if (copy_from_user(&ifr
, uifr32
, sizeof(*uifr32
)))
538 err
= sys_ioctl (fd
, cmd
, (unsigned long)&ifr
);
542 /* TUNSETIFF is defined as _IOW, it should be _IORW
543 * as the data is copied back to user space, but that
544 * cannot be fixed without breaking all existing apps.
559 if (copy_to_user(uifr32
, &ifr
, sizeof(*uifr32
)))
563 err
= copy_to_user(uifr32
, &ifr
, sizeof(ifr
.ifr_name
));
564 err
|= __put_user(ifr
.ifr_map
.mem_start
, &uifmap32
->mem_start
);
565 err
|= __put_user(ifr
.ifr_map
.mem_end
, &uifmap32
->mem_end
);
566 err
|= __put_user(ifr
.ifr_map
.base_addr
, &uifmap32
->base_addr
);
567 err
|= __put_user(ifr
.ifr_map
.irq
, &uifmap32
->irq
);
568 err
|= __put_user(ifr
.ifr_map
.dma
, &uifmap32
->dma
);
569 err
|= __put_user(ifr
.ifr_map
.port
, &uifmap32
->port
);
580 struct sockaddr rt_dst
; /* target address */
581 struct sockaddr rt_gateway
; /* gateway addr (RTF_GATEWAY) */
582 struct sockaddr rt_genmask
; /* target network mask (IP) */
583 unsigned short rt_flags
;
586 unsigned char rt_tos
;
587 unsigned char rt_class
;
589 short rt_metric
; /* +1 for binary compatibility! */
590 /* char * */ u32 rt_dev
; /* forcing the device at add */
591 u32 rt_mtu
; /* per route MTU/Window */
592 u32 rt_window
; /* Window clamping */
593 unsigned short rt_irtt
; /* Initial RTT */
598 struct in6_addr rtmsg_dst
;
599 struct in6_addr rtmsg_src
;
600 struct in6_addr rtmsg_gateway
;
610 static int routing_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
618 mm_segment_t old_fs
= get_fs();
620 struct socket
*mysock
= sockfd_lookup(fd
, &ret
);
622 if (mysock
&& mysock
->sk
&& mysock
->sk
->sk_family
== AF_INET6
) { /* ipv6 */
623 struct in6_rtmsg32 __user
*ur6
= compat_ptr(arg
);
624 ret
= copy_from_user (&r6
.rtmsg_dst
, &(ur6
->rtmsg_dst
),
625 3 * sizeof(struct in6_addr
));
626 ret
|= __get_user (r6
.rtmsg_type
, &(ur6
->rtmsg_type
));
627 ret
|= __get_user (r6
.rtmsg_dst_len
, &(ur6
->rtmsg_dst_len
));
628 ret
|= __get_user (r6
.rtmsg_src_len
, &(ur6
->rtmsg_src_len
));
629 ret
|= __get_user (r6
.rtmsg_metric
, &(ur6
->rtmsg_metric
));
630 ret
|= __get_user (r6
.rtmsg_info
, &(ur6
->rtmsg_info
));
631 ret
|= __get_user (r6
.rtmsg_flags
, &(ur6
->rtmsg_flags
));
632 ret
|= __get_user (r6
.rtmsg_ifindex
, &(ur6
->rtmsg_ifindex
));
636 struct rtentry32 __user
*ur4
= compat_ptr(arg
);
637 ret
= copy_from_user (&r4
.rt_dst
, &(ur4
->rt_dst
),
638 3 * sizeof(struct sockaddr
));
639 ret
|= __get_user (r4
.rt_flags
, &(ur4
->rt_flags
));
640 ret
|= __get_user (r4
.rt_metric
, &(ur4
->rt_metric
));
641 ret
|= __get_user (r4
.rt_mtu
, &(ur4
->rt_mtu
));
642 ret
|= __get_user (r4
.rt_window
, &(ur4
->rt_window
));
643 ret
|= __get_user (r4
.rt_irtt
, &(ur4
->rt_irtt
));
644 ret
|= __get_user (rtdev
, &(ur4
->rt_dev
));
646 ret
|= copy_from_user (devname
, compat_ptr(rtdev
), 15);
647 r4
.rt_dev
= devname
; devname
[15] = 0;
660 ret
= sys_ioctl (fd
, cmd
, (unsigned long) r
);
672 typedef struct sg_io_hdr32
{
673 compat_int_t interface_id
; /* [i] 'S' for SCSI generic (required) */
674 compat_int_t dxfer_direction
; /* [i] data transfer direction */
675 unsigned char cmd_len
; /* [i] SCSI command length ( <= 16 bytes) */
676 unsigned char mx_sb_len
; /* [i] max length to write to sbp */
677 unsigned short iovec_count
; /* [i] 0 implies no scatter gather */
678 compat_uint_t dxfer_len
; /* [i] byte count of data transfer */
679 compat_uint_t dxferp
; /* [i], [*io] points to data transfer memory
680 or scatter gather list */
681 compat_uptr_t cmdp
; /* [i], [*i] points to command to perform */
682 compat_uptr_t sbp
; /* [i], [*o] points to sense_buffer memory */
683 compat_uint_t timeout
; /* [i] MAX_UINT->no timeout (unit: millisec) */
684 compat_uint_t flags
; /* [i] 0 -> default, see SG_FLAG... */
685 compat_int_t pack_id
; /* [i->o] unused internally (normally) */
686 compat_uptr_t usr_ptr
; /* [i->o] unused internally */
687 unsigned char status
; /* [o] scsi status */
688 unsigned char masked_status
; /* [o] shifted, masked scsi status */
689 unsigned char msg_status
; /* [o] messaging level data (optional) */
690 unsigned char sb_len_wr
; /* [o] byte count actually written to sbp */
691 unsigned short host_status
; /* [o] errors from host adapter */
692 unsigned short driver_status
; /* [o] errors from software driver */
693 compat_int_t resid
; /* [o] dxfer_len - actual_transferred */
694 compat_uint_t duration
; /* [o] time taken by cmd (unit: millisec) */
695 compat_uint_t info
; /* [o] auxiliary information */
696 } sg_io_hdr32_t
; /* 64 bytes long (on sparc32) */
698 typedef struct sg_iovec32
{
699 compat_uint_t iov_base
;
700 compat_uint_t iov_len
;
703 static int sg_build_iovec(sg_io_hdr_t __user
*sgio
, void __user
*dxferp
, u16 iovec_count
)
705 sg_iovec_t __user
*iov
= (sg_iovec_t __user
*) (sgio
+ 1);
706 sg_iovec32_t __user
*iov32
= dxferp
;
709 for (i
= 0; i
< iovec_count
; i
++) {
712 if (get_user(base
, &iov32
[i
].iov_base
) ||
713 get_user(len
, &iov32
[i
].iov_len
) ||
714 put_user(compat_ptr(base
), &iov
[i
].iov_base
) ||
715 put_user(len
, &iov
[i
].iov_len
))
719 if (put_user(iov
, &sgio
->dxferp
))
724 static int sg_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
726 sg_io_hdr_t __user
*sgio
;
727 sg_io_hdr32_t __user
*sgio32
;
733 sgio32
= compat_ptr(arg
);
734 if (get_user(iovec_count
, &sgio32
->iovec_count
))
738 void __user
*top
= compat_alloc_user_space(0);
739 void __user
*new = compat_alloc_user_space(sizeof(sg_io_hdr_t
) +
740 (iovec_count
* sizeof(sg_iovec_t
)));
747 /* Ok, now construct. */
748 if (copy_in_user(&sgio
->interface_id
, &sgio32
->interface_id
,
750 (2 * sizeof(unsigned char)) +
751 (1 * sizeof(unsigned short)) +
752 (1 * sizeof(unsigned int))))
755 if (get_user(data
, &sgio32
->dxferp
))
757 dxferp
= compat_ptr(data
);
759 if (sg_build_iovec(sgio
, dxferp
, iovec_count
))
762 if (put_user(dxferp
, &sgio
->dxferp
))
767 unsigned char __user
*cmdp
;
768 unsigned char __user
*sbp
;
770 if (get_user(data
, &sgio32
->cmdp
))
772 cmdp
= compat_ptr(data
);
774 if (get_user(data
, &sgio32
->sbp
))
776 sbp
= compat_ptr(data
);
778 if (put_user(cmdp
, &sgio
->cmdp
) ||
779 put_user(sbp
, &sgio
->sbp
))
783 if (copy_in_user(&sgio
->timeout
, &sgio32
->timeout
,
787 if (get_user(data
, &sgio32
->usr_ptr
))
789 if (put_user(compat_ptr(data
), &sgio
->usr_ptr
))
792 err
= sys_ioctl(fd
, cmd
, (unsigned long) sgio
);
797 if (copy_in_user(&sgio32
->pack_id
, &sgio
->pack_id
,
799 get_user(datap
, &sgio
->usr_ptr
) ||
800 put_user((u32
)(unsigned long)datap
,
802 copy_in_user(&sgio32
->status
, &sgio
->status
,
803 (4 * sizeof(unsigned char)) +
804 (2 * sizeof(unsigned short)) +
812 struct compat_sg_req_info
{ /* used by SG_GET_REQUEST_TABLE ioctl() */
818 compat_uptr_t usr_ptr
;
819 unsigned int duration
;
823 static int sg_grt_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
826 sg_req_info_t __user
*r
;
827 struct compat_sg_req_info __user
*o
= (void __user
*)arg
;
828 r
= compat_alloc_user_space(sizeof(sg_req_info_t
)*SG_MAX_QUEUE
);
829 err
= sys_ioctl(fd
,cmd
,(unsigned long)r
);
832 for (i
= 0; i
< SG_MAX_QUEUE
; i
++) {
836 if (copy_in_user(o
+ i
, r
+ i
, offsetof(sg_req_info_t
, usr_ptr
)) ||
837 get_user(ptr
, &r
[i
].usr_ptr
) ||
838 get_user(d
, &r
[i
].duration
) ||
839 put_user((u32
)(unsigned long)(ptr
), &o
[i
].usr_ptr
) ||
840 put_user(d
, &o
[i
].duration
))
845 #endif /* CONFIG_BLOCK */
847 struct sock_fprog32
{
849 compat_caddr_t filter
;
852 #define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
853 #define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
855 static int ppp_sock_fprog_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
857 struct sock_fprog32 __user
*u_fprog32
= compat_ptr(arg
);
858 struct sock_fprog __user
*u_fprog64
= compat_alloc_user_space(sizeof(struct sock_fprog
));
863 if (get_user(flen
, &u_fprog32
->len
) ||
864 get_user(fptr32
, &u_fprog32
->filter
))
867 fptr64
= compat_ptr(fptr32
);
869 if (put_user(flen
, &u_fprog64
->len
) ||
870 put_user(fptr64
, &u_fprog64
->filter
))
873 if (cmd
== PPPIOCSPASS32
)
878 return sys_ioctl(fd
, cmd
, (unsigned long) u_fprog64
);
881 struct ppp_option_data32
{
884 compat_int_t transmit
;
886 #define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
889 compat_time_t xmit_idle
;
890 compat_time_t recv_idle
;
892 #define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
894 static int ppp_gidle(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
896 struct ppp_idle __user
*idle
;
897 struct ppp_idle32 __user
*idle32
;
898 __kernel_time_t xmit
, recv
;
901 idle
= compat_alloc_user_space(sizeof(*idle
));
902 idle32
= compat_ptr(arg
);
904 err
= sys_ioctl(fd
, PPPIOCGIDLE
, (unsigned long) idle
);
907 if (get_user(xmit
, &idle
->xmit_idle
) ||
908 get_user(recv
, &idle
->recv_idle
) ||
909 put_user(xmit
, &idle32
->xmit_idle
) ||
910 put_user(recv
, &idle32
->recv_idle
))
916 static int ppp_scompress(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
918 struct ppp_option_data __user
*odata
;
919 struct ppp_option_data32 __user
*odata32
;
923 odata
= compat_alloc_user_space(sizeof(*odata
));
924 odata32
= compat_ptr(arg
);
926 if (get_user(data
, &odata32
->ptr
))
929 datap
= compat_ptr(data
);
930 if (put_user(datap
, &odata
->ptr
))
933 if (copy_in_user(&odata
->length
, &odata32
->length
,
934 sizeof(__u32
) + sizeof(int)))
937 return sys_ioctl(fd
, PPPIOCSCOMPRESS
, (unsigned long) odata
);
940 static int ppp_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
946 err
= ppp_gidle(fd
, cmd
, arg
);
949 case PPPIOCSCOMPRESS32
:
950 err
= ppp_scompress(fd
, cmd
, arg
);
957 printk("ppp_ioctl: Unknown cmd fd(%d) "
958 "cmd(%08x) arg(%08x)\n",
959 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
971 compat_long_t mt_type
;
972 compat_long_t mt_resid
;
973 compat_long_t mt_dsreg
;
974 compat_long_t mt_gstat
;
975 compat_long_t mt_erreg
;
976 compat_daddr_t mt_fileno
;
977 compat_daddr_t mt_blkno
;
979 #define MTIOCGET32 _IOR('m', 2, struct mtget32)
982 compat_long_t mt_blkno
;
984 #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
986 static int mt_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
988 mm_segment_t old_fs
= get_fs();
990 struct mtget32 __user
*umget32
;
992 struct mtpos32 __user
*upos32
;
1010 printk("mt_ioctl: Unknown cmd fd(%d) "
1011 "cmd(%08x) arg(%08x)\n",
1012 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1017 err
= sys_ioctl (fd
, kcmd
, (unsigned long)karg
);
1023 upos32
= compat_ptr(arg
);
1024 err
= __put_user(pos
.mt_blkno
, &upos32
->mt_blkno
);
1027 umget32
= compat_ptr(arg
);
1028 err
= __put_user(get
.mt_type
, &umget32
->mt_type
);
1029 err
|= __put_user(get
.mt_resid
, &umget32
->mt_resid
);
1030 err
|= __put_user(get
.mt_dsreg
, &umget32
->mt_dsreg
);
1031 err
|= __put_user(get
.mt_gstat
, &umget32
->mt_gstat
);
1032 err
|= __put_user(get
.mt_erreg
, &umget32
->mt_erreg
);
1033 err
|= __put_user(get
.mt_fileno
, &umget32
->mt_fileno
);
1034 err
|= __put_user(get
.mt_blkno
, &umget32
->mt_blkno
);
1037 return err
? -EFAULT
: 0;
1040 #endif /* CONFIG_BLOCK */
1044 static int vt_check(struct file
*file
)
1046 struct tty_struct
*tty
;
1047 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1050 if (file
->f_op
->unlocked_ioctl
!= tty_ioctl
)
1053 tty
= (struct tty_struct
*)file
->private_data
;
1054 if (tty_paranoia_check(tty
, inode
, "tty_ioctl"))
1057 if (tty
->ops
->ioctl
!= vt_ioctl
)
1060 vc
= (struct vc_data
*)tty
->driver_data
;
1061 if (!vc_cons_allocated(vc
->vc_num
)) /* impossible? */
1062 return -ENOIOCTLCMD
;
1065 * To have permissions to do most of the vt ioctls, we either have
1066 * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
1068 if (current
->signal
->tty
== tty
|| capable(CAP_SYS_TTY_CONFIG
))
1073 struct consolefontdesc32
{
1074 unsigned short charcount
; /* characters in font (256 or 512) */
1075 unsigned short charheight
; /* scan lines per character (1-32) */
1076 compat_caddr_t chardata
; /* font data in expanded form */
1079 static int do_fontx_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1081 struct consolefontdesc32 __user
*user_cfd
= compat_ptr(arg
);
1082 struct console_font_op op
;
1083 compat_caddr_t data
;
1086 perm
= vt_check(file
);
1087 if (perm
< 0) return perm
;
1093 op
.op
= KD_FONT_OP_SET
;
1096 if (get_user(op
.height
, &user_cfd
->charheight
) ||
1097 get_user(op
.charcount
, &user_cfd
->charcount
) ||
1098 get_user(data
, &user_cfd
->chardata
))
1100 op
.data
= compat_ptr(data
);
1101 return con_font_op(vc_cons
[fg_console
].d
, &op
);
1103 op
.op
= KD_FONT_OP_GET
;
1106 if (get_user(op
.height
, &user_cfd
->charheight
) ||
1107 get_user(op
.charcount
, &user_cfd
->charcount
) ||
1108 get_user(data
, &user_cfd
->chardata
))
1112 op
.data
= compat_ptr(data
);
1113 i
= con_font_op(vc_cons
[fg_console
].d
, &op
);
1116 if (put_user(op
.height
, &user_cfd
->charheight
) ||
1117 put_user(op
.charcount
, &user_cfd
->charcount
) ||
1118 put_user((compat_caddr_t
)(unsigned long)op
.data
,
1119 &user_cfd
->chardata
))
1126 struct console_font_op32
{
1127 compat_uint_t op
; /* operation code KD_FONT_OP_* */
1128 compat_uint_t flags
; /* KD_FONT_FLAG_* */
1129 compat_uint_t width
, height
; /* font size */
1130 compat_uint_t charcount
;
1131 compat_caddr_t data
; /* font data with height fixed to 32 */
1134 static int do_kdfontop_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1136 struct console_font_op op
;
1137 struct console_font_op32 __user
*fontop
= compat_ptr(arg
);
1138 int perm
= vt_check(file
), i
;
1141 if (perm
< 0) return perm
;
1143 if (copy_from_user(&op
, fontop
, sizeof(struct console_font_op32
)))
1145 if (!perm
&& op
.op
!= KD_FONT_OP_GET
)
1147 op
.data
= compat_ptr(((struct console_font_op32
*)&op
)->data
);
1148 op
.flags
|= KD_FONT_FLAG_OLD
;
1149 vc
= ((struct tty_struct
*)file
->private_data
)->driver_data
;
1150 i
= con_font_op(vc
, &op
);
1153 ((struct console_font_op32
*)&op
)->data
= (unsigned long)op
.data
;
1154 if (copy_to_user(fontop
, &op
, sizeof(struct console_font_op32
)))
1159 struct unimapdesc32
{
1160 unsigned short entry_ct
;
1161 compat_caddr_t entries
;
1164 static int do_unimap_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1166 struct unimapdesc32 tmp
;
1167 struct unimapdesc32 __user
*user_ud
= compat_ptr(arg
);
1168 int perm
= vt_check(file
);
1173 if (copy_from_user(&tmp
, user_ud
, sizeof tmp
))
1176 if (!access_ok(VERIFY_WRITE
, compat_ptr(tmp
.entries
),
1177 tmp
.entry_ct
*sizeof(struct unipair
)))
1179 vc
= ((struct tty_struct
*)file
->private_data
)->driver_data
;
1184 return con_set_unimap(vc
, tmp
.entry_ct
,
1185 compat_ptr(tmp
.entries
));
1187 if (!perm
&& fg_console
!= vc
->vc_num
)
1189 return con_get_unimap(vc
, tmp
.entry_ct
, &(user_ud
->entry_ct
),
1190 compat_ptr(tmp
.entries
));
1195 #endif /* CONFIG_VT */
1197 static int do_smb_getmountuid(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1199 mm_segment_t old_fs
= get_fs();
1200 __kernel_uid_t kuid
;
1203 cmd
= SMB_IOC_GETMOUNTUID
;
1206 err
= sys_ioctl(fd
, cmd
, (unsigned long)&kuid
);
1210 err
= put_user(kuid
, (compat_uid_t __user
*)compat_ptr(arg
));
1215 struct atmif_sioc32
{
1216 compat_int_t number
;
1217 compat_int_t length
;
1221 struct atm_iobuf32
{
1222 compat_int_t length
;
1223 compat_caddr_t buffer
;
1226 #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
1227 #define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
1228 #define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
1229 #define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
1230 #define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
1231 #define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
1232 #define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
1233 #define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
1234 #define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
1235 #define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
1236 #define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
1237 #define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
1238 #define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
1239 #define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
1240 #define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
1241 #define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
1242 #define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
1247 } atm_ioctl_map
[] = {
1248 { ATM_GETLINKRATE32
, ATM_GETLINKRATE
},
1249 { ATM_GETNAMES32
, ATM_GETNAMES
},
1250 { ATM_GETTYPE32
, ATM_GETTYPE
},
1251 { ATM_GETESI32
, ATM_GETESI
},
1252 { ATM_GETADDR32
, ATM_GETADDR
},
1253 { ATM_RSTADDR32
, ATM_RSTADDR
},
1254 { ATM_ADDADDR32
, ATM_ADDADDR
},
1255 { ATM_DELADDR32
, ATM_DELADDR
},
1256 { ATM_GETCIRANGE32
, ATM_GETCIRANGE
},
1257 { ATM_SETCIRANGE32
, ATM_SETCIRANGE
},
1258 { ATM_SETESI32
, ATM_SETESI
},
1259 { ATM_SETESIF32
, ATM_SETESIF
},
1260 { ATM_GETSTAT32
, ATM_GETSTAT
},
1261 { ATM_GETSTATZ32
, ATM_GETSTATZ
},
1262 { ATM_GETLOOP32
, ATM_GETLOOP
},
1263 { ATM_SETLOOP32
, ATM_SETLOOP
},
1264 { ATM_QUERYLOOP32
, ATM_QUERYLOOP
}
1267 #define NR_ATM_IOCTL ARRAY_SIZE(atm_ioctl_map)
1269 static int do_atm_iobuf(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1271 struct atm_iobuf __user
*iobuf
;
1272 struct atm_iobuf32 __user
*iobuf32
;
1277 iobuf
= compat_alloc_user_space(sizeof(*iobuf
));
1278 iobuf32
= compat_ptr(arg
);
1280 if (get_user(len
, &iobuf32
->length
) ||
1281 get_user(data
, &iobuf32
->buffer
))
1283 datap
= compat_ptr(data
);
1284 if (put_user(len
, &iobuf
->length
) ||
1285 put_user(datap
, &iobuf
->buffer
))
1288 err
= sys_ioctl(fd
, cmd
, (unsigned long)iobuf
);
1291 if (copy_in_user(&iobuf32
->length
, &iobuf
->length
,
1299 static int do_atmif_sioc(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1301 struct atmif_sioc __user
*sioc
;
1302 struct atmif_sioc32 __user
*sioc32
;
1307 sioc
= compat_alloc_user_space(sizeof(*sioc
));
1308 sioc32
= compat_ptr(arg
);
1310 if (copy_in_user(&sioc
->number
, &sioc32
->number
, 2 * sizeof(int)) ||
1311 get_user(data
, &sioc32
->arg
))
1313 datap
= compat_ptr(data
);
1314 if (put_user(datap
, &sioc
->arg
))
1317 err
= sys_ioctl(fd
, cmd
, (unsigned long) sioc
);
1320 if (copy_in_user(&sioc32
->length
, &sioc
->length
,
1327 static int do_atm_ioctl(unsigned int fd
, unsigned int cmd32
, unsigned long arg
)
1330 unsigned int cmd
= 0;
1334 case SONET_GETSTATZ
:
1338 case SONET_SETFRAMING
:
1339 case SONET_GETFRAMING
:
1340 case SONET_GETFRSENSE
:
1341 return do_atmif_sioc(fd
, cmd32
, arg
);
1344 for (i
= 0; i
< NR_ATM_IOCTL
; i
++) {
1345 if (cmd32
== atm_ioctl_map
[i
].cmd32
) {
1346 cmd
= atm_ioctl_map
[i
].cmd
;
1350 if (i
== NR_ATM_IOCTL
)
1355 return do_atm_iobuf(fd
, cmd
, arg
);
1357 case ATM_GETLINKRATE
:
1364 case ATM_GETCIRANGE
:
1365 case ATM_SETCIRANGE
:
1373 return do_atmif_sioc(fd
, cmd
, arg
);
1380 ret_einval(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1385 static int ioc_settimeout(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1387 return rw_long(fd
, AUTOFS_IOC_SETTIMEOUT
, arg
);
1390 /* Bluetooth ioctls */
1391 #define HCIUARTSETPROTO _IOW('U', 200, int)
1392 #define HCIUARTGETPROTO _IOR('U', 201, int)
1394 #define BNEPCONNADD _IOW('B', 200, int)
1395 #define BNEPCONNDEL _IOW('B', 201, int)
1396 #define BNEPGETCONNLIST _IOR('B', 210, int)
1397 #define BNEPGETCONNINFO _IOR('B', 211, int)
1399 #define CMTPCONNADD _IOW('C', 200, int)
1400 #define CMTPCONNDEL _IOW('C', 201, int)
1401 #define CMTPGETCONNLIST _IOR('C', 210, int)
1402 #define CMTPGETCONNINFO _IOR('C', 211, int)
1404 #define HIDPCONNADD _IOW('H', 200, int)
1405 #define HIDPCONNDEL _IOW('H', 201, int)
1406 #define HIDPGETCONNLIST _IOR('H', 210, int)
1407 #define HIDPGETCONNINFO _IOR('H', 211, int)
1409 struct serial_struct32
{
1415 compat_int_t xmit_fifo_size
;
1416 compat_int_t custom_divisor
;
1417 compat_int_t baud_base
;
1418 unsigned short close_delay
;
1420 char reserved_char
[1];
1422 unsigned short closing_wait
; /* time to wait before closing */
1423 unsigned short closing_wait2
; /* no longer used... */
1424 compat_uint_t iomem_base
;
1425 unsigned short iomem_reg_shift
;
1426 unsigned int port_high
;
1427 /* compat_ulong_t iomap_base FIXME */
1428 compat_int_t reserved
[1];
1431 static int serial_struct_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
1433 typedef struct serial_struct SS
;
1434 typedef struct serial_struct32 SS32
;
1435 struct serial_struct32 __user
*ss32
= compat_ptr(arg
);
1437 struct serial_struct ss
;
1438 mm_segment_t oldseg
= get_fs();
1442 if (cmd
== TIOCSSERIAL
) {
1443 if (!access_ok(VERIFY_READ
, ss32
, sizeof(SS32
)))
1445 if (__copy_from_user(&ss
, ss32
, offsetof(SS32
, iomem_base
)))
1447 if (__get_user(udata
, &ss32
->iomem_base
))
1449 ss
.iomem_base
= compat_ptr(udata
);
1450 if (__get_user(ss
.iomem_reg_shift
, &ss32
->iomem_reg_shift
) ||
1451 __get_user(ss
.port_high
, &ss32
->port_high
))
1453 ss
.iomap_base
= 0UL;
1456 err
= sys_ioctl(fd
,cmd
,(unsigned long)(&ss
));
1458 if (cmd
== TIOCGSERIAL
&& err
>= 0) {
1459 if (!access_ok(VERIFY_WRITE
, ss32
, sizeof(SS32
)))
1461 if (__copy_to_user(ss32
,&ss
,offsetof(SS32
,iomem_base
)))
1463 base
= (unsigned long)ss
.iomem_base
>> 32 ?
1464 0xffffffff : (unsigned)(unsigned long)ss
.iomem_base
;
1465 if (__put_user(base
, &ss32
->iomem_base
) ||
1466 __put_user(ss
.iomem_reg_shift
, &ss32
->iomem_reg_shift
) ||
1467 __put_user(ss
.port_high
, &ss32
->port_high
))
1473 struct usbdevfs_ctrltransfer32
{
1479 u32 timeout
; /* in milliseconds */
1480 compat_caddr_t data
;
1483 #define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
1485 static int do_usbdevfs_control(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1487 struct usbdevfs_ctrltransfer32 __user
*p32
= compat_ptr(arg
);
1488 struct usbdevfs_ctrltransfer __user
*p
;
1490 p
= compat_alloc_user_space(sizeof(*p
));
1491 if (copy_in_user(p
, p32
, (sizeof(*p32
) - sizeof(compat_caddr_t
))) ||
1492 get_user(udata
, &p32
->data
) ||
1493 put_user(compat_ptr(udata
), &p
->data
))
1495 return sys_ioctl(fd
, USBDEVFS_CONTROL
, (unsigned long)p
);
1499 struct usbdevfs_bulktransfer32
{
1502 compat_uint_t timeout
; /* in milliseconds */
1503 compat_caddr_t data
;
1506 #define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
1508 static int do_usbdevfs_bulk(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1510 struct usbdevfs_bulktransfer32 __user
*p32
= compat_ptr(arg
);
1511 struct usbdevfs_bulktransfer __user
*p
;
1513 compat_caddr_t addr
;
1515 p
= compat_alloc_user_space(sizeof(*p
));
1517 if (get_user(n
, &p32
->ep
) || put_user(n
, &p
->ep
) ||
1518 get_user(n
, &p32
->len
) || put_user(n
, &p
->len
) ||
1519 get_user(n
, &p32
->timeout
) || put_user(n
, &p
->timeout
) ||
1520 get_user(addr
, &p32
->data
) || put_user(compat_ptr(addr
), &p
->data
))
1523 return sys_ioctl(fd
, USBDEVFS_BULK
, (unsigned long)p
);
1528 * USBDEVFS_SUBMITURB, USBDEVFS_REAPURB and USBDEVFS_REAPURBNDELAY
1529 * are handled in usbdevfs core. -Christopher Li
1532 struct usbdevfs_disconnectsignal32
{
1534 compat_caddr_t context
;
1537 #define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
1539 static int do_usbdevfs_discsignal(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1541 struct usbdevfs_disconnectsignal kdis
;
1542 struct usbdevfs_disconnectsignal32 __user
*udis
;
1543 mm_segment_t old_fs
;
1547 udis
= compat_ptr(arg
);
1549 if (get_user(kdis
.signr
, &udis
->signr
) ||
1550 __get_user(uctx
, &udis
->context
))
1553 kdis
.context
= compat_ptr(uctx
);
1557 err
= sys_ioctl(fd
, USBDEVFS_DISCSIGNAL
, (unsigned long) &kdis
);
1574 struct i2c_rdwr_ioctl_data32
{
1575 compat_caddr_t msgs
; /* struct i2c_msg __user *msgs */
1579 struct i2c_smbus_ioctl_data32
{
1583 compat_caddr_t data
; /* union i2c_smbus_data *data */
1586 struct i2c_rdwr_aligned
{
1587 struct i2c_rdwr_ioctl_data cmd
;
1588 struct i2c_msg msgs
[0];
1591 static int do_i2c_rdwr_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1593 struct i2c_rdwr_ioctl_data32 __user
*udata
= compat_ptr(arg
);
1594 struct i2c_rdwr_aligned __user
*tdata
;
1595 struct i2c_msg __user
*tmsgs
;
1596 struct i2c_msg32 __user
*umsgs
;
1597 compat_caddr_t datap
;
1600 if (get_user(nmsgs
, &udata
->nmsgs
))
1602 if (nmsgs
> I2C_RDRW_IOCTL_MAX_MSGS
)
1605 if (get_user(datap
, &udata
->msgs
))
1607 umsgs
= compat_ptr(datap
);
1609 tdata
= compat_alloc_user_space(sizeof(*tdata
) +
1610 nmsgs
* sizeof(struct i2c_msg
));
1611 tmsgs
= &tdata
->msgs
[0];
1613 if (put_user(nmsgs
, &tdata
->cmd
.nmsgs
) ||
1614 put_user(tmsgs
, &tdata
->cmd
.msgs
))
1617 for (i
= 0; i
< nmsgs
; i
++) {
1618 if (copy_in_user(&tmsgs
[i
].addr
, &umsgs
[i
].addr
, 3*sizeof(u16
)))
1620 if (get_user(datap
, &umsgs
[i
].buf
) ||
1621 put_user(compat_ptr(datap
), &tmsgs
[i
].buf
))
1624 return sys_ioctl(fd
, cmd
, (unsigned long)tdata
);
1627 static int do_i2c_smbus_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1629 struct i2c_smbus_ioctl_data __user
*tdata
;
1630 struct i2c_smbus_ioctl_data32 __user
*udata
;
1631 compat_caddr_t datap
;
1633 tdata
= compat_alloc_user_space(sizeof(*tdata
));
1636 if (!access_ok(VERIFY_WRITE
, tdata
, sizeof(*tdata
)))
1639 udata
= compat_ptr(arg
);
1640 if (!access_ok(VERIFY_READ
, udata
, sizeof(*udata
)))
1643 if (__copy_in_user(&tdata
->read_write
, &udata
->read_write
, 2 * sizeof(u8
)))
1645 if (__copy_in_user(&tdata
->size
, &udata
->size
, 2 * sizeof(u32
)))
1647 if (__get_user(datap
, &udata
->data
) ||
1648 __put_user(compat_ptr(datap
), &tdata
->data
))
1651 return sys_ioctl(fd
, cmd
, (unsigned long)tdata
);
1654 /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
1655 * for some operations; this forces use of the newer bridge-utils that
1656 * use compatible ioctls
1658 static int old_bridge_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1662 if (get_user(tmp
, (u32 __user
*) arg
))
1664 if (tmp
== BRCTL_GET_VERSION
)
1665 return BRCTL_VERSION
+ 1;
1669 #define RTC_IRQP_READ32 _IOR('p', 0x0b, compat_ulong_t)
1670 #define RTC_IRQP_SET32 _IOW('p', 0x0c, compat_ulong_t)
1671 #define RTC_EPOCH_READ32 _IOR('p', 0x0d, compat_ulong_t)
1672 #define RTC_EPOCH_SET32 _IOW('p', 0x0e, compat_ulong_t)
1674 static int rtc_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
1676 mm_segment_t oldfs
= get_fs();
1677 compat_ulong_t val32
;
1682 case RTC_IRQP_READ32
:
1683 case RTC_EPOCH_READ32
:
1685 ret
= sys_ioctl(fd
, (cmd
== RTC_IRQP_READ32
) ?
1686 RTC_IRQP_READ
: RTC_EPOCH_READ
,
1687 (unsigned long)&kval
);
1692 return put_user(val32
, (unsigned int __user
*)arg
);
1693 case RTC_IRQP_SET32
:
1694 return sys_ioctl(fd
, RTC_IRQP_SET
, arg
);
1695 case RTC_EPOCH_SET32
:
1696 return sys_ioctl(fd
, RTC_EPOCH_SET
, arg
);
1699 return -ENOIOCTLCMD
;
1704 lp_timeout_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1706 struct compat_timeval __user
*tc
= (struct compat_timeval __user
*)arg
;
1707 struct timeval __user
*tn
= compat_alloc_user_space(sizeof(struct timeval
));
1709 if (get_user(ts
.tv_sec
, &tc
->tv_sec
) ||
1710 get_user(ts
.tv_usec
, &tc
->tv_usec
) ||
1711 put_user(ts
.tv_sec
, &tn
->tv_sec
) ||
1712 put_user(ts
.tv_usec
, &tn
->tv_usec
))
1714 return sys_ioctl(fd
, cmd
, (unsigned long)tn
);
1717 /* on ia32 l_start is on a 32-bit boundary */
1718 #if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
1719 struct space_resv_32
{
1722 __s64 l_start
__attribute__((packed
));
1723 /* len == 0 means until end of file */
1724 __s64 l_len
__attribute__((packed
));
1727 __s32 l_pad
[4]; /* reserve area */
1730 #define FS_IOC_RESVSP_32 _IOW ('X', 40, struct space_resv_32)
1731 #define FS_IOC_RESVSP64_32 _IOW ('X', 42, struct space_resv_32)
1733 /* just account for different alignment */
1734 static int compat_ioctl_preallocate(struct file
*file
, unsigned long arg
)
1736 struct space_resv_32 __user
*p32
= (void __user
*)arg
;
1737 struct space_resv __user
*p
= compat_alloc_user_space(sizeof(*p
));
1739 if (copy_in_user(&p
->l_type
, &p32
->l_type
, sizeof(s16
)) ||
1740 copy_in_user(&p
->l_whence
, &p32
->l_whence
, sizeof(s16
)) ||
1741 copy_in_user(&p
->l_start
, &p32
->l_start
, sizeof(s64
)) ||
1742 copy_in_user(&p
->l_len
, &p32
->l_len
, sizeof(s64
)) ||
1743 copy_in_user(&p
->l_sysid
, &p32
->l_sysid
, sizeof(s32
)) ||
1744 copy_in_user(&p
->l_pid
, &p32
->l_pid
, sizeof(u32
)) ||
1745 copy_in_user(&p
->l_pad
, &p32
->l_pad
, 4*sizeof(u32
)))
1748 return ioctl_preallocate(file
, p
);
1753 typedef int (*ioctl_trans_handler_t
)(unsigned int, unsigned int,
1754 unsigned long, struct file
*);
1756 struct ioctl_trans
{
1758 ioctl_trans_handler_t handler
;
1759 struct ioctl_trans
*next
;
1762 #define HANDLE_IOCTL(cmd,handler) \
1763 { (cmd), (ioctl_trans_handler_t)(handler) },
1765 /* pointer to compatible structure or no argument */
1766 #define COMPATIBLE_IOCTL(cmd) \
1767 { (cmd), do_ioctl32_pointer },
1769 /* argument is an unsigned long integer, not a pointer */
1770 #define ULONG_IOCTL(cmd) \
1771 { (cmd), (ioctl_trans_handler_t)sys_ioctl },
1773 /* ioctl should not be warned about even if it's not implemented.
1774 Valid reasons to use this:
1775 - It is implemented with ->compat_ioctl on some device, but programs
1776 call it on others too.
1777 - The ioctl is not implemented in the native kernel, but programs
1778 call it commonly anyways.
1779 Most other reasons are not valid. */
1780 #define IGNORE_IOCTL(cmd) COMPATIBLE_IOCTL(cmd)
1782 static struct ioctl_trans ioctl_start
[] = {
1783 /* compatible ioctls first */
1784 COMPATIBLE_IOCTL(0x4B50) /* KDGHWCLK - not in the kernel, but don't complain */
1785 COMPATIBLE_IOCTL(0x4B51) /* KDSHWCLK - not in the kernel, but don't complain */
1788 COMPATIBLE_IOCTL(TCGETA
)
1789 COMPATIBLE_IOCTL(TCSETA
)
1790 COMPATIBLE_IOCTL(TCSETAW
)
1791 COMPATIBLE_IOCTL(TCSETAF
)
1792 COMPATIBLE_IOCTL(TCSBRK
)
1793 ULONG_IOCTL(TCSBRKP
)
1794 COMPATIBLE_IOCTL(TCXONC
)
1795 COMPATIBLE_IOCTL(TCFLSH
)
1796 COMPATIBLE_IOCTL(TCGETS
)
1797 COMPATIBLE_IOCTL(TCSETS
)
1798 COMPATIBLE_IOCTL(TCSETSW
)
1799 COMPATIBLE_IOCTL(TCSETSF
)
1800 COMPATIBLE_IOCTL(TIOCLINUX
)
1801 COMPATIBLE_IOCTL(TIOCSBRK
)
1802 COMPATIBLE_IOCTL(TIOCCBRK
)
1803 ULONG_IOCTL(TIOCMIWAIT
)
1804 COMPATIBLE_IOCTL(TIOCGICOUNT
)
1806 COMPATIBLE_IOCTL(TIOCGETD
)
1807 COMPATIBLE_IOCTL(TIOCSETD
)
1808 COMPATIBLE_IOCTL(TIOCEXCL
)
1809 COMPATIBLE_IOCTL(TIOCNXCL
)
1810 COMPATIBLE_IOCTL(TIOCCONS
)
1811 COMPATIBLE_IOCTL(TIOCGSOFTCAR
)
1812 COMPATIBLE_IOCTL(TIOCSSOFTCAR
)
1813 COMPATIBLE_IOCTL(TIOCSWINSZ
)
1814 COMPATIBLE_IOCTL(TIOCGWINSZ
)
1815 COMPATIBLE_IOCTL(TIOCMGET
)
1816 COMPATIBLE_IOCTL(TIOCMBIC
)
1817 COMPATIBLE_IOCTL(TIOCMBIS
)
1818 COMPATIBLE_IOCTL(TIOCMSET
)
1819 COMPATIBLE_IOCTL(TIOCPKT
)
1820 COMPATIBLE_IOCTL(TIOCNOTTY
)
1821 COMPATIBLE_IOCTL(TIOCSTI
)
1822 COMPATIBLE_IOCTL(TIOCOUTQ
)
1823 COMPATIBLE_IOCTL(TIOCSPGRP
)
1824 COMPATIBLE_IOCTL(TIOCGPGRP
)
1825 ULONG_IOCTL(TIOCSCTTY
)
1826 COMPATIBLE_IOCTL(TIOCGPTN
)
1827 COMPATIBLE_IOCTL(TIOCSPTLCK
)
1828 COMPATIBLE_IOCTL(TIOCSERGETLSR
)
1830 COMPATIBLE_IOCTL(TCGETS2
)
1831 COMPATIBLE_IOCTL(TCSETS2
)
1832 COMPATIBLE_IOCTL(TCSETSW2
)
1833 COMPATIBLE_IOCTL(TCSETSF2
)
1836 COMPATIBLE_IOCTL(FIOCLEX
)
1837 COMPATIBLE_IOCTL(FIONCLEX
)
1838 COMPATIBLE_IOCTL(FIOASYNC
)
1839 COMPATIBLE_IOCTL(FIONBIO
)
1840 COMPATIBLE_IOCTL(FIONREAD
) /* This is also TIOCINQ */
1841 COMPATIBLE_IOCTL(FS_IOC_FIEMAP
)
1843 COMPATIBLE_IOCTL(FIBMAP
)
1844 COMPATIBLE_IOCTL(FIGETBSZ
)
1845 /* 'X' - originally XFS but some now in the VFS */
1846 COMPATIBLE_IOCTL(FIFREEZE
)
1847 COMPATIBLE_IOCTL(FITHAW
)
1849 COMPATIBLE_IOCTL(RAID_VERSION
)
1850 COMPATIBLE_IOCTL(GET_ARRAY_INFO
)
1851 COMPATIBLE_IOCTL(GET_DISK_INFO
)
1852 COMPATIBLE_IOCTL(PRINT_RAID_DEBUG
)
1853 COMPATIBLE_IOCTL(RAID_AUTORUN
)
1854 COMPATIBLE_IOCTL(CLEAR_ARRAY
)
1855 COMPATIBLE_IOCTL(ADD_NEW_DISK
)
1856 ULONG_IOCTL(HOT_REMOVE_DISK
)
1857 COMPATIBLE_IOCTL(SET_ARRAY_INFO
)
1858 COMPATIBLE_IOCTL(SET_DISK_INFO
)
1859 COMPATIBLE_IOCTL(WRITE_RAID_INFO
)
1860 COMPATIBLE_IOCTL(UNPROTECT_ARRAY
)
1861 COMPATIBLE_IOCTL(PROTECT_ARRAY
)
1862 ULONG_IOCTL(HOT_ADD_DISK
)
1863 ULONG_IOCTL(SET_DISK_FAULTY
)
1864 COMPATIBLE_IOCTL(RUN_ARRAY
)
1865 COMPATIBLE_IOCTL(STOP_ARRAY
)
1866 COMPATIBLE_IOCTL(STOP_ARRAY_RO
)
1867 COMPATIBLE_IOCTL(RESTART_ARRAY_RW
)
1868 COMPATIBLE_IOCTL(GET_BITMAP_FILE
)
1869 ULONG_IOCTL(SET_BITMAP_FILE
)
1871 COMPATIBLE_IOCTL(PIO_FONT
)
1872 COMPATIBLE_IOCTL(GIO_FONT
)
1873 COMPATIBLE_IOCTL(PIO_CMAP
)
1874 COMPATIBLE_IOCTL(GIO_CMAP
)
1875 ULONG_IOCTL(KDSIGACCEPT
)
1876 COMPATIBLE_IOCTL(KDGETKEYCODE
)
1877 COMPATIBLE_IOCTL(KDSETKEYCODE
)
1878 ULONG_IOCTL(KIOCSOUND
)
1879 ULONG_IOCTL(KDMKTONE
)
1880 COMPATIBLE_IOCTL(KDGKBTYPE
)
1881 ULONG_IOCTL(KDSETMODE
)
1882 COMPATIBLE_IOCTL(KDGETMODE
)
1883 ULONG_IOCTL(KDSKBMODE
)
1884 COMPATIBLE_IOCTL(KDGKBMODE
)
1885 ULONG_IOCTL(KDSKBMETA
)
1886 COMPATIBLE_IOCTL(KDGKBMETA
)
1887 COMPATIBLE_IOCTL(KDGKBENT
)
1888 COMPATIBLE_IOCTL(KDSKBENT
)
1889 COMPATIBLE_IOCTL(KDGKBSENT
)
1890 COMPATIBLE_IOCTL(KDSKBSENT
)
1891 COMPATIBLE_IOCTL(KDGKBDIACR
)
1892 COMPATIBLE_IOCTL(KDSKBDIACR
)
1893 COMPATIBLE_IOCTL(KDKBDREP
)
1894 COMPATIBLE_IOCTL(KDGKBLED
)
1895 ULONG_IOCTL(KDSKBLED
)
1896 COMPATIBLE_IOCTL(KDGETLED
)
1897 ULONG_IOCTL(KDSETLED
)
1898 COMPATIBLE_IOCTL(GIO_SCRNMAP
)
1899 COMPATIBLE_IOCTL(PIO_SCRNMAP
)
1900 COMPATIBLE_IOCTL(GIO_UNISCRNMAP
)
1901 COMPATIBLE_IOCTL(PIO_UNISCRNMAP
)
1902 COMPATIBLE_IOCTL(PIO_FONTRESET
)
1903 COMPATIBLE_IOCTL(PIO_UNIMAPCLR
)
1906 COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN
)
1907 COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK
)
1908 COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK
)
1909 COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY
)
1910 COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER
)
1911 COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND
)
1912 COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST
)
1913 COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI
)
1916 COMPATIBLE_IOCTL(TUNSETNOCSUM
)
1917 COMPATIBLE_IOCTL(TUNSETDEBUG
)
1918 COMPATIBLE_IOCTL(TUNSETPERSIST
)
1919 COMPATIBLE_IOCTL(TUNSETOWNER
)
1920 COMPATIBLE_IOCTL(TUNSETLINK
)
1921 COMPATIBLE_IOCTL(TUNSETGROUP
)
1922 COMPATIBLE_IOCTL(TUNGETFEATURES
)
1923 COMPATIBLE_IOCTL(TUNSETOFFLOAD
)
1924 COMPATIBLE_IOCTL(TUNSETTXFILTER
)
1925 COMPATIBLE_IOCTL(TUNGETSNDBUF
)
1926 COMPATIBLE_IOCTL(TUNSETSNDBUF
)
1928 COMPATIBLE_IOCTL(VT_SETMODE
)
1929 COMPATIBLE_IOCTL(VT_GETMODE
)
1930 COMPATIBLE_IOCTL(VT_GETSTATE
)
1931 COMPATIBLE_IOCTL(VT_OPENQRY
)
1932 ULONG_IOCTL(VT_ACTIVATE
)
1933 ULONG_IOCTL(VT_WAITACTIVE
)
1934 ULONG_IOCTL(VT_RELDISP
)
1935 ULONG_IOCTL(VT_DISALLOCATE
)
1936 COMPATIBLE_IOCTL(VT_RESIZE
)
1937 COMPATIBLE_IOCTL(VT_RESIZEX
)
1938 COMPATIBLE_IOCTL(VT_LOCKSWITCH
)
1939 COMPATIBLE_IOCTL(VT_UNLOCKSWITCH
)
1940 COMPATIBLE_IOCTL(VT_GETHIFONTMASK
)
1941 /* Little p (/dev/rtc, /dev/envctrl, etc.) */
1942 COMPATIBLE_IOCTL(RTC_AIE_ON
)
1943 COMPATIBLE_IOCTL(RTC_AIE_OFF
)
1944 COMPATIBLE_IOCTL(RTC_UIE_ON
)
1945 COMPATIBLE_IOCTL(RTC_UIE_OFF
)
1946 COMPATIBLE_IOCTL(RTC_PIE_ON
)
1947 COMPATIBLE_IOCTL(RTC_PIE_OFF
)
1948 COMPATIBLE_IOCTL(RTC_WIE_ON
)
1949 COMPATIBLE_IOCTL(RTC_WIE_OFF
)
1950 COMPATIBLE_IOCTL(RTC_ALM_SET
)
1951 COMPATIBLE_IOCTL(RTC_ALM_READ
)
1952 COMPATIBLE_IOCTL(RTC_RD_TIME
)
1953 COMPATIBLE_IOCTL(RTC_SET_TIME
)
1954 COMPATIBLE_IOCTL(RTC_WKALM_SET
)
1955 COMPATIBLE_IOCTL(RTC_WKALM_RD
)
1957 * These two are only for the sbus rtc driver, but
1958 * hwclock tries them on every rtc device first when
1959 * running on sparc. On other architectures the entries
1960 * are useless but harmless.
1962 COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
1963 COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
1965 COMPATIBLE_IOCTL(MTIOCTOP
)
1966 /* Socket level stuff */
1967 COMPATIBLE_IOCTL(FIOQSIZE
)
1968 COMPATIBLE_IOCTL(FIOSETOWN
)
1969 COMPATIBLE_IOCTL(SIOCSPGRP
)
1970 COMPATIBLE_IOCTL(FIOGETOWN
)
1971 COMPATIBLE_IOCTL(SIOCGPGRP
)
1972 COMPATIBLE_IOCTL(SIOCATMARK
)
1973 COMPATIBLE_IOCTL(SIOCSIFLINK
)
1974 COMPATIBLE_IOCTL(SIOCSIFENCAP
)
1975 COMPATIBLE_IOCTL(SIOCGIFENCAP
)
1976 COMPATIBLE_IOCTL(SIOCSIFNAME
)
1977 COMPATIBLE_IOCTL(SIOCSARP
)
1978 COMPATIBLE_IOCTL(SIOCGARP
)
1979 COMPATIBLE_IOCTL(SIOCDARP
)
1980 COMPATIBLE_IOCTL(SIOCSRARP
)
1981 COMPATIBLE_IOCTL(SIOCGRARP
)
1982 COMPATIBLE_IOCTL(SIOCDRARP
)
1983 COMPATIBLE_IOCTL(SIOCADDDLCI
)
1984 COMPATIBLE_IOCTL(SIOCDELDLCI
)
1985 COMPATIBLE_IOCTL(SIOCGMIIPHY
)
1986 COMPATIBLE_IOCTL(SIOCGMIIREG
)
1987 COMPATIBLE_IOCTL(SIOCSMIIREG
)
1988 COMPATIBLE_IOCTL(SIOCGIFVLAN
)
1989 COMPATIBLE_IOCTL(SIOCSIFVLAN
)
1990 COMPATIBLE_IOCTL(SIOCBRADDBR
)
1991 COMPATIBLE_IOCTL(SIOCBRDELBR
)
1994 COMPATIBLE_IOCTL(SG_SET_TIMEOUT
)
1995 COMPATIBLE_IOCTL(SG_GET_TIMEOUT
)
1996 COMPATIBLE_IOCTL(SG_EMULATED_HOST
)
1997 ULONG_IOCTL(SG_SET_TRANSFORM
)
1998 COMPATIBLE_IOCTL(SG_GET_TRANSFORM
)
1999 COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE
)
2000 COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE
)
2001 COMPATIBLE_IOCTL(SG_GET_SCSI_ID
)
2002 COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA
)
2003 COMPATIBLE_IOCTL(SG_GET_LOW_DMA
)
2004 COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID
)
2005 COMPATIBLE_IOCTL(SG_GET_PACK_ID
)
2006 COMPATIBLE_IOCTL(SG_GET_NUM_WAITING
)
2007 COMPATIBLE_IOCTL(SG_SET_DEBUG
)
2008 COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE
)
2009 COMPATIBLE_IOCTL(SG_GET_COMMAND_Q
)
2010 COMPATIBLE_IOCTL(SG_SET_COMMAND_Q
)
2011 COMPATIBLE_IOCTL(SG_GET_VERSION_NUM
)
2012 COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN
)
2013 COMPATIBLE_IOCTL(SG_SCSI_RESET
)
2014 COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE
)
2015 COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN
)
2016 COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN
)
2019 COMPATIBLE_IOCTL(PPPIOCGFLAGS
)
2020 COMPATIBLE_IOCTL(PPPIOCSFLAGS
)
2021 COMPATIBLE_IOCTL(PPPIOCGASYNCMAP
)
2022 COMPATIBLE_IOCTL(PPPIOCSASYNCMAP
)
2023 COMPATIBLE_IOCTL(PPPIOCGUNIT
)
2024 COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP
)
2025 COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP
)
2026 COMPATIBLE_IOCTL(PPPIOCGMRU
)
2027 COMPATIBLE_IOCTL(PPPIOCSMRU
)
2028 COMPATIBLE_IOCTL(PPPIOCSMAXCID
)
2029 COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP
)
2030 COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP
)
2031 COMPATIBLE_IOCTL(PPPIOCXFERUNIT
)
2032 /* PPPIOCSCOMPRESS is translated */
2033 COMPATIBLE_IOCTL(PPPIOCGNPMODE
)
2034 COMPATIBLE_IOCTL(PPPIOCSNPMODE
)
2035 COMPATIBLE_IOCTL(PPPIOCGDEBUG
)
2036 COMPATIBLE_IOCTL(PPPIOCSDEBUG
)
2037 /* PPPIOCSPASS is translated */
2038 /* PPPIOCSACTIVE is translated */
2039 /* PPPIOCGIDLE is translated */
2040 COMPATIBLE_IOCTL(PPPIOCNEWUNIT
)
2041 COMPATIBLE_IOCTL(PPPIOCATTACH
)
2042 COMPATIBLE_IOCTL(PPPIOCDETACH
)
2043 COMPATIBLE_IOCTL(PPPIOCSMRRU
)
2044 COMPATIBLE_IOCTL(PPPIOCCONNECT
)
2045 COMPATIBLE_IOCTL(PPPIOCDISCONN
)
2046 COMPATIBLE_IOCTL(PPPIOCATTCHAN
)
2047 COMPATIBLE_IOCTL(PPPIOCGCHAN
)
2049 COMPATIBLE_IOCTL(PPPOEIOCSFWD
)
2050 COMPATIBLE_IOCTL(PPPOEIOCDFWD
)
2052 COMPATIBLE_IOCTL(LPGETSTATUS
)
2054 COMPATIBLE_IOCTL(PPSETMODE
)
2055 COMPATIBLE_IOCTL(PPRSTATUS
)
2056 COMPATIBLE_IOCTL(PPRCONTROL
)
2057 COMPATIBLE_IOCTL(PPWCONTROL
)
2058 COMPATIBLE_IOCTL(PPFCONTROL
)
2059 COMPATIBLE_IOCTL(PPRDATA
)
2060 COMPATIBLE_IOCTL(PPWDATA
)
2061 COMPATIBLE_IOCTL(PPCLAIM
)
2062 COMPATIBLE_IOCTL(PPRELEASE
)
2063 COMPATIBLE_IOCTL(PPYIELD
)
2064 COMPATIBLE_IOCTL(PPEXCL
)
2065 COMPATIBLE_IOCTL(PPDATADIR
)
2066 COMPATIBLE_IOCTL(PPNEGOT
)
2067 COMPATIBLE_IOCTL(PPWCTLONIRQ
)
2068 COMPATIBLE_IOCTL(PPCLRIRQ
)
2069 COMPATIBLE_IOCTL(PPSETPHASE
)
2070 COMPATIBLE_IOCTL(PPGETMODES
)
2071 COMPATIBLE_IOCTL(PPGETMODE
)
2072 COMPATIBLE_IOCTL(PPGETPHASE
)
2073 COMPATIBLE_IOCTL(PPGETFLAGS
)
2074 COMPATIBLE_IOCTL(PPSETFLAGS
)
2076 COMPATIBLE_IOCTL(PACKET_CTRL_CMD
)
2079 /* Big Q for sound/OSS */
2080 COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET
)
2081 COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC
)
2082 COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO
)
2083 COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE
)
2084 COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT
)
2085 COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT
)
2086 COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE
)
2087 COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR
)
2088 COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI
)
2089 COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES
)
2090 COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS
)
2091 COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS
)
2092 COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO
)
2093 COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD
)
2094 COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL
)
2095 COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE
)
2096 COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC
)
2097 COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND
)
2098 COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME
)
2099 COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID
)
2100 COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL
)
2101 COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE
)
2102 /* Big T for sound/OSS */
2103 COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE
)
2104 COMPATIBLE_IOCTL(SNDCTL_TMR_START
)
2105 COMPATIBLE_IOCTL(SNDCTL_TMR_STOP
)
2106 COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE
)
2107 COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO
)
2108 COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE
)
2109 COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME
)
2110 COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT
)
2111 /* Little m for sound/OSS */
2112 COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME
)
2113 COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE
)
2114 COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD
)
2115 /* Big P for sound/OSS */
2116 COMPATIBLE_IOCTL(SNDCTL_DSP_RESET
)
2117 COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC
)
2118 COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED
)
2119 COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO
)
2120 COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE
)
2121 COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS
)
2122 COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER
)
2123 COMPATIBLE_IOCTL(SNDCTL_DSP_POST
)
2124 COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE
)
2125 COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT
)
2126 COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS
)
2127 COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT
)
2128 COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE
)
2129 COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE
)
2130 COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK
)
2131 COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS
)
2132 COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER
)
2133 COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER
)
2134 COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR
)
2135 COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR
)
2136 /* SNDCTL_DSP_MAPINBUF, XXX needs translation */
2137 /* SNDCTL_DSP_MAPOUTBUF, XXX needs translation */
2138 COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO
)
2139 COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX
)
2140 COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY
)
2141 COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE
)
2142 COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE
)
2143 COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS
)
2144 COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS
)
2145 COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER
)
2146 /* Big C for sound/OSS */
2147 COMPATIBLE_IOCTL(SNDCTL_COPR_RESET
)
2148 COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD
)
2149 COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA
)
2150 COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE
)
2151 COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA
)
2152 COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE
)
2153 COMPATIBLE_IOCTL(SNDCTL_COPR_RUN
)
2154 COMPATIBLE_IOCTL(SNDCTL_COPR_HALT
)
2155 COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG
)
2156 COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG
)
2157 /* Big M for sound/OSS */
2158 COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME
)
2159 COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS
)
2160 COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE
)
2161 COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH
)
2162 COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM
)
2163 COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER
)
2164 COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE
)
2165 COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC
)
2166 COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD
)
2167 COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX
)
2168 COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM
)
2169 COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV
)
2170 COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN
)
2171 COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN
)
2172 COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1
)
2173 COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2
)
2174 COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3
)
2175 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1
))
2176 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2
))
2177 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3
))
2178 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN
))
2179 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT
))
2180 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO
))
2181 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO
))
2182 COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR
))
2183 COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE
)
2184 /* SOUND_MIXER_READ_ENHANCE, same value as READ_MUTE */
2185 /* SOUND_MIXER_READ_LOUD, same value as READ_MUTE */
2186 COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC
)
2187 COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK
)
2188 COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK
)
2189 COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS
)
2190 COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS
)
2191 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME
)
2192 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS
)
2193 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE
)
2194 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH
)
2195 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM
)
2196 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER
)
2197 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE
)
2198 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC
)
2199 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD
)
2200 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX
)
2201 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM
)
2202 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV
)
2203 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN
)
2204 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN
)
2205 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1
)
2206 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2
)
2207 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3
)
2208 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1
))
2209 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2
))
2210 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3
))
2211 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN
))
2212 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT
))
2213 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO
))
2214 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO
))
2215 COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR
))
2216 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE
)
2217 /* SOUND_MIXER_WRITE_ENHANCE, same value as WRITE_MUTE */
2218 /* SOUND_MIXER_WRITE_LOUD, same value as WRITE_MUTE */
2219 COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC
)
2220 COMPATIBLE_IOCTL(SOUND_MIXER_INFO
)
2221 COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO
)
2222 COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS
)
2223 COMPATIBLE_IOCTL(SOUND_MIXER_AGC
)
2224 COMPATIBLE_IOCTL(SOUND_MIXER_3DSE
)
2225 COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1
)
2226 COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2
)
2227 COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3
)
2228 COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4
)
2229 COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5
)
2230 COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS
)
2231 COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS
)
2232 COMPATIBLE_IOCTL(OSS_GETVERSION
)
2234 ULONG_IOCTL(AUTOFS_IOC_READY
)
2235 ULONG_IOCTL(AUTOFS_IOC_FAIL
)
2236 COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC
)
2237 COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER
)
2238 COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE
)
2239 COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI
)
2240 COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOSUBVER
)
2241 COMPATIBLE_IOCTL(AUTOFS_IOC_ASKUMOUNT
)
2242 /* SMB ioctls which do not need any translations */
2243 COMPATIBLE_IOCTL(SMB_IOC_NEWCONN
)
2245 COMPATIBLE_IOCTL(ATMSIGD_CTRL
)
2246 COMPATIBLE_IOCTL(ATMARPD_CTRL
)
2247 COMPATIBLE_IOCTL(ATMLEC_CTRL
)
2248 COMPATIBLE_IOCTL(ATMLEC_MCAST
)
2249 COMPATIBLE_IOCTL(ATMLEC_DATA
)
2250 COMPATIBLE_IOCTL(ATM_SETSC
)
2251 COMPATIBLE_IOCTL(SIOCSIFATMTCP
)
2252 COMPATIBLE_IOCTL(SIOCMKCLIP
)
2253 COMPATIBLE_IOCTL(ATMARP_MKIP
)
2254 COMPATIBLE_IOCTL(ATMARP_SETENTRY
)
2255 COMPATIBLE_IOCTL(ATMARP_ENCAP
)
2256 COMPATIBLE_IOCTL(ATMTCP_CREATE
)
2257 COMPATIBLE_IOCTL(ATMTCP_REMOVE
)
2258 COMPATIBLE_IOCTL(ATMMPC_CTRL
)
2259 COMPATIBLE_IOCTL(ATMMPC_DATA
)
2261 COMPATIBLE_IOCTL(WDIOC_GETSUPPORT
)
2262 COMPATIBLE_IOCTL(WDIOC_GETSTATUS
)
2263 COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS
)
2264 COMPATIBLE_IOCTL(WDIOC_GETTEMP
)
2265 COMPATIBLE_IOCTL(WDIOC_SETOPTIONS
)
2266 COMPATIBLE_IOCTL(WDIOC_KEEPALIVE
)
2267 COMPATIBLE_IOCTL(WDIOC_SETTIMEOUT
)
2268 COMPATIBLE_IOCTL(WDIOC_GETTIMEOUT
)
2270 COMPATIBLE_IOCTL(RNDGETENTCNT
)
2271 COMPATIBLE_IOCTL(RNDADDTOENTCNT
)
2272 COMPATIBLE_IOCTL(RNDGETPOOL
)
2273 COMPATIBLE_IOCTL(RNDADDENTROPY
)
2274 COMPATIBLE_IOCTL(RNDZAPENTCNT
)
2275 COMPATIBLE_IOCTL(RNDCLEARPOOL
)
2277 COMPATIBLE_IOCTL(HCIDEVUP
)
2278 COMPATIBLE_IOCTL(HCIDEVDOWN
)
2279 COMPATIBLE_IOCTL(HCIDEVRESET
)
2280 COMPATIBLE_IOCTL(HCIDEVRESTAT
)
2281 COMPATIBLE_IOCTL(HCIGETDEVLIST
)
2282 COMPATIBLE_IOCTL(HCIGETDEVINFO
)
2283 COMPATIBLE_IOCTL(HCIGETCONNLIST
)
2284 COMPATIBLE_IOCTL(HCIGETCONNINFO
)
2285 COMPATIBLE_IOCTL(HCIGETAUTHINFO
)
2286 COMPATIBLE_IOCTL(HCISETRAW
)
2287 COMPATIBLE_IOCTL(HCISETSCAN
)
2288 COMPATIBLE_IOCTL(HCISETAUTH
)
2289 COMPATIBLE_IOCTL(HCISETENCRYPT
)
2290 COMPATIBLE_IOCTL(HCISETPTYPE
)
2291 COMPATIBLE_IOCTL(HCISETLINKPOL
)
2292 COMPATIBLE_IOCTL(HCISETLINKMODE
)
2293 COMPATIBLE_IOCTL(HCISETACLMTU
)
2294 COMPATIBLE_IOCTL(HCISETSCOMTU
)
2295 COMPATIBLE_IOCTL(HCIINQUIRY
)
2296 COMPATIBLE_IOCTL(HCIUARTSETPROTO
)
2297 COMPATIBLE_IOCTL(HCIUARTGETPROTO
)
2298 COMPATIBLE_IOCTL(RFCOMMCREATEDEV
)
2299 COMPATIBLE_IOCTL(RFCOMMRELEASEDEV
)
2300 COMPATIBLE_IOCTL(RFCOMMGETDEVLIST
)
2301 COMPATIBLE_IOCTL(RFCOMMGETDEVINFO
)
2302 COMPATIBLE_IOCTL(RFCOMMSTEALDLC
)
2303 COMPATIBLE_IOCTL(BNEPCONNADD
)
2304 COMPATIBLE_IOCTL(BNEPCONNDEL
)
2305 COMPATIBLE_IOCTL(BNEPGETCONNLIST
)
2306 COMPATIBLE_IOCTL(BNEPGETCONNINFO
)
2307 COMPATIBLE_IOCTL(CMTPCONNADD
)
2308 COMPATIBLE_IOCTL(CMTPCONNDEL
)
2309 COMPATIBLE_IOCTL(CMTPGETCONNLIST
)
2310 COMPATIBLE_IOCTL(CMTPGETCONNINFO
)
2311 COMPATIBLE_IOCTL(HIDPCONNADD
)
2312 COMPATIBLE_IOCTL(HIDPCONNDEL
)
2313 COMPATIBLE_IOCTL(HIDPGETCONNLIST
)
2314 COMPATIBLE_IOCTL(HIDPGETCONNINFO
)
2316 COMPATIBLE_IOCTL(CAPI_REGISTER
)
2317 COMPATIBLE_IOCTL(CAPI_GET_MANUFACTURER
)
2318 COMPATIBLE_IOCTL(CAPI_GET_VERSION
)
2319 COMPATIBLE_IOCTL(CAPI_GET_SERIAL
)
2320 COMPATIBLE_IOCTL(CAPI_GET_PROFILE
)
2321 COMPATIBLE_IOCTL(CAPI_MANUFACTURER_CMD
)
2322 COMPATIBLE_IOCTL(CAPI_GET_ERRCODE
)
2323 COMPATIBLE_IOCTL(CAPI_INSTALLED
)
2324 COMPATIBLE_IOCTL(CAPI_GET_FLAGS
)
2325 COMPATIBLE_IOCTL(CAPI_SET_FLAGS
)
2326 COMPATIBLE_IOCTL(CAPI_CLR_FLAGS
)
2327 COMPATIBLE_IOCTL(CAPI_NCCI_OPENCOUNT
)
2328 COMPATIBLE_IOCTL(CAPI_NCCI_GETUNIT
)
2329 /* Siemens Gigaset */
2330 COMPATIBLE_IOCTL(GIGASET_REDIR
)
2331 COMPATIBLE_IOCTL(GIGASET_CONFIG
)
2332 COMPATIBLE_IOCTL(GIGASET_BRKCHARS
)
2333 COMPATIBLE_IOCTL(GIGASET_VERSION
)
2335 COMPATIBLE_IOCTL(0x41545900) /* ATYIO_CLKR */
2336 COMPATIBLE_IOCTL(0x41545901) /* ATYIO_CLKW */
2337 COMPATIBLE_IOCTL(PCIIOC_CONTROLLER
)
2338 COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO
)
2339 COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM
)
2340 COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE
)
2342 COMPATIBLE_IOCTL(USBDEVFS_RESETEP
)
2343 COMPATIBLE_IOCTL(USBDEVFS_SETINTERFACE
)
2344 COMPATIBLE_IOCTL(USBDEVFS_SETCONFIGURATION
)
2345 COMPATIBLE_IOCTL(USBDEVFS_GETDRIVER
)
2346 COMPATIBLE_IOCTL(USBDEVFS_DISCARDURB
)
2347 COMPATIBLE_IOCTL(USBDEVFS_CLAIMINTERFACE
)
2348 COMPATIBLE_IOCTL(USBDEVFS_RELEASEINTERFACE
)
2349 COMPATIBLE_IOCTL(USBDEVFS_CONNECTINFO
)
2350 COMPATIBLE_IOCTL(USBDEVFS_HUB_PORTINFO
)
2351 COMPATIBLE_IOCTL(USBDEVFS_RESET
)
2352 COMPATIBLE_IOCTL(USBDEVFS_SUBMITURB32
)
2353 COMPATIBLE_IOCTL(USBDEVFS_REAPURB32
)
2354 COMPATIBLE_IOCTL(USBDEVFS_REAPURBNDELAY32
)
2355 COMPATIBLE_IOCTL(USBDEVFS_CLEAR_HALT
)
2357 ULONG_IOCTL(NBD_SET_SOCK
)
2358 ULONG_IOCTL(NBD_SET_BLKSIZE
)
2359 ULONG_IOCTL(NBD_SET_SIZE
)
2360 COMPATIBLE_IOCTL(NBD_DO_IT
)
2361 COMPATIBLE_IOCTL(NBD_CLEAR_SOCK
)
2362 COMPATIBLE_IOCTL(NBD_CLEAR_QUE
)
2363 COMPATIBLE_IOCTL(NBD_PRINT_DEBUG
)
2364 ULONG_IOCTL(NBD_SET_SIZE_BLOCKS
)
2365 COMPATIBLE_IOCTL(NBD_DISCONNECT
)
2367 COMPATIBLE_IOCTL(I2C_SLAVE
)
2368 COMPATIBLE_IOCTL(I2C_SLAVE_FORCE
)
2369 COMPATIBLE_IOCTL(I2C_TENBIT
)
2370 COMPATIBLE_IOCTL(I2C_PEC
)
2371 COMPATIBLE_IOCTL(I2C_RETRIES
)
2372 COMPATIBLE_IOCTL(I2C_TIMEOUT
)
2374 COMPATIBLE_IOCTL(HIDIOCGVERSION
)
2375 COMPATIBLE_IOCTL(HIDIOCAPPLICATION
)
2376 COMPATIBLE_IOCTL(HIDIOCGDEVINFO
)
2377 COMPATIBLE_IOCTL(HIDIOCGSTRING
)
2378 COMPATIBLE_IOCTL(HIDIOCINITREPORT
)
2379 COMPATIBLE_IOCTL(HIDIOCGREPORT
)
2380 COMPATIBLE_IOCTL(HIDIOCSREPORT
)
2381 COMPATIBLE_IOCTL(HIDIOCGREPORTINFO
)
2382 COMPATIBLE_IOCTL(HIDIOCGFIELDINFO
)
2383 COMPATIBLE_IOCTL(HIDIOCGUSAGE
)
2384 COMPATIBLE_IOCTL(HIDIOCSUSAGE
)
2385 COMPATIBLE_IOCTL(HIDIOCGUCODE
)
2386 COMPATIBLE_IOCTL(HIDIOCGFLAG
)
2387 COMPATIBLE_IOCTL(HIDIOCSFLAG
)
2388 COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINDEX
)
2389 COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINFO
)
2391 COMPATIBLE_IOCTL(AUDIO_STOP
)
2392 COMPATIBLE_IOCTL(AUDIO_PLAY
)
2393 COMPATIBLE_IOCTL(AUDIO_PAUSE
)
2394 COMPATIBLE_IOCTL(AUDIO_CONTINUE
)
2395 COMPATIBLE_IOCTL(AUDIO_SELECT_SOURCE
)
2396 COMPATIBLE_IOCTL(AUDIO_SET_MUTE
)
2397 COMPATIBLE_IOCTL(AUDIO_SET_AV_SYNC
)
2398 COMPATIBLE_IOCTL(AUDIO_SET_BYPASS_MODE
)
2399 COMPATIBLE_IOCTL(AUDIO_CHANNEL_SELECT
)
2400 COMPATIBLE_IOCTL(AUDIO_GET_STATUS
)
2401 COMPATIBLE_IOCTL(AUDIO_GET_CAPABILITIES
)
2402 COMPATIBLE_IOCTL(AUDIO_CLEAR_BUFFER
)
2403 COMPATIBLE_IOCTL(AUDIO_SET_ID
)
2404 COMPATIBLE_IOCTL(AUDIO_SET_MIXER
)
2405 COMPATIBLE_IOCTL(AUDIO_SET_STREAMTYPE
)
2406 COMPATIBLE_IOCTL(AUDIO_SET_EXT_ID
)
2407 COMPATIBLE_IOCTL(AUDIO_SET_ATTRIBUTES
)
2408 COMPATIBLE_IOCTL(AUDIO_SET_KARAOKE
)
2409 COMPATIBLE_IOCTL(DMX_START
)
2410 COMPATIBLE_IOCTL(DMX_STOP
)
2411 COMPATIBLE_IOCTL(DMX_SET_FILTER
)
2412 COMPATIBLE_IOCTL(DMX_SET_PES_FILTER
)
2413 COMPATIBLE_IOCTL(DMX_SET_BUFFER_SIZE
)
2414 COMPATIBLE_IOCTL(DMX_GET_PES_PIDS
)
2415 COMPATIBLE_IOCTL(DMX_GET_CAPS
)
2416 COMPATIBLE_IOCTL(DMX_SET_SOURCE
)
2417 COMPATIBLE_IOCTL(DMX_GET_STC
)
2418 COMPATIBLE_IOCTL(FE_GET_INFO
)
2419 COMPATIBLE_IOCTL(FE_DISEQC_RESET_OVERLOAD
)
2420 COMPATIBLE_IOCTL(FE_DISEQC_SEND_MASTER_CMD
)
2421 COMPATIBLE_IOCTL(FE_DISEQC_RECV_SLAVE_REPLY
)
2422 COMPATIBLE_IOCTL(FE_DISEQC_SEND_BURST
)
2423 COMPATIBLE_IOCTL(FE_SET_TONE
)
2424 COMPATIBLE_IOCTL(FE_SET_VOLTAGE
)
2425 COMPATIBLE_IOCTL(FE_ENABLE_HIGH_LNB_VOLTAGE
)
2426 COMPATIBLE_IOCTL(FE_READ_STATUS
)
2427 COMPATIBLE_IOCTL(FE_READ_BER
)
2428 COMPATIBLE_IOCTL(FE_READ_SIGNAL_STRENGTH
)
2429 COMPATIBLE_IOCTL(FE_READ_SNR
)
2430 COMPATIBLE_IOCTL(FE_READ_UNCORRECTED_BLOCKS
)
2431 COMPATIBLE_IOCTL(FE_SET_FRONTEND
)
2432 COMPATIBLE_IOCTL(FE_GET_FRONTEND
)
2433 COMPATIBLE_IOCTL(FE_GET_EVENT
)
2434 COMPATIBLE_IOCTL(FE_DISHNETWORK_SEND_LEGACY_CMD
)
2435 COMPATIBLE_IOCTL(VIDEO_STOP
)
2436 COMPATIBLE_IOCTL(VIDEO_PLAY
)
2437 COMPATIBLE_IOCTL(VIDEO_FREEZE
)
2438 COMPATIBLE_IOCTL(VIDEO_CONTINUE
)
2439 COMPATIBLE_IOCTL(VIDEO_SELECT_SOURCE
)
2440 COMPATIBLE_IOCTL(VIDEO_SET_BLANK
)
2441 COMPATIBLE_IOCTL(VIDEO_GET_STATUS
)
2442 COMPATIBLE_IOCTL(VIDEO_SET_DISPLAY_FORMAT
)
2443 COMPATIBLE_IOCTL(VIDEO_FAST_FORWARD
)
2444 COMPATIBLE_IOCTL(VIDEO_SLOWMOTION
)
2445 COMPATIBLE_IOCTL(VIDEO_GET_CAPABILITIES
)
2446 COMPATIBLE_IOCTL(VIDEO_CLEAR_BUFFER
)
2447 COMPATIBLE_IOCTL(VIDEO_SET_ID
)
2448 COMPATIBLE_IOCTL(VIDEO_SET_STREAMTYPE
)
2449 COMPATIBLE_IOCTL(VIDEO_SET_FORMAT
)
2450 COMPATIBLE_IOCTL(VIDEO_SET_SYSTEM
)
2451 COMPATIBLE_IOCTL(VIDEO_SET_HIGHLIGHT
)
2452 COMPATIBLE_IOCTL(VIDEO_SET_SPU
)
2453 COMPATIBLE_IOCTL(VIDEO_GET_NAVI
)
2454 COMPATIBLE_IOCTL(VIDEO_SET_ATTRIBUTES
)
2455 COMPATIBLE_IOCTL(VIDEO_GET_SIZE
)
2456 COMPATIBLE_IOCTL(VIDEO_GET_FRAME_RATE
)
2459 COMPATIBLE_IOCTL(JSIOCGVERSION
)
2460 COMPATIBLE_IOCTL(JSIOCGAXES
)
2461 COMPATIBLE_IOCTL(JSIOCGBUTTONS
)
2462 COMPATIBLE_IOCTL(JSIOCGNAME(0))
2464 /* now things that need handlers */
2466 HANDLE_IOCTL(SIOCGIFNAME
, dev_ifname32
)
2467 HANDLE_IOCTL(SIOCGIFCONF
, dev_ifconf
)
2468 HANDLE_IOCTL(SIOCGIFFLAGS
, dev_ifsioc
)
2469 HANDLE_IOCTL(SIOCSIFFLAGS
, dev_ifsioc
)
2470 HANDLE_IOCTL(SIOCGIFMETRIC
, dev_ifsioc
)
2471 HANDLE_IOCTL(SIOCSIFMETRIC
, dev_ifsioc
)
2472 HANDLE_IOCTL(SIOCGIFMTU
, dev_ifsioc
)
2473 HANDLE_IOCTL(SIOCSIFMTU
, dev_ifsioc
)
2474 HANDLE_IOCTL(SIOCGIFMEM
, dev_ifsioc
)
2475 HANDLE_IOCTL(SIOCSIFMEM
, dev_ifsioc
)
2476 HANDLE_IOCTL(SIOCGIFHWADDR
, dev_ifsioc
)
2477 HANDLE_IOCTL(SIOCSIFHWADDR
, dev_ifsioc
)
2478 HANDLE_IOCTL(SIOCADDMULTI
, dev_ifsioc
)
2479 HANDLE_IOCTL(SIOCDELMULTI
, dev_ifsioc
)
2480 HANDLE_IOCTL(SIOCGIFINDEX
, dev_ifsioc
)
2481 HANDLE_IOCTL(SIOCGIFMAP
, dev_ifsioc
)
2482 HANDLE_IOCTL(SIOCSIFMAP
, dev_ifsioc
)
2483 HANDLE_IOCTL(SIOCGIFADDR
, dev_ifsioc
)
2484 HANDLE_IOCTL(SIOCSIFADDR
, dev_ifsioc
)
2485 HANDLE_IOCTL(SIOCSIFHWBROADCAST
, dev_ifsioc
)
2486 HANDLE_IOCTL(SIOCSHWTSTAMP
, dev_ifsioc
)
2488 /* ioctls used by appletalk ddp.c */
2489 HANDLE_IOCTL(SIOCATALKDIFADDR
, dev_ifsioc
)
2490 HANDLE_IOCTL(SIOCDIFADDR
, dev_ifsioc
)
2491 HANDLE_IOCTL(SIOCSARP
, dev_ifsioc
)
2492 HANDLE_IOCTL(SIOCDARP
, dev_ifsioc
)
2494 HANDLE_IOCTL(SIOCGIFBRDADDR
, dev_ifsioc
)
2495 HANDLE_IOCTL(SIOCSIFBRDADDR
, dev_ifsioc
)
2496 HANDLE_IOCTL(SIOCGIFDSTADDR
, dev_ifsioc
)
2497 HANDLE_IOCTL(SIOCSIFDSTADDR
, dev_ifsioc
)
2498 HANDLE_IOCTL(SIOCGIFNETMASK
, dev_ifsioc
)
2499 HANDLE_IOCTL(SIOCSIFNETMASK
, dev_ifsioc
)
2500 HANDLE_IOCTL(SIOCSIFPFLAGS
, dev_ifsioc
)
2501 HANDLE_IOCTL(SIOCGIFPFLAGS
, dev_ifsioc
)
2502 HANDLE_IOCTL(SIOCGIFTXQLEN
, dev_ifsioc
)
2503 HANDLE_IOCTL(SIOCSIFTXQLEN
, dev_ifsioc
)
2504 HANDLE_IOCTL(TUNSETIFF
, dev_ifsioc
)
2505 HANDLE_IOCTL(TUNGETIFF
, dev_ifsioc
)
2506 HANDLE_IOCTL(SIOCETHTOOL
, ethtool_ioctl
)
2507 HANDLE_IOCTL(SIOCBONDENSLAVE
, bond_ioctl
)
2508 HANDLE_IOCTL(SIOCBONDRELEASE
, bond_ioctl
)
2509 HANDLE_IOCTL(SIOCBONDSETHWADDR
, bond_ioctl
)
2510 HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY
, bond_ioctl
)
2511 HANDLE_IOCTL(SIOCBONDINFOQUERY
, bond_ioctl
)
2512 HANDLE_IOCTL(SIOCBONDCHANGEACTIVE
, bond_ioctl
)
2513 HANDLE_IOCTL(SIOCADDRT
, routing_ioctl
)
2514 HANDLE_IOCTL(SIOCDELRT
, routing_ioctl
)
2515 HANDLE_IOCTL(SIOCBRADDIF
, dev_ifsioc
)
2516 HANDLE_IOCTL(SIOCBRDELIF
, dev_ifsioc
)
2517 /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
2518 HANDLE_IOCTL(SIOCRTMSG
, ret_einval
)
2519 HANDLE_IOCTL(SIOCGSTAMP
, do_siocgstamp
)
2520 HANDLE_IOCTL(SIOCGSTAMPNS
, do_siocgstampns
)
2523 HANDLE_IOCTL(SG_IO
,sg_ioctl_trans
)
2524 HANDLE_IOCTL(SG_GET_REQUEST_TABLE
, sg_grt_trans
)
2526 HANDLE_IOCTL(PPPIOCGIDLE32
, ppp_ioctl_trans
)
2527 HANDLE_IOCTL(PPPIOCSCOMPRESS32
, ppp_ioctl_trans
)
2528 HANDLE_IOCTL(PPPIOCSPASS32
, ppp_sock_fprog_ioctl_trans
)
2529 HANDLE_IOCTL(PPPIOCSACTIVE32
, ppp_sock_fprog_ioctl_trans
)
2531 HANDLE_IOCTL(MTIOCGET32
, mt_ioctl_trans
)
2532 HANDLE_IOCTL(MTIOCPOS32
, mt_ioctl_trans
)
2534 #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
2535 HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32
, ioc_settimeout
)
2537 HANDLE_IOCTL(PIO_FONTX
, do_fontx_ioctl
)
2538 HANDLE_IOCTL(GIO_FONTX
, do_fontx_ioctl
)
2539 HANDLE_IOCTL(PIO_UNIMAP
, do_unimap_ioctl
)
2540 HANDLE_IOCTL(GIO_UNIMAP
, do_unimap_ioctl
)
2541 HANDLE_IOCTL(KDFONTOP
, do_kdfontop_ioctl
)
2543 /* One SMB ioctl needs translations. */
2544 #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
2545 HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32
, do_smb_getmountuid
)
2546 HANDLE_IOCTL(ATM_GETLINKRATE32
, do_atm_ioctl
)
2547 HANDLE_IOCTL(ATM_GETNAMES32
, do_atm_ioctl
)
2548 HANDLE_IOCTL(ATM_GETTYPE32
, do_atm_ioctl
)
2549 HANDLE_IOCTL(ATM_GETESI32
, do_atm_ioctl
)
2550 HANDLE_IOCTL(ATM_GETADDR32
, do_atm_ioctl
)
2551 HANDLE_IOCTL(ATM_RSTADDR32
, do_atm_ioctl
)
2552 HANDLE_IOCTL(ATM_ADDADDR32
, do_atm_ioctl
)
2553 HANDLE_IOCTL(ATM_DELADDR32
, do_atm_ioctl
)
2554 HANDLE_IOCTL(ATM_GETCIRANGE32
, do_atm_ioctl
)
2555 HANDLE_IOCTL(ATM_SETCIRANGE32
, do_atm_ioctl
)
2556 HANDLE_IOCTL(ATM_SETESI32
, do_atm_ioctl
)
2557 HANDLE_IOCTL(ATM_SETESIF32
, do_atm_ioctl
)
2558 HANDLE_IOCTL(ATM_GETSTAT32
, do_atm_ioctl
)
2559 HANDLE_IOCTL(ATM_GETSTATZ32
, do_atm_ioctl
)
2560 HANDLE_IOCTL(ATM_GETLOOP32
, do_atm_ioctl
)
2561 HANDLE_IOCTL(ATM_SETLOOP32
, do_atm_ioctl
)
2562 HANDLE_IOCTL(ATM_QUERYLOOP32
, do_atm_ioctl
)
2563 HANDLE_IOCTL(SONET_GETSTAT
, do_atm_ioctl
)
2564 HANDLE_IOCTL(SONET_GETSTATZ
, do_atm_ioctl
)
2565 HANDLE_IOCTL(SONET_GETDIAG
, do_atm_ioctl
)
2566 HANDLE_IOCTL(SONET_SETDIAG
, do_atm_ioctl
)
2567 HANDLE_IOCTL(SONET_CLRDIAG
, do_atm_ioctl
)
2568 HANDLE_IOCTL(SONET_SETFRAMING
, do_atm_ioctl
)
2569 HANDLE_IOCTL(SONET_GETFRAMING
, do_atm_ioctl
)
2570 HANDLE_IOCTL(SONET_GETFRSENSE
, do_atm_ioctl
)
2574 IGNORE_IOCTL(LOOP_CLR_FD
)
2577 HANDLE_IOCTL(TIOCGSERIAL
, serial_struct_ioctl
)
2578 HANDLE_IOCTL(TIOCSSERIAL
, serial_struct_ioctl
)
2580 COMPATIBLE_IOCTL(TIOCGLTC
)
2581 COMPATIBLE_IOCTL(TIOCSLTC
)
2585 * For these two we have defintions in ioctls.h and/or termios.h on
2586 * some architectures but no actual implemention. Some applications
2587 * like bash call them if they are defined in the headers, so we provide
2588 * entries here to avoid syslog message spew.
2590 COMPATIBLE_IOCTL(TIOCSTART
)
2591 COMPATIBLE_IOCTL(TIOCSTOP
)
2594 HANDLE_IOCTL(USBDEVFS_CONTROL32
, do_usbdevfs_control
)
2595 HANDLE_IOCTL(USBDEVFS_BULK32
, do_usbdevfs_bulk
)
2596 HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32
, do_usbdevfs_discsignal
)
2597 COMPATIBLE_IOCTL(USBDEVFS_IOCTL32
)
2599 HANDLE_IOCTL(I2C_FUNCS
, w_long
)
2600 HANDLE_IOCTL(I2C_RDWR
, do_i2c_rdwr_ioctl
)
2601 HANDLE_IOCTL(I2C_SMBUS
, do_i2c_smbus_ioctl
)
2603 HANDLE_IOCTL(SIOCSIFBR
, old_bridge_ioctl
)
2604 HANDLE_IOCTL(SIOCGIFBR
, old_bridge_ioctl
)
2605 /* Not implemented in the native kernel */
2606 IGNORE_IOCTL(SIOCGIFCOUNT
)
2607 HANDLE_IOCTL(RTC_IRQP_READ32
, rtc_ioctl
)
2608 HANDLE_IOCTL(RTC_IRQP_SET32
, rtc_ioctl
)
2609 HANDLE_IOCTL(RTC_EPOCH_READ32
, rtc_ioctl
)
2610 HANDLE_IOCTL(RTC_EPOCH_SET32
, rtc_ioctl
)
2613 HANDLE_IOCTL(VIDEO_GET_EVENT
, do_video_get_event
)
2614 HANDLE_IOCTL(VIDEO_STILLPICTURE
, do_video_stillpicture
)
2615 HANDLE_IOCTL(VIDEO_SET_SPU_PALETTE
, do_video_set_spu_palette
)
2618 COMPATIBLE_IOCTL(LPTIME
)
2619 COMPATIBLE_IOCTL(LPCHAR
)
2620 COMPATIBLE_IOCTL(LPABORTOPEN
)
2621 COMPATIBLE_IOCTL(LPCAREFUL
)
2622 COMPATIBLE_IOCTL(LPWAIT
)
2623 COMPATIBLE_IOCTL(LPSETIRQ
)
2624 COMPATIBLE_IOCTL(LPGETSTATUS
)
2625 COMPATIBLE_IOCTL(LPGETSTATUS
)
2626 COMPATIBLE_IOCTL(LPRESET
)
2627 /*LPGETSTATS not implemented, but no kernels seem to compile it in anyways*/
2628 COMPATIBLE_IOCTL(LPGETFLAGS
)
2629 HANDLE_IOCTL(LPSETTIMEOUT
, lp_timeout_trans
)
2631 /* fat 'r' ioctls. These are handled by fat with ->compat_ioctl,
2632 but we don't want warnings on other file systems. So declare
2633 them as compatible here. */
2634 #define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
2635 #define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
2637 IGNORE_IOCTL(VFAT_IOCTL_READDIR_BOTH32
)
2638 IGNORE_IOCTL(VFAT_IOCTL_READDIR_SHORT32
)
2641 /* Sparc framebuffers, handled in sbusfb_compat_ioctl() */
2642 IGNORE_IOCTL(FBIOGTYPE
)
2643 IGNORE_IOCTL(FBIOSATTR
)
2644 IGNORE_IOCTL(FBIOGATTR
)
2645 IGNORE_IOCTL(FBIOSVIDEO
)
2646 IGNORE_IOCTL(FBIOGVIDEO
)
2647 IGNORE_IOCTL(FBIOSCURPOS
)
2648 IGNORE_IOCTL(FBIOGCURPOS
)
2649 IGNORE_IOCTL(FBIOGCURMAX
)
2650 IGNORE_IOCTL(FBIOPUTCMAP32
)
2651 IGNORE_IOCTL(FBIOGETCMAP32
)
2652 IGNORE_IOCTL(FBIOSCURSOR32
)
2653 IGNORE_IOCTL(FBIOGCURSOR32
)
2657 #define IOCTL_HASHSIZE 256
2658 static struct ioctl_trans
*ioctl32_hash_table
[IOCTL_HASHSIZE
];
2660 static inline unsigned long ioctl32_hash(unsigned long cmd
)
2662 return (((cmd
>> 6) ^ (cmd
>> 4) ^ cmd
)) % IOCTL_HASHSIZE
;
2665 static void compat_ioctl_error(struct file
*filp
, unsigned int fd
,
2666 unsigned int cmd
, unsigned long arg
)
2672 /* find the name of the device. */
2673 path
= (char *)__get_free_page(GFP_KERNEL
);
2675 fn
= d_path(&filp
->f_path
, path
, PAGE_SIZE
);
2680 sprintf(buf
,"'%c'", (cmd
>>_IOC_TYPESHIFT
) & _IOC_TYPEMASK
);
2681 if (!isprint(buf
[1]))
2682 sprintf(buf
, "%02x", buf
[1]);
2683 compat_printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
2684 "cmd(%08x){t:%s;sz:%u} arg(%08x) on %s\n",
2685 current
->comm
, current
->pid
,
2686 (int)fd
, (unsigned int)cmd
, buf
,
2687 (cmd
>> _IOC_SIZESHIFT
) & _IOC_SIZEMASK
,
2688 (unsigned int)arg
, fn
);
2691 free_page((unsigned long)path
);
2694 asmlinkage
long compat_sys_ioctl(unsigned int fd
, unsigned int cmd
,
2699 struct ioctl_trans
*t
;
2702 filp
= fget_light(fd
, &fput_needed
);
2706 /* RED-PEN how should LSM module know it's handling 32bit? */
2707 error
= security_file_ioctl(filp
, cmd
, arg
);
2712 * To allow the compat_ioctl handlers to be self contained
2713 * we need to check the common ioctls here first.
2714 * Just handle them with the standard handlers below.
2724 #if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
2725 case FS_IOC_RESVSP_32
:
2726 case FS_IOC_RESVSP64_32
:
2727 error
= compat_ioctl_preallocate(filp
, arg
);
2731 case FS_IOC_RESVSP64
:
2732 error
= ioctl_preallocate(filp
, (void __user
*)arg
);
2739 if (S_ISREG(filp
->f_path
.dentry
->d_inode
->i_mode
))
2744 if (filp
->f_op
&& filp
->f_op
->compat_ioctl
) {
2745 error
= filp
->f_op
->compat_ioctl(filp
, cmd
, arg
);
2746 if (error
!= -ENOIOCTLCMD
)
2751 (!filp
->f_op
->ioctl
&& !filp
->f_op
->unlocked_ioctl
))
2756 for (t
= ioctl32_hash_table
[ioctl32_hash(cmd
)]; t
; t
= t
->next
) {
2762 if (S_ISSOCK(filp
->f_path
.dentry
->d_inode
->i_mode
) &&
2763 cmd
>= SIOCDEVPRIVATE
&& cmd
<= (SIOCDEVPRIVATE
+ 15)) {
2764 error
= siocdevprivate_ioctl(fd
, cmd
, arg
);
2771 compat_ioctl_error(filp
, fd
, cmd
, arg
);
2780 error
= t
->handler(fd
, cmd
, arg
, filp
);
2786 error
= do_vfs_ioctl(filp
, fd
, cmd
, arg
);
2788 fput_light(filp
, fput_needed
);
2793 static void ioctl32_insert_translation(struct ioctl_trans
*trans
)
2796 struct ioctl_trans
*t
;
2798 hash
= ioctl32_hash (trans
->cmd
);
2799 if (!ioctl32_hash_table
[hash
])
2800 ioctl32_hash_table
[hash
] = trans
;
2802 t
= ioctl32_hash_table
[hash
];
2810 static int __init
init_sys32_ioctl(void)
2814 for (i
= 0; i
< ARRAY_SIZE(ioctl_start
); i
++) {
2815 if (ioctl_start
[i
].next
) {
2816 printk("ioctl translation %d bad\n",i
);
2820 ioctl32_insert_translation(&ioctl_start
[i
]);
2824 __initcall(init_sys32_ioctl
);