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/config.h>
14 #include <linux/types.h>
15 #include <linux/compat.h>
16 #include <linux/kernel.h>
17 #include <linux/compiler.h>
18 #include <linux/sched.h>
19 #include <linux/smp.h>
20 #include <linux/smp_lock.h>
21 #include <linux/ioctl.h>
23 #include <linux/if_bridge.h>
24 #include <linux/slab.h>
25 #include <linux/hdreg.h>
26 #include <linux/raid/md.h>
28 #include <linux/dirent.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>
36 #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/cdrom.h>
43 #include <linux/loop.h>
44 #include <linux/auto_fs.h>
45 #include <linux/auto_fs4.h>
46 #include <linux/devfs_fs.h>
47 #include <linux/tty.h>
48 #include <linux/vt_kern.h>
50 #include <linux/ext2_fs.h>
51 #include <linux/ext3_jbd.h>
52 #include <linux/ext3_fs.h>
53 #include <linux/videodev.h>
54 #include <linux/netdevice.h>
55 #include <linux/raw.h>
56 #include <linux/smb_fs.h>
57 #include <linux/blkpg.h>
58 #include <linux/blkdev.h>
59 #include <linux/elevator.h>
60 #include <linux/rtc.h>
61 #include <linux/pci.h>
62 #include <linux/module.h>
63 #include <linux/serial.h>
64 #include <linux/reiserfs_fs.h>
65 #include <linux/if_tun.h>
66 #include <linux/ctype.h>
67 #include <linux/ioctl32.h>
68 #include <linux/syscalls.h>
69 #include <linux/ncp_fs.h>
70 #include <linux/i2c.h>
71 #include <linux/i2c-dev.h>
72 #include <linux/wireless.h>
73 #include <linux/atalk.h>
75 #include <net/sock.h> /* siocdevprivate_ioctl */
76 #include <net/bluetooth/bluetooth.h>
77 #include <net/bluetooth/hci.h>
78 #include <net/bluetooth/rfcomm.h>
80 #include <linux/capi.h>
82 #include <scsi/scsi.h>
83 #include <scsi/scsi_ioctl.h>
86 #include <asm/uaccess.h>
87 #include <linux/ethtool.h>
88 #include <linux/mii.h>
89 #include <linux/if_bonding.h>
90 #include <linux/watchdog.h>
91 #include <linux/dm-ioctl.h>
93 #include <linux/soundcard.h>
95 #include <linux/ppdev.h>
97 #include <linux/atm.h>
98 #include <linux/atmarp.h>
99 #include <linux/atmclip.h>
100 #include <linux/atmdev.h>
101 #include <linux/atmioc.h>
102 #include <linux/atmlec.h>
103 #include <linux/atmmpc.h>
104 #include <linux/atmsvc.h>
105 #include <linux/atm_tcp.h>
106 #include <linux/sonet.h>
107 #include <linux/atm_suni.h>
108 #include <linux/mtd/mtd.h>
110 #include <linux/usb.h>
111 #include <linux/usbdevice_fs.h>
112 #include <linux/nbd.h>
113 #include <linux/random.h>
114 #include <linux/filter.h>
115 #include <linux/msdos_fs.h>
116 #include <linux/pktcdvd.h>
118 #include <linux/hiddev.h>
120 #include <linux/dvb/audio.h>
121 #include <linux/dvb/dmx.h>
122 #include <linux/dvb/frontend.h>
123 #include <linux/dvb/video.h>
125 /* Aiee. Someone does not find a difference between int and long */
126 #define EXT2_IOC32_GETFLAGS _IOR('f', 1, int)
127 #define EXT2_IOC32_SETFLAGS _IOW('f', 2, int)
128 #define EXT3_IOC32_GETVERSION _IOR('f', 3, int)
129 #define EXT3_IOC32_SETVERSION _IOW('f', 4, int)
130 #define EXT3_IOC32_GETRSVSZ _IOR('f', 5, int)
131 #define EXT3_IOC32_SETRSVSZ _IOW('f', 6, int)
132 #define EXT3_IOC32_GROUP_EXTEND _IOW('f', 7, unsigned int)
133 #ifdef CONFIG_JBD_DEBUG
134 #define EXT3_IOC32_WAIT_FOR_READONLY _IOR('f', 99, int)
137 #define EXT2_IOC32_GETVERSION _IOR('v', 1, int)
138 #define EXT2_IOC32_SETVERSION _IOW('v', 2, int)
140 static int do_ioctl32_pointer(unsigned int fd
, unsigned int cmd
,
141 unsigned long arg
, struct file
*f
)
143 return sys_ioctl(fd
, cmd
, (unsigned long)compat_ptr(arg
));
146 static int w_long(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
148 mm_segment_t old_fs
= get_fs();
153 err
= sys_ioctl(fd
, cmd
, (unsigned long)&val
);
155 if (!err
&& put_user(val
, (u32 __user
*)compat_ptr(arg
)))
160 static int rw_long(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
162 mm_segment_t old_fs
= get_fs();
163 u32 __user
*argptr
= compat_ptr(arg
);
167 if(get_user(val
, argptr
))
170 err
= sys_ioctl(fd
, cmd
, (unsigned long)&val
);
172 if (!err
&& put_user(val
, argptr
))
177 static int do_ext2_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
179 /* These are just misnamed, they actually get/put from/to user an int */
181 case EXT2_IOC32_GETFLAGS
: cmd
= EXT2_IOC_GETFLAGS
; break;
182 case EXT2_IOC32_SETFLAGS
: cmd
= EXT2_IOC_SETFLAGS
; break;
183 case EXT2_IOC32_GETVERSION
: cmd
= EXT2_IOC_GETVERSION
; break;
184 case EXT2_IOC32_SETVERSION
: cmd
= EXT2_IOC_SETVERSION
; break;
186 return sys_ioctl(fd
, cmd
, (unsigned long)compat_ptr(arg
));
189 static int do_ext3_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
191 /* These are just misnamed, they actually get/put from/to user an int */
193 case EXT3_IOC32_GETVERSION
: cmd
= EXT3_IOC_GETVERSION
; break;
194 case EXT3_IOC32_SETVERSION
: cmd
= EXT3_IOC_SETVERSION
; break;
195 case EXT3_IOC32_GETRSVSZ
: cmd
= EXT3_IOC_GETRSVSZ
; break;
196 case EXT3_IOC32_SETRSVSZ
: cmd
= EXT3_IOC_SETRSVSZ
; break;
197 case EXT3_IOC32_GROUP_EXTEND
: cmd
= EXT3_IOC_GROUP_EXTEND
; break;
198 #ifdef CONFIG_JBD_DEBUG
199 case EXT3_IOC32_WAIT_FOR_READONLY
: cmd
= EXT3_IOC_WAIT_FOR_READONLY
; break;
202 return sys_ioctl(fd
, cmd
, (unsigned long)compat_ptr(arg
));
205 struct compat_dmx_event
{
207 compat_time_t timeStamp
;
210 dmx_scrambling_status_t scrambling
;
214 static int do_dmx_get_event(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
216 struct dmx_event kevent
;
217 mm_segment_t old_fs
= get_fs();
221 err
= sys_ioctl(fd
, cmd
, (unsigned long) &kevent
);
225 struct compat_dmx_event __user
*up
= compat_ptr(arg
);
227 err
= put_user(kevent
.event
, &up
->event
);
228 err
|= put_user(kevent
.timeStamp
, &up
->timeStamp
);
229 err
|= put_user(kevent
.u
.scrambling
, &up
->u
.scrambling
);
237 struct compat_video_event
{
239 compat_time_t timestamp
;
242 unsigned int frame_rate
;
246 static int do_video_get_event(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
248 struct video_event kevent
;
249 mm_segment_t old_fs
= get_fs();
253 err
= sys_ioctl(fd
, cmd
, (unsigned long) &kevent
);
257 struct compat_video_event __user
*up
= compat_ptr(arg
);
259 err
= put_user(kevent
.type
, &up
->type
);
260 err
|= put_user(kevent
.timestamp
, &up
->timestamp
);
261 err
|= put_user(kevent
.u
.size
.w
, &up
->u
.size
.w
);
262 err
|= put_user(kevent
.u
.size
.h
, &up
->u
.size
.h
);
263 err
|= put_user(kevent
.u
.size
.aspect_ratio
,
264 &up
->u
.size
.aspect_ratio
);
272 struct compat_video_still_picture
{
273 compat_uptr_t iFrame
;
277 static int do_video_stillpicture(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
279 struct compat_video_still_picture __user
*up
;
280 struct video_still_picture __user
*up_native
;
285 up
= (struct compat_video_still_picture __user
*) arg
;
286 err
= get_user(fp
, &up
->iFrame
);
287 err
|= get_user(size
, &up
->size
);
292 compat_alloc_user_space(sizeof(struct video_still_picture
));
294 put_user(compat_ptr(fp
), &up_native
->iFrame
);
295 put_user(size
, &up_native
->size
);
297 err
= sys_ioctl(fd
, cmd
, (unsigned long) up_native
);
302 struct compat_video_spu_palette
{
304 compat_uptr_t palette
;
307 static int do_video_set_spu_palette(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
309 struct compat_video_spu_palette __user
*up
;
310 struct video_spu_palette __user
*up_native
;
314 up
= (struct compat_video_spu_palette __user
*) arg
;
315 err
= get_user(palp
, &up
->palette
);
316 err
|= get_user(length
, &up
->length
);
318 up_native
= compat_alloc_user_space(sizeof(struct video_spu_palette
));
319 put_user(compat_ptr(palp
), &up_native
->palette
);
320 put_user(length
, &up_native
->length
);
322 err
= sys_ioctl(fd
, cmd
, (unsigned long) up_native
);
328 static int do_siocgstamp(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
330 struct compat_timeval __user
*up
= compat_ptr(arg
);
332 mm_segment_t old_fs
= get_fs();
336 err
= sys_ioctl(fd
, cmd
, (unsigned long)&ktv
);
339 err
= put_user(ktv
.tv_sec
, &up
->tv_sec
);
340 err
|= __put_user(ktv
.tv_usec
, &up
->tv_usec
);
346 compat_ulong_t mem_start
;
347 compat_ulong_t mem_end
;
348 unsigned short base_addr
;
355 #define IFHWADDRLEN 6
358 char ifrn_name
[IFNAMSIZ
]; /* if name, e.g. "en0" */
361 struct sockaddr ifru_addr
;
362 struct sockaddr ifru_dstaddr
;
363 struct sockaddr ifru_broadaddr
;
364 struct sockaddr ifru_netmask
;
365 struct sockaddr ifru_hwaddr
;
367 compat_int_t ifru_ivalue
;
368 compat_int_t ifru_mtu
;
369 struct ifmap32 ifru_map
;
370 char ifru_slave
[IFNAMSIZ
]; /* Just fits the size */
371 char ifru_newname
[IFNAMSIZ
];
372 compat_caddr_t ifru_data
;
373 /* XXXX? ifru_settings should be here */
378 compat_int_t ifc_len
; /* size of buffer */
379 compat_caddr_t ifcbuf
;
382 static int dev_ifname32(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
384 struct net_device
*dev
;
385 struct ifreq32 ifr32
;
388 if (copy_from_user(&ifr32
, compat_ptr(arg
), sizeof(ifr32
)))
391 dev
= dev_get_by_index(ifr32
.ifr_ifindex
);
395 strlcpy(ifr32
.ifr_name
, dev
->name
, sizeof(ifr32
.ifr_name
));
398 err
= copy_to_user(compat_ptr(arg
), &ifr32
, sizeof(ifr32
));
399 return (err
? -EFAULT
: 0);
402 static int dev_ifconf(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
404 struct ifconf32 ifc32
;
406 struct ifconf __user
*uifc
;
407 struct ifreq32 __user
*ifr32
;
408 struct ifreq __user
*ifr
;
412 if (copy_from_user(&ifc32
, compat_ptr(arg
), sizeof(struct ifconf32
)))
415 if (ifc32
.ifcbuf
== 0) {
419 uifc
= compat_alloc_user_space(sizeof(struct ifconf
));
421 size_t len
=((ifc32
.ifc_len
/ sizeof (struct ifreq32
)) + 1) *
422 sizeof (struct ifreq
);
423 uifc
= compat_alloc_user_space(sizeof(struct ifconf
) + len
);
425 ifr
= ifc
.ifc_req
= (void __user
*)(uifc
+ 1);
426 ifr32
= compat_ptr(ifc32
.ifcbuf
);
427 for (i
= 0; i
< ifc32
.ifc_len
; i
+= sizeof (struct ifreq32
)) {
428 if (copy_in_user(ifr
, ifr32
, sizeof(struct ifreq32
)))
434 if (copy_to_user(uifc
, &ifc
, sizeof(struct ifconf
)))
437 err
= sys_ioctl (fd
, SIOCGIFCONF
, (unsigned long)uifc
);
441 if (copy_from_user(&ifc
, uifc
, sizeof(struct ifconf
)))
445 ifr32
= compat_ptr(ifc32
.ifcbuf
);
447 i
+ sizeof (struct ifreq32
) < ifc32
.ifc_len
&& j
< ifc
.ifc_len
;
448 i
+= sizeof (struct ifreq32
), j
+= sizeof (struct ifreq
)) {
449 if (copy_in_user(ifr32
, ifr
, sizeof (struct ifreq32
)))
455 if (ifc32
.ifcbuf
== 0) {
456 /* Translate from 64-bit structure multiple to
460 i
= ((i
/ sizeof(struct ifreq
)) * sizeof(struct ifreq32
));
465 if (copy_to_user(compat_ptr(arg
), &ifc32
, sizeof(struct ifconf32
)))
471 static int ethtool_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
473 struct ifreq __user
*ifr
;
474 struct ifreq32 __user
*ifr32
;
478 ifr
= compat_alloc_user_space(sizeof(*ifr
));
479 ifr32
= compat_ptr(arg
);
481 if (copy_in_user(&ifr
->ifr_name
, &ifr32
->ifr_name
, IFNAMSIZ
))
484 if (get_user(data
, &ifr32
->ifr_ifru
.ifru_data
))
487 datap
= compat_ptr(data
);
488 if (put_user(datap
, &ifr
->ifr_ifru
.ifru_data
))
491 return sys_ioctl(fd
, cmd
, (unsigned long) ifr
);
494 static int bond_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
497 struct ifreq __user
*uifr
;
498 struct ifreq32 __user
*ifr32
= compat_ptr(arg
);
505 case SIOCBONDENSLAVE
:
506 case SIOCBONDRELEASE
:
507 case SIOCBONDSETHWADDR
:
508 case SIOCBONDCHANGEACTIVE
:
509 if (copy_from_user(&kifr
, ifr32
, sizeof(struct ifreq32
)))
514 err
= sys_ioctl (fd
, cmd
, (unsigned long)&kifr
);
518 case SIOCBONDSLAVEINFOQUERY
:
519 case SIOCBONDINFOQUERY
:
520 uifr
= compat_alloc_user_space(sizeof(*uifr
));
521 if (copy_in_user(&uifr
->ifr_name
, &ifr32
->ifr_name
, IFNAMSIZ
))
524 if (get_user(data
, &ifr32
->ifr_ifru
.ifru_data
))
527 datap
= compat_ptr(data
);
528 if (put_user(datap
, &uifr
->ifr_ifru
.ifru_data
))
531 return sys_ioctl (fd
, cmd
, (unsigned long)uifr
);
537 int siocdevprivate_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
539 struct ifreq __user
*u_ifreq64
;
540 struct ifreq32 __user
*u_ifreq32
= compat_ptr(arg
);
541 char tmp_buf
[IFNAMSIZ
];
545 if (copy_from_user(&tmp_buf
[0], &(u_ifreq32
->ifr_ifrn
.ifrn_name
[0]),
548 if (__get_user(data32
, &u_ifreq32
->ifr_ifru
.ifru_data
))
550 data64
= compat_ptr(data32
);
552 u_ifreq64
= compat_alloc_user_space(sizeof(*u_ifreq64
));
554 /* Don't check these user accesses, just let that get trapped
555 * in the ioctl handler instead.
557 if (copy_to_user(&u_ifreq64
->ifr_ifrn
.ifrn_name
[0], &tmp_buf
[0],
560 if (__put_user(data64
, &u_ifreq64
->ifr_ifru
.ifru_data
))
563 return sys_ioctl(fd
, cmd
, (unsigned long) u_ifreq64
);
566 static int dev_ifsioc(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
569 struct ifreq32 __user
*uifr32
;
570 struct ifmap32 __user
*uifmap32
;
574 uifr32
= compat_ptr(arg
);
575 uifmap32
= &uifr32
->ifr_ifru
.ifru_map
;
578 err
= copy_from_user(&ifr
, uifr32
, sizeof(ifr
.ifr_name
));
579 err
|= __get_user(ifr
.ifr_map
.mem_start
, &uifmap32
->mem_start
);
580 err
|= __get_user(ifr
.ifr_map
.mem_end
, &uifmap32
->mem_end
);
581 err
|= __get_user(ifr
.ifr_map
.base_addr
, &uifmap32
->base_addr
);
582 err
|= __get_user(ifr
.ifr_map
.irq
, &uifmap32
->irq
);
583 err
|= __get_user(ifr
.ifr_map
.dma
, &uifmap32
->dma
);
584 err
|= __get_user(ifr
.ifr_map
.port
, &uifmap32
->port
);
589 if (copy_from_user(&ifr
, uifr32
, sizeof(*uifr32
)))
595 err
= sys_ioctl (fd
, cmd
, (unsigned long)&ifr
);
599 /* TUNSETIFF is defined as _IOW, it should be _IORW
600 * as the data is copied back to user space, but that
601 * cannot be fixed without breaking all existing apps.
615 if (copy_to_user(uifr32
, &ifr
, sizeof(*uifr32
)))
619 err
= copy_to_user(uifr32
, &ifr
, sizeof(ifr
.ifr_name
));
620 err
|= __put_user(ifr
.ifr_map
.mem_start
, &uifmap32
->mem_start
);
621 err
|= __put_user(ifr
.ifr_map
.mem_end
, &uifmap32
->mem_end
);
622 err
|= __put_user(ifr
.ifr_map
.base_addr
, &uifmap32
->base_addr
);
623 err
|= __put_user(ifr
.ifr_map
.irq
, &uifmap32
->irq
);
624 err
|= __put_user(ifr
.ifr_map
.dma
, &uifmap32
->dma
);
625 err
|= __put_user(ifr
.ifr_map
.port
, &uifmap32
->port
);
636 struct sockaddr rt_dst
; /* target address */
637 struct sockaddr rt_gateway
; /* gateway addr (RTF_GATEWAY) */
638 struct sockaddr rt_genmask
; /* target network mask (IP) */
639 unsigned short rt_flags
;
642 unsigned char rt_tos
;
643 unsigned char rt_class
;
645 short rt_metric
; /* +1 for binary compatibility! */
646 /* char * */ u32 rt_dev
; /* forcing the device at add */
647 u32 rt_mtu
; /* per route MTU/Window */
648 u32 rt_window
; /* Window clamping */
649 unsigned short rt_irtt
; /* Initial RTT */
654 struct in6_addr rtmsg_dst
;
655 struct in6_addr rtmsg_src
;
656 struct in6_addr rtmsg_gateway
;
666 static int routing_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
674 mm_segment_t old_fs
= get_fs();
676 struct socket
*mysock
= sockfd_lookup(fd
, &ret
);
678 if (mysock
&& mysock
->sk
&& mysock
->sk
->sk_family
== AF_INET6
) { /* ipv6 */
679 struct in6_rtmsg32 __user
*ur6
= compat_ptr(arg
);
680 ret
= copy_from_user (&r6
.rtmsg_dst
, &(ur6
->rtmsg_dst
),
681 3 * sizeof(struct in6_addr
));
682 ret
|= __get_user (r6
.rtmsg_type
, &(ur6
->rtmsg_type
));
683 ret
|= __get_user (r6
.rtmsg_dst_len
, &(ur6
->rtmsg_dst_len
));
684 ret
|= __get_user (r6
.rtmsg_src_len
, &(ur6
->rtmsg_src_len
));
685 ret
|= __get_user (r6
.rtmsg_metric
, &(ur6
->rtmsg_metric
));
686 ret
|= __get_user (r6
.rtmsg_info
, &(ur6
->rtmsg_info
));
687 ret
|= __get_user (r6
.rtmsg_flags
, &(ur6
->rtmsg_flags
));
688 ret
|= __get_user (r6
.rtmsg_ifindex
, &(ur6
->rtmsg_ifindex
));
692 struct rtentry32 __user
*ur4
= compat_ptr(arg
);
693 ret
= copy_from_user (&r4
.rt_dst
, &(ur4
->rt_dst
),
694 3 * sizeof(struct sockaddr
));
695 ret
|= __get_user (r4
.rt_flags
, &(ur4
->rt_flags
));
696 ret
|= __get_user (r4
.rt_metric
, &(ur4
->rt_metric
));
697 ret
|= __get_user (r4
.rt_mtu
, &(ur4
->rt_mtu
));
698 ret
|= __get_user (r4
.rt_window
, &(ur4
->rt_window
));
699 ret
|= __get_user (r4
.rt_irtt
, &(ur4
->rt_irtt
));
700 ret
|= __get_user (rtdev
, &(ur4
->rt_dev
));
702 ret
|= copy_from_user (devname
, compat_ptr(rtdev
), 15);
703 r4
.rt_dev
= devname
; devname
[15] = 0;
716 ret
= sys_ioctl (fd
, cmd
, (unsigned long) r
);
727 struct hd_geometry32
{
729 unsigned char sectors
;
730 unsigned short cylinders
;
734 static int hdio_getgeo(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
736 mm_segment_t old_fs
= get_fs();
737 struct hd_geometry geo
;
738 struct hd_geometry32 __user
*ugeo
;
742 err
= sys_ioctl(fd
, HDIO_GETGEO
, (unsigned long)&geo
);
744 ugeo
= compat_ptr(arg
);
746 err
= copy_to_user (ugeo
, &geo
, 4);
747 err
|= __put_user (geo
.start
, &ugeo
->start
);
749 return err
? -EFAULT
: 0;
752 static int hdio_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
754 mm_segment_t old_fs
= get_fs();
756 unsigned int __user
*uvp
;
760 error
= sys_ioctl(fd
, cmd
, (long)&kval
);
764 uvp
= compat_ptr(arg
);
765 if(put_user(kval
, uvp
))
772 typedef struct sg_io_hdr32
{
773 compat_int_t interface_id
; /* [i] 'S' for SCSI generic (required) */
774 compat_int_t dxfer_direction
; /* [i] data transfer direction */
775 unsigned char cmd_len
; /* [i] SCSI command length ( <= 16 bytes) */
776 unsigned char mx_sb_len
; /* [i] max length to write to sbp */
777 unsigned short iovec_count
; /* [i] 0 implies no scatter gather */
778 compat_uint_t dxfer_len
; /* [i] byte count of data transfer */
779 compat_uint_t dxferp
; /* [i], [*io] points to data transfer memory
780 or scatter gather list */
781 compat_uptr_t cmdp
; /* [i], [*i] points to command to perform */
782 compat_uptr_t sbp
; /* [i], [*o] points to sense_buffer memory */
783 compat_uint_t timeout
; /* [i] MAX_UINT->no timeout (unit: millisec) */
784 compat_uint_t flags
; /* [i] 0 -> default, see SG_FLAG... */
785 compat_int_t pack_id
; /* [i->o] unused internally (normally) */
786 compat_uptr_t usr_ptr
; /* [i->o] unused internally */
787 unsigned char status
; /* [o] scsi status */
788 unsigned char masked_status
; /* [o] shifted, masked scsi status */
789 unsigned char msg_status
; /* [o] messaging level data (optional) */
790 unsigned char sb_len_wr
; /* [o] byte count actually written to sbp */
791 unsigned short host_status
; /* [o] errors from host adapter */
792 unsigned short driver_status
; /* [o] errors from software driver */
793 compat_int_t resid
; /* [o] dxfer_len - actual_transferred */
794 compat_uint_t duration
; /* [o] time taken by cmd (unit: millisec) */
795 compat_uint_t info
; /* [o] auxiliary information */
796 } sg_io_hdr32_t
; /* 64 bytes long (on sparc32) */
798 typedef struct sg_iovec32
{
799 compat_uint_t iov_base
;
800 compat_uint_t iov_len
;
803 static int sg_build_iovec(sg_io_hdr_t __user
*sgio
, void __user
*dxferp
, u16 iovec_count
)
805 sg_iovec_t __user
*iov
= (sg_iovec_t __user
*) (sgio
+ 1);
806 sg_iovec32_t __user
*iov32
= dxferp
;
809 for (i
= 0; i
< iovec_count
; i
++) {
812 if (get_user(base
, &iov32
[i
].iov_base
) ||
813 get_user(len
, &iov32
[i
].iov_len
) ||
814 put_user(compat_ptr(base
), &iov
[i
].iov_base
) ||
815 put_user(len
, &iov
[i
].iov_len
))
819 if (put_user(iov
, &sgio
->dxferp
))
824 static int sg_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
826 sg_io_hdr_t __user
*sgio
;
827 sg_io_hdr32_t __user
*sgio32
;
833 sgio32
= compat_ptr(arg
);
834 if (get_user(iovec_count
, &sgio32
->iovec_count
))
838 void __user
*top
= compat_alloc_user_space(0);
839 void __user
*new = compat_alloc_user_space(sizeof(sg_io_hdr_t
) +
840 (iovec_count
* sizeof(sg_iovec_t
)));
847 /* Ok, now construct. */
848 if (copy_in_user(&sgio
->interface_id
, &sgio32
->interface_id
,
850 (2 * sizeof(unsigned char)) +
851 (1 * sizeof(unsigned short)) +
852 (1 * sizeof(unsigned int))))
855 if (get_user(data
, &sgio32
->dxferp
))
857 dxferp
= compat_ptr(data
);
859 if (sg_build_iovec(sgio
, dxferp
, iovec_count
))
862 if (put_user(dxferp
, &sgio
->dxferp
))
867 unsigned char __user
*cmdp
;
868 unsigned char __user
*sbp
;
870 if (get_user(data
, &sgio32
->cmdp
))
872 cmdp
= compat_ptr(data
);
874 if (get_user(data
, &sgio32
->sbp
))
876 sbp
= compat_ptr(data
);
878 if (put_user(cmdp
, &sgio
->cmdp
) ||
879 put_user(sbp
, &sgio
->sbp
))
883 if (copy_in_user(&sgio
->timeout
, &sgio32
->timeout
,
887 if (get_user(data
, &sgio32
->usr_ptr
))
889 if (put_user(compat_ptr(data
), &sgio
->usr_ptr
))
892 if (copy_in_user(&sgio
->status
, &sgio32
->status
,
893 (4 * sizeof(unsigned char)) +
894 (2 * sizeof(unsigned (short))) +
898 err
= sys_ioctl(fd
, cmd
, (unsigned long) sgio
);
903 if (copy_in_user(&sgio32
->pack_id
, &sgio
->pack_id
,
905 get_user(datap
, &sgio
->usr_ptr
) ||
906 put_user((u32
)(unsigned long)datap
,
908 copy_in_user(&sgio32
->status
, &sgio
->status
,
909 (4 * sizeof(unsigned char)) +
910 (2 * sizeof(unsigned short)) +
918 struct sock_fprog32
{
920 compat_caddr_t filter
;
923 #define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
924 #define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
926 static int ppp_sock_fprog_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
928 struct sock_fprog32 __user
*u_fprog32
= compat_ptr(arg
);
929 struct sock_fprog __user
*u_fprog64
= compat_alloc_user_space(sizeof(struct sock_fprog
));
934 if (get_user(flen
, &u_fprog32
->len
) ||
935 get_user(fptr32
, &u_fprog32
->filter
))
938 fptr64
= compat_ptr(fptr32
);
940 if (put_user(flen
, &u_fprog64
->len
) ||
941 put_user(fptr64
, &u_fprog64
->filter
))
944 if (cmd
== PPPIOCSPASS32
)
949 return sys_ioctl(fd
, cmd
, (unsigned long) u_fprog64
);
952 struct ppp_option_data32
{
955 compat_int_t transmit
;
957 #define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
960 compat_time_t xmit_idle
;
961 compat_time_t recv_idle
;
963 #define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
965 static int ppp_gidle(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
967 struct ppp_idle __user
*idle
;
968 struct ppp_idle32 __user
*idle32
;
969 __kernel_time_t xmit
, recv
;
972 idle
= compat_alloc_user_space(sizeof(*idle
));
973 idle32
= compat_ptr(arg
);
975 err
= sys_ioctl(fd
, PPPIOCGIDLE
, (unsigned long) idle
);
978 if (get_user(xmit
, &idle
->xmit_idle
) ||
979 get_user(recv
, &idle
->recv_idle
) ||
980 put_user(xmit
, &idle32
->xmit_idle
) ||
981 put_user(recv
, &idle32
->recv_idle
))
987 static int ppp_scompress(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
989 struct ppp_option_data __user
*odata
;
990 struct ppp_option_data32 __user
*odata32
;
994 odata
= compat_alloc_user_space(sizeof(*odata
));
995 odata32
= compat_ptr(arg
);
997 if (get_user(data
, &odata32
->ptr
))
1000 datap
= compat_ptr(data
);
1001 if (put_user(datap
, &odata
->ptr
))
1004 if (copy_in_user(&odata
->length
, &odata32
->length
,
1005 sizeof(__u32
) + sizeof(int)))
1008 return sys_ioctl(fd
, PPPIOCSCOMPRESS
, (unsigned long) odata
);
1011 static int ppp_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1017 err
= ppp_gidle(fd
, cmd
, arg
);
1020 case PPPIOCSCOMPRESS32
:
1021 err
= ppp_scompress(fd
, cmd
, arg
);
1028 printk("ppp_ioctl: Unknown cmd fd(%d) "
1029 "cmd(%08x) arg(%08x)\n",
1030 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1041 compat_long_t mt_type
;
1042 compat_long_t mt_resid
;
1043 compat_long_t mt_dsreg
;
1044 compat_long_t mt_gstat
;
1045 compat_long_t mt_erreg
;
1046 compat_daddr_t mt_fileno
;
1047 compat_daddr_t mt_blkno
;
1049 #define MTIOCGET32 _IOR('m', 2, struct mtget32)
1052 compat_long_t mt_blkno
;
1054 #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
1056 static int mt_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1058 mm_segment_t old_fs
= get_fs();
1060 struct mtget32 __user
*umget32
;
1062 struct mtpos32 __user
*upos32
;
1080 printk("mt_ioctl: Unknown cmd fd(%d) "
1081 "cmd(%08x) arg(%08x)\n",
1082 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1087 err
= sys_ioctl (fd
, kcmd
, (unsigned long)karg
);
1093 upos32
= compat_ptr(arg
);
1094 err
= __put_user(pos
.mt_blkno
, &upos32
->mt_blkno
);
1097 umget32
= compat_ptr(arg
);
1098 err
= __put_user(get
.mt_type
, &umget32
->mt_type
);
1099 err
|= __put_user(get
.mt_resid
, &umget32
->mt_resid
);
1100 err
|= __put_user(get
.mt_dsreg
, &umget32
->mt_dsreg
);
1101 err
|= __put_user(get
.mt_gstat
, &umget32
->mt_gstat
);
1102 err
|= __put_user(get
.mt_erreg
, &umget32
->mt_erreg
);
1103 err
|= __put_user(get
.mt_fileno
, &umget32
->mt_fileno
);
1104 err
|= __put_user(get
.mt_blkno
, &umget32
->mt_blkno
);
1107 return err
? -EFAULT
: 0;
1110 struct cdrom_read_audio32
{
1111 union cdrom_addr addr
;
1113 compat_int_t nframes
;
1117 struct cdrom_generic_command32
{
1118 unsigned char cmd
[CDROM_PACKET_SIZE
];
1119 compat_caddr_t buffer
;
1120 compat_uint_t buflen
;
1122 compat_caddr_t sense
;
1123 unsigned char data_direction
;
1125 compat_int_t timeout
;
1126 compat_caddr_t reserved
[1];
1129 static int cdrom_do_read_audio(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1131 struct cdrom_read_audio __user
*cdread_audio
;
1132 struct cdrom_read_audio32 __user
*cdread_audio32
;
1136 cdread_audio
= compat_alloc_user_space(sizeof(*cdread_audio
));
1137 cdread_audio32
= compat_ptr(arg
);
1139 if (copy_in_user(&cdread_audio
->addr
,
1140 &cdread_audio32
->addr
,
1141 (sizeof(*cdread_audio32
) -
1142 sizeof(compat_caddr_t
))))
1145 if (get_user(data
, &cdread_audio32
->buf
))
1147 datap
= compat_ptr(data
);
1148 if (put_user(datap
, &cdread_audio
->buf
))
1151 return sys_ioctl(fd
, cmd
, (unsigned long) cdread_audio
);
1154 static int cdrom_do_generic_command(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1156 struct cdrom_generic_command __user
*cgc
;
1157 struct cdrom_generic_command32 __user
*cgc32
;
1162 cgc
= compat_alloc_user_space(sizeof(*cgc
));
1163 cgc32
= compat_ptr(arg
);
1165 if (copy_in_user(&cgc
->cmd
, &cgc32
->cmd
, sizeof(cgc
->cmd
)) ||
1166 get_user(data
, &cgc32
->buffer
) ||
1167 put_user(compat_ptr(data
), &cgc
->buffer
) ||
1168 copy_in_user(&cgc
->buflen
, &cgc32
->buflen
,
1169 (sizeof(unsigned int) + sizeof(int))) ||
1170 get_user(data
, &cgc32
->sense
) ||
1171 put_user(compat_ptr(data
), &cgc
->sense
) ||
1172 get_user(dir
, &cgc32
->data_direction
) ||
1173 put_user(dir
, &cgc
->data_direction
) ||
1174 get_user(itmp
, &cgc32
->quiet
) ||
1175 put_user(itmp
, &cgc
->quiet
) ||
1176 get_user(itmp
, &cgc32
->timeout
) ||
1177 put_user(itmp
, &cgc
->timeout
) ||
1178 get_user(data
, &cgc32
->reserved
[0]) ||
1179 put_user(compat_ptr(data
), &cgc
->reserved
[0]))
1182 return sys_ioctl(fd
, cmd
, (unsigned long) cgc
);
1185 static int cdrom_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1190 case CDROMREADAUDIO
:
1191 err
= cdrom_do_read_audio(fd
, cmd
, arg
);
1194 case CDROM_SEND_PACKET
:
1195 err
= cdrom_do_generic_command(fd
, cmd
, arg
);
1202 printk("cdrom_ioctl: Unknown cmd fd(%d) "
1203 "cmd(%08x) arg(%08x)\n",
1204 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1213 struct loop_info32
{
1214 compat_int_t lo_number
; /* ioctl r/o */
1215 compat_dev_t lo_device
; /* ioctl r/o */
1216 compat_ulong_t lo_inode
; /* ioctl r/o */
1217 compat_dev_t lo_rdevice
; /* ioctl r/o */
1218 compat_int_t lo_offset
;
1219 compat_int_t lo_encrypt_type
;
1220 compat_int_t lo_encrypt_key_size
; /* ioctl w/o */
1221 compat_int_t lo_flags
; /* ioctl r/o */
1222 char lo_name
[LO_NAME_SIZE
];
1223 unsigned char lo_encrypt_key
[LO_KEY_SIZE
]; /* ioctl w/o */
1224 compat_ulong_t lo_init
[2];
1228 static int loop_status(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1230 mm_segment_t old_fs
= get_fs();
1232 struct loop_info32 __user
*ul
;
1235 ul
= compat_ptr(arg
);
1237 case LOOP_SET_STATUS
:
1238 err
= get_user(l
.lo_number
, &ul
->lo_number
);
1239 err
|= __get_user(l
.lo_device
, &ul
->lo_device
);
1240 err
|= __get_user(l
.lo_inode
, &ul
->lo_inode
);
1241 err
|= __get_user(l
.lo_rdevice
, &ul
->lo_rdevice
);
1242 err
|= __copy_from_user(&l
.lo_offset
, &ul
->lo_offset
,
1243 8 + (unsigned long)l
.lo_init
- (unsigned long)&l
.lo_offset
);
1248 err
= sys_ioctl (fd
, cmd
, (unsigned long)&l
);
1252 case LOOP_GET_STATUS
:
1254 err
= sys_ioctl (fd
, cmd
, (unsigned long)&l
);
1257 err
= put_user(l
.lo_number
, &ul
->lo_number
);
1258 err
|= __put_user(l
.lo_device
, &ul
->lo_device
);
1259 err
|= __put_user(l
.lo_inode
, &ul
->lo_inode
);
1260 err
|= __put_user(l
.lo_rdevice
, &ul
->lo_rdevice
);
1261 err
|= __copy_to_user(&ul
->lo_offset
, &l
.lo_offset
,
1262 (unsigned long)l
.lo_init
- (unsigned long)&l
.lo_offset
);
1270 printk("%s: Unknown loop ioctl cmd, fd(%d) "
1271 "cmd(%08x) arg(%08lx)\n",
1272 __FUNCTION__
, fd
, cmd
, arg
);
1278 extern int tty_ioctl(struct inode
* inode
, struct file
* file
, unsigned int cmd
, unsigned long arg
);
1282 static int vt_check(struct file
*file
)
1284 struct tty_struct
*tty
;
1285 struct inode
*inode
= file
->f_dentry
->d_inode
;
1287 if (file
->f_op
->ioctl
!= tty_ioctl
)
1290 tty
= (struct tty_struct
*)file
->private_data
;
1291 if (tty_paranoia_check(tty
, inode
, "tty_ioctl"))
1294 if (tty
->driver
->ioctl
!= vt_ioctl
)
1298 * To have permissions to do most of the vt ioctls, we either have
1299 * to be the owner of the tty, or super-user.
1301 if (current
->signal
->tty
== tty
|| capable(CAP_SYS_ADMIN
))
1306 struct consolefontdesc32
{
1307 unsigned short charcount
; /* characters in font (256 or 512) */
1308 unsigned short charheight
; /* scan lines per character (1-32) */
1309 compat_caddr_t chardata
; /* font data in expanded form */
1312 static int do_fontx_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1314 struct consolefontdesc32 __user
*user_cfd
= compat_ptr(arg
);
1315 struct console_font_op op
;
1316 compat_caddr_t data
;
1319 perm
= vt_check(file
);
1320 if (perm
< 0) return perm
;
1326 op
.op
= KD_FONT_OP_SET
;
1329 if (get_user(op
.height
, &user_cfd
->charheight
) ||
1330 get_user(op
.charcount
, &user_cfd
->charcount
) ||
1331 get_user(data
, &user_cfd
->chardata
))
1333 op
.data
= compat_ptr(data
);
1334 return con_font_op(vc_cons
[fg_console
].d
, &op
);
1336 op
.op
= KD_FONT_OP_GET
;
1339 if (get_user(op
.height
, &user_cfd
->charheight
) ||
1340 get_user(op
.charcount
, &user_cfd
->charcount
) ||
1341 get_user(data
, &user_cfd
->chardata
))
1345 op
.data
= compat_ptr(data
);
1346 i
= con_font_op(vc_cons
[fg_console
].d
, &op
);
1349 if (put_user(op
.height
, &user_cfd
->charheight
) ||
1350 put_user(op
.charcount
, &user_cfd
->charcount
) ||
1351 put_user((compat_caddr_t
)(unsigned long)op
.data
,
1352 &user_cfd
->chardata
))
1359 struct console_font_op32
{
1360 compat_uint_t op
; /* operation code KD_FONT_OP_* */
1361 compat_uint_t flags
; /* KD_FONT_FLAG_* */
1362 compat_uint_t width
, height
; /* font size */
1363 compat_uint_t charcount
;
1364 compat_caddr_t data
; /* font data with height fixed to 32 */
1367 static int do_kdfontop_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1369 struct console_font_op op
;
1370 struct console_font_op32 __user
*fontop
= compat_ptr(arg
);
1371 int perm
= vt_check(file
), i
;
1374 if (perm
< 0) return perm
;
1376 if (copy_from_user(&op
, fontop
, sizeof(struct console_font_op32
)))
1378 if (!perm
&& op
.op
!= KD_FONT_OP_GET
)
1380 op
.data
= compat_ptr(((struct console_font_op32
*)&op
)->data
);
1381 op
.flags
|= KD_FONT_FLAG_OLD
;
1382 vc
= ((struct tty_struct
*)file
->private_data
)->driver_data
;
1383 i
= con_font_op(vc
, &op
);
1386 ((struct console_font_op32
*)&op
)->data
= (unsigned long)op
.data
;
1387 if (copy_to_user(fontop
, &op
, sizeof(struct console_font_op32
)))
1392 struct unimapdesc32
{
1393 unsigned short entry_ct
;
1394 compat_caddr_t entries
;
1397 static int do_unimap_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1399 struct unimapdesc32 tmp
;
1400 struct unimapdesc32 __user
*user_ud
= compat_ptr(arg
);
1401 int perm
= vt_check(file
);
1403 if (perm
< 0) return perm
;
1404 if (copy_from_user(&tmp
, user_ud
, sizeof tmp
))
1408 if (!perm
) return -EPERM
;
1409 return con_set_unimap(vc_cons
[fg_console
].d
, tmp
.entry_ct
, compat_ptr(tmp
.entries
));
1411 return con_get_unimap(vc_cons
[fg_console
].d
, tmp
.entry_ct
, &(user_ud
->entry_ct
), compat_ptr(tmp
.entries
));
1416 #endif /* CONFIG_VT */
1418 static int do_smb_getmountuid(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1420 mm_segment_t old_fs
= get_fs();
1421 __kernel_uid_t kuid
;
1424 cmd
= SMB_IOC_GETMOUNTUID
;
1427 err
= sys_ioctl(fd
, cmd
, (unsigned long)&kuid
);
1431 err
= put_user(kuid
, (compat_uid_t __user
*)compat_ptr(arg
));
1436 struct atmif_sioc32
{
1437 compat_int_t number
;
1438 compat_int_t length
;
1442 struct atm_iobuf32
{
1443 compat_int_t length
;
1444 compat_caddr_t buffer
;
1447 #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
1448 #define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
1449 #define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
1450 #define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
1451 #define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
1452 #define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
1453 #define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
1454 #define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
1455 #define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
1456 #define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
1457 #define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
1458 #define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
1459 #define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
1460 #define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
1461 #define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
1462 #define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
1463 #define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
1468 } atm_ioctl_map
[] = {
1469 { ATM_GETLINKRATE32
, ATM_GETLINKRATE
},
1470 { ATM_GETNAMES32
, ATM_GETNAMES
},
1471 { ATM_GETTYPE32
, ATM_GETTYPE
},
1472 { ATM_GETESI32
, ATM_GETESI
},
1473 { ATM_GETADDR32
, ATM_GETADDR
},
1474 { ATM_RSTADDR32
, ATM_RSTADDR
},
1475 { ATM_ADDADDR32
, ATM_ADDADDR
},
1476 { ATM_DELADDR32
, ATM_DELADDR
},
1477 { ATM_GETCIRANGE32
, ATM_GETCIRANGE
},
1478 { ATM_SETCIRANGE32
, ATM_SETCIRANGE
},
1479 { ATM_SETESI32
, ATM_SETESI
},
1480 { ATM_SETESIF32
, ATM_SETESIF
},
1481 { ATM_GETSTAT32
, ATM_GETSTAT
},
1482 { ATM_GETSTATZ32
, ATM_GETSTATZ
},
1483 { ATM_GETLOOP32
, ATM_GETLOOP
},
1484 { ATM_SETLOOP32
, ATM_SETLOOP
},
1485 { ATM_QUERYLOOP32
, ATM_QUERYLOOP
}
1488 #define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
1491 static int do_atm_iobuf(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1493 struct atm_iobuf __user
*iobuf
;
1494 struct atm_iobuf32 __user
*iobuf32
;
1499 iobuf
= compat_alloc_user_space(sizeof(*iobuf
));
1500 iobuf32
= compat_ptr(arg
);
1502 if (get_user(len
, &iobuf32
->length
) ||
1503 get_user(data
, &iobuf32
->buffer
))
1505 datap
= compat_ptr(data
);
1506 if (put_user(len
, &iobuf
->length
) ||
1507 put_user(datap
, &iobuf
->buffer
))
1510 err
= sys_ioctl(fd
, cmd
, (unsigned long)iobuf
);
1513 if (copy_in_user(&iobuf32
->length
, &iobuf
->length
,
1521 static int do_atmif_sioc(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1523 struct atmif_sioc __user
*sioc
;
1524 struct atmif_sioc32 __user
*sioc32
;
1529 sioc
= compat_alloc_user_space(sizeof(*sioc
));
1530 sioc32
= compat_ptr(arg
);
1532 if (copy_in_user(&sioc
->number
, &sioc32
->number
, 2 * sizeof(int)) ||
1533 get_user(data
, &sioc32
->arg
))
1535 datap
= compat_ptr(data
);
1536 if (put_user(datap
, &sioc
->arg
))
1539 err
= sys_ioctl(fd
, cmd
, (unsigned long) sioc
);
1542 if (copy_in_user(&sioc32
->length
, &sioc
->length
,
1549 static int do_atm_ioctl(unsigned int fd
, unsigned int cmd32
, unsigned long arg
)
1552 unsigned int cmd
= 0;
1556 case SONET_GETSTATZ
:
1560 case SONET_SETFRAMING
:
1561 case SONET_GETFRAMING
:
1562 case SONET_GETFRSENSE
:
1563 return do_atmif_sioc(fd
, cmd32
, arg
);
1566 for (i
= 0; i
< NR_ATM_IOCTL
; i
++) {
1567 if (cmd32
== atm_ioctl_map
[i
].cmd32
) {
1568 cmd
= atm_ioctl_map
[i
].cmd
;
1572 if (i
== NR_ATM_IOCTL
)
1577 return do_atm_iobuf(fd
, cmd
, arg
);
1579 case ATM_GETLINKRATE
:
1586 case ATM_GETCIRANGE
:
1587 case ATM_SETCIRANGE
:
1595 return do_atmif_sioc(fd
, cmd
, arg
);
1601 static __attribute_used__
int
1602 ret_einval(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1607 static int broken_blkgetsize(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1609 /* The mkswap binary hard codes it to Intel value :-((( */
1610 return w_long(fd
, BLKGETSIZE
, arg
);
1613 struct blkpg_ioctl_arg32
{
1616 compat_int_t datalen
;
1617 compat_caddr_t data
;
1620 static int blkpg_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1622 struct blkpg_ioctl_arg32 __user
*ua32
= compat_ptr(arg
);
1623 struct blkpg_ioctl_arg __user
*a
= compat_alloc_user_space(sizeof(*a
));
1624 compat_caddr_t udata
;
1628 err
= get_user(n
, &ua32
->op
);
1629 err
|= put_user(n
, &a
->op
);
1630 err
|= get_user(n
, &ua32
->flags
);
1631 err
|= put_user(n
, &a
->flags
);
1632 err
|= get_user(n
, &ua32
->datalen
);
1633 err
|= put_user(n
, &a
->datalen
);
1634 err
|= get_user(udata
, &ua32
->data
);
1635 err
|= put_user(compat_ptr(udata
), &a
->data
);
1639 return sys_ioctl(fd
, cmd
, (unsigned long)a
);
1642 static int ioc_settimeout(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1644 return rw_long(fd
, AUTOFS_IOC_SETTIMEOUT
, arg
);
1647 /* Fix sizeof(sizeof()) breakage */
1648 #define BLKBSZGET_32 _IOR(0x12,112,int)
1649 #define BLKBSZSET_32 _IOW(0x12,113,int)
1650 #define BLKGETSIZE64_32 _IOR(0x12,114,int)
1652 static int do_blkbszget(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1654 return sys_ioctl(fd
, BLKBSZGET
, (unsigned long)compat_ptr(arg
));
1657 static int do_blkbszset(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1659 return sys_ioctl(fd
, BLKBSZSET
, (unsigned long)compat_ptr(arg
));
1662 static int do_blkgetsize64(unsigned int fd
, unsigned int cmd
,
1665 return sys_ioctl(fd
, BLKGETSIZE64
, (unsigned long)compat_ptr(arg
));
1668 /* Bluetooth ioctls */
1669 #define HCIUARTSETPROTO _IOW('U', 200, int)
1670 #define HCIUARTGETPROTO _IOR('U', 201, int)
1672 #define BNEPCONNADD _IOW('B', 200, int)
1673 #define BNEPCONNDEL _IOW('B', 201, int)
1674 #define BNEPGETCONNLIST _IOR('B', 210, int)
1675 #define BNEPGETCONNINFO _IOR('B', 211, int)
1677 #define CMTPCONNADD _IOW('C', 200, int)
1678 #define CMTPCONNDEL _IOW('C', 201, int)
1679 #define CMTPGETCONNLIST _IOR('C', 210, int)
1680 #define CMTPGETCONNINFO _IOR('C', 211, int)
1682 #define HIDPCONNADD _IOW('H', 200, int)
1683 #define HIDPCONNDEL _IOW('H', 201, int)
1684 #define HIDPGETCONNLIST _IOR('H', 210, int)
1685 #define HIDPGETCONNINFO _IOR('H', 211, int)
1687 struct floppy_struct32
{
1691 compat_uint_t track
;
1692 compat_uint_t stretch
;
1695 unsigned char spec1
;
1696 unsigned char fmt_gap
;
1697 const compat_caddr_t name
;
1700 struct floppy_drive_params32
{
1702 compat_ulong_t max_dtr
;
1706 compat_ulong_t spinup
;
1707 compat_ulong_t spindown
;
1708 unsigned char spindown_offset
;
1709 unsigned char select_delay
;
1711 unsigned char tracks
;
1712 compat_ulong_t timeout
;
1713 unsigned char interleave_sect
;
1714 struct floppy_max_errors max_errors
;
1717 short autodetect
[8];
1718 compat_int_t checkfreq
;
1719 compat_int_t native_format
;
1722 struct floppy_drive_struct32
{
1724 compat_ulong_t spinup_date
;
1725 compat_ulong_t select_date
;
1726 compat_ulong_t first_read_date
;
1727 short probed_format
;
1731 compat_int_t generation
;
1732 compat_int_t keep_data
;
1733 compat_int_t fd_ref
;
1734 compat_int_t fd_device
;
1735 compat_int_t last_checked
;
1736 compat_caddr_t dmabuf
;
1737 compat_int_t bufblocks
;
1740 struct floppy_fdc_state32
{
1744 unsigned char version
;
1746 compat_ulong_t address
;
1747 unsigned int rawcmd
:2;
1748 unsigned int reset
:1;
1749 unsigned int need_configure
:1;
1750 unsigned int perp_mode
:2;
1751 unsigned int has_fifo
:1;
1752 unsigned int driver_version
;
1753 unsigned char track
[4];
1756 struct floppy_write_errors32
{
1757 unsigned int write_errors
;
1758 compat_ulong_t first_error_sector
;
1759 compat_int_t first_error_generation
;
1760 compat_ulong_t last_error_sector
;
1761 compat_int_t last_error_generation
;
1762 compat_uint_t badness
;
1765 #define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
1766 #define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
1767 #define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
1768 #define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
1769 #define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
1770 #define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
1771 #define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
1772 #define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
1773 #define FDWERRORGET32 _IOR(2, 0x17, struct floppy_write_errors32)
1778 } fd_ioctl_trans_table
[] = {
1779 { FDSETPRM32
, FDSETPRM
},
1780 { FDDEFPRM32
, FDDEFPRM
},
1781 { FDGETPRM32
, FDGETPRM
},
1782 { FDSETDRVPRM32
, FDSETDRVPRM
},
1783 { FDGETDRVPRM32
, FDGETDRVPRM
},
1784 { FDGETDRVSTAT32
, FDGETDRVSTAT
},
1785 { FDPOLLDRVSTAT32
, FDPOLLDRVSTAT
},
1786 { FDGETFDCSTAT32
, FDGETFDCSTAT
},
1787 { FDWERRORGET32
, FDWERRORGET
}
1790 #define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
1792 static int fd_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1794 mm_segment_t old_fs
= get_fs();
1796 unsigned int kcmd
= 0;
1799 for (i
= 0; i
< NR_FD_IOCTL_TRANS
; i
++)
1800 if (cmd
== fd_ioctl_trans_table
[i
].cmd32
) {
1801 kcmd
= fd_ioctl_trans_table
[i
].cmd
;
1813 struct floppy_struct32 __user
*uf
;
1814 struct floppy_struct
*f
;
1816 uf
= compat_ptr(arg
);
1817 f
= karg
= kmalloc(sizeof(struct floppy_struct
), GFP_KERNEL
);
1820 if (cmd
== FDGETPRM32
)
1822 err
= __get_user(f
->size
, &uf
->size
);
1823 err
|= __get_user(f
->sect
, &uf
->sect
);
1824 err
|= __get_user(f
->head
, &uf
->head
);
1825 err
|= __get_user(f
->track
, &uf
->track
);
1826 err
|= __get_user(f
->stretch
, &uf
->stretch
);
1827 err
|= __get_user(f
->gap
, &uf
->gap
);
1828 err
|= __get_user(f
->rate
, &uf
->rate
);
1829 err
|= __get_user(f
->spec1
, &uf
->spec1
);
1830 err
|= __get_user(f
->fmt_gap
, &uf
->fmt_gap
);
1831 err
|= __get_user(name
, &uf
->name
);
1832 f
->name
= compat_ptr(name
);
1842 struct floppy_drive_params32 __user
*uf
;
1843 struct floppy_drive_params
*f
;
1845 uf
= compat_ptr(arg
);
1846 f
= karg
= kmalloc(sizeof(struct floppy_drive_params
), GFP_KERNEL
);
1849 if (cmd
== FDGETDRVPRM32
)
1851 err
= __get_user(f
->cmos
, &uf
->cmos
);
1852 err
|= __get_user(f
->max_dtr
, &uf
->max_dtr
);
1853 err
|= __get_user(f
->hlt
, &uf
->hlt
);
1854 err
|= __get_user(f
->hut
, &uf
->hut
);
1855 err
|= __get_user(f
->srt
, &uf
->srt
);
1856 err
|= __get_user(f
->spinup
, &uf
->spinup
);
1857 err
|= __get_user(f
->spindown
, &uf
->spindown
);
1858 err
|= __get_user(f
->spindown_offset
, &uf
->spindown_offset
);
1859 err
|= __get_user(f
->select_delay
, &uf
->select_delay
);
1860 err
|= __get_user(f
->rps
, &uf
->rps
);
1861 err
|= __get_user(f
->tracks
, &uf
->tracks
);
1862 err
|= __get_user(f
->timeout
, &uf
->timeout
);
1863 err
|= __get_user(f
->interleave_sect
, &uf
->interleave_sect
);
1864 err
|= __copy_from_user(&f
->max_errors
, &uf
->max_errors
, sizeof(f
->max_errors
));
1865 err
|= __get_user(f
->flags
, &uf
->flags
);
1866 err
|= __get_user(f
->read_track
, &uf
->read_track
);
1867 err
|= __copy_from_user(f
->autodetect
, uf
->autodetect
, sizeof(f
->autodetect
));
1868 err
|= __get_user(f
->checkfreq
, &uf
->checkfreq
);
1869 err
|= __get_user(f
->native_format
, &uf
->native_format
);
1876 case FDGETDRVSTAT32
:
1877 case FDPOLLDRVSTAT32
:
1878 karg
= kmalloc(sizeof(struct floppy_drive_struct
), GFP_KERNEL
);
1882 case FDGETFDCSTAT32
:
1883 karg
= kmalloc(sizeof(struct floppy_fdc_state
), GFP_KERNEL
);
1888 karg
= kmalloc(sizeof(struct floppy_write_errors
), GFP_KERNEL
);
1896 err
= sys_ioctl (fd
, kcmd
, (unsigned long)karg
);
1903 struct floppy_struct
*f
= karg
;
1904 struct floppy_struct32 __user
*uf
= compat_ptr(arg
);
1906 err
= __put_user(f
->size
, &uf
->size
);
1907 err
|= __put_user(f
->sect
, &uf
->sect
);
1908 err
|= __put_user(f
->head
, &uf
->head
);
1909 err
|= __put_user(f
->track
, &uf
->track
);
1910 err
|= __put_user(f
->stretch
, &uf
->stretch
);
1911 err
|= __put_user(f
->gap
, &uf
->gap
);
1912 err
|= __put_user(f
->rate
, &uf
->rate
);
1913 err
|= __put_user(f
->spec1
, &uf
->spec1
);
1914 err
|= __put_user(f
->fmt_gap
, &uf
->fmt_gap
);
1915 err
|= __put_user((u64
)f
->name
, (compat_caddr_t __user
*)&uf
->name
);
1920 struct floppy_drive_params32 __user
*uf
;
1921 struct floppy_drive_params
*f
= karg
;
1923 uf
= compat_ptr(arg
);
1924 err
= __put_user(f
->cmos
, &uf
->cmos
);
1925 err
|= __put_user(f
->max_dtr
, &uf
->max_dtr
);
1926 err
|= __put_user(f
->hlt
, &uf
->hlt
);
1927 err
|= __put_user(f
->hut
, &uf
->hut
);
1928 err
|= __put_user(f
->srt
, &uf
->srt
);
1929 err
|= __put_user(f
->spinup
, &uf
->spinup
);
1930 err
|= __put_user(f
->spindown
, &uf
->spindown
);
1931 err
|= __put_user(f
->spindown_offset
, &uf
->spindown_offset
);
1932 err
|= __put_user(f
->select_delay
, &uf
->select_delay
);
1933 err
|= __put_user(f
->rps
, &uf
->rps
);
1934 err
|= __put_user(f
->tracks
, &uf
->tracks
);
1935 err
|= __put_user(f
->timeout
, &uf
->timeout
);
1936 err
|= __put_user(f
->interleave_sect
, &uf
->interleave_sect
);
1937 err
|= __copy_to_user(&uf
->max_errors
, &f
->max_errors
, sizeof(f
->max_errors
));
1938 err
|= __put_user(f
->flags
, &uf
->flags
);
1939 err
|= __put_user(f
->read_track
, &uf
->read_track
);
1940 err
|= __copy_to_user(uf
->autodetect
, f
->autodetect
, sizeof(f
->autodetect
));
1941 err
|= __put_user(f
->checkfreq
, &uf
->checkfreq
);
1942 err
|= __put_user(f
->native_format
, &uf
->native_format
);
1945 case FDGETDRVSTAT32
:
1946 case FDPOLLDRVSTAT32
:
1948 struct floppy_drive_struct32 __user
*uf
;
1949 struct floppy_drive_struct
*f
= karg
;
1951 uf
= compat_ptr(arg
);
1952 err
= __put_user(f
->flags
, &uf
->flags
);
1953 err
|= __put_user(f
->spinup_date
, &uf
->spinup_date
);
1954 err
|= __put_user(f
->select_date
, &uf
->select_date
);
1955 err
|= __put_user(f
->first_read_date
, &uf
->first_read_date
);
1956 err
|= __put_user(f
->probed_format
, &uf
->probed_format
);
1957 err
|= __put_user(f
->track
, &uf
->track
);
1958 err
|= __put_user(f
->maxblock
, &uf
->maxblock
);
1959 err
|= __put_user(f
->maxtrack
, &uf
->maxtrack
);
1960 err
|= __put_user(f
->generation
, &uf
->generation
);
1961 err
|= __put_user(f
->keep_data
, &uf
->keep_data
);
1962 err
|= __put_user(f
->fd_ref
, &uf
->fd_ref
);
1963 err
|= __put_user(f
->fd_device
, &uf
->fd_device
);
1964 err
|= __put_user(f
->last_checked
, &uf
->last_checked
);
1965 err
|= __put_user((u64
)f
->dmabuf
, &uf
->dmabuf
);
1966 err
|= __put_user((u64
)f
->bufblocks
, &uf
->bufblocks
);
1969 case FDGETFDCSTAT32
:
1971 struct floppy_fdc_state32 __user
*uf
;
1972 struct floppy_fdc_state
*f
= karg
;
1974 uf
= compat_ptr(arg
);
1975 err
= __put_user(f
->spec1
, &uf
->spec1
);
1976 err
|= __put_user(f
->spec2
, &uf
->spec2
);
1977 err
|= __put_user(f
->dtr
, &uf
->dtr
);
1978 err
|= __put_user(f
->version
, &uf
->version
);
1979 err
|= __put_user(f
->dor
, &uf
->dor
);
1980 err
|= __put_user(f
->address
, &uf
->address
);
1981 err
|= __copy_to_user((char __user
*)&uf
->address
+ sizeof(uf
->address
),
1982 (char *)&f
->address
+ sizeof(f
->address
), sizeof(int));
1983 err
|= __put_user(f
->driver_version
, &uf
->driver_version
);
1984 err
|= __copy_to_user(uf
->track
, f
->track
, sizeof(f
->track
));
1989 struct floppy_write_errors32 __user
*uf
;
1990 struct floppy_write_errors
*f
= karg
;
1992 uf
= compat_ptr(arg
);
1993 err
= __put_user(f
->write_errors
, &uf
->write_errors
);
1994 err
|= __put_user(f
->first_error_sector
, &uf
->first_error_sector
);
1995 err
|= __put_user(f
->first_error_generation
, &uf
->first_error_generation
);
1996 err
|= __put_user(f
->last_error_sector
, &uf
->last_error_sector
);
1997 err
|= __put_user(f
->last_error_generation
, &uf
->last_error_generation
);
1998 err
|= __put_user(f
->badness
, &uf
->badness
);
2012 struct mtd_oob_buf32
{
2015 compat_caddr_t ptr
; /* unsigned char* */
2018 #define MEMWRITEOOB32 _IOWR('M',3,struct mtd_oob_buf32)
2019 #define MEMREADOOB32 _IOWR('M',4,struct mtd_oob_buf32)
2021 static int mtd_rw_oob(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2023 struct mtd_oob_buf __user
*buf
= compat_alloc_user_space(sizeof(*buf
));
2024 struct mtd_oob_buf32 __user
*buf32
= compat_ptr(arg
);
2027 unsigned int real_cmd
;
2030 real_cmd
= (cmd
== MEMREADOOB32
) ?
2031 MEMREADOOB
: MEMWRITEOOB
;
2033 if (copy_in_user(&buf
->start
, &buf32
->start
,
2035 get_user(data
, &buf32
->ptr
))
2037 datap
= compat_ptr(data
);
2038 if (put_user(datap
, &buf
->ptr
))
2041 err
= sys_ioctl(fd
, real_cmd
, (unsigned long) buf
);
2044 if (copy_in_user(&buf32
->start
, &buf
->start
,
2052 #define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
2053 #define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
2056 put_dirent32 (struct dirent
*d
, struct compat_dirent __user
*d32
)
2058 if (!access_ok(VERIFY_WRITE
, d32
, sizeof(struct compat_dirent
)))
2061 __put_user(d
->d_ino
, &d32
->d_ino
);
2062 __put_user(d
->d_off
, &d32
->d_off
);
2063 __put_user(d
->d_reclen
, &d32
->d_reclen
);
2064 if (__copy_to_user(d32
->d_name
, d
->d_name
, d
->d_reclen
))
2070 static int vfat_ioctl32(unsigned fd
, unsigned cmd
, unsigned long arg
)
2072 struct compat_dirent __user
*p
= compat_ptr(arg
);
2074 mm_segment_t oldfs
= get_fs();
2079 case VFAT_IOCTL_READDIR_BOTH32
:
2080 cmd
= VFAT_IOCTL_READDIR_BOTH
;
2082 case VFAT_IOCTL_READDIR_SHORT32
:
2083 cmd
= VFAT_IOCTL_READDIR_SHORT
;
2088 ret
= sys_ioctl(fd
,cmd
,(unsigned long)&d
);
2091 ret
|= put_dirent32(&d
[0], p
);
2092 ret
|= put_dirent32(&d
[1], p
+ 1);
2097 #define REISERFS_IOC_UNPACK32 _IOW(0xCD,1,int)
2099 static int reiserfs_ioctl32(unsigned fd
, unsigned cmd
, unsigned long ptr
)
2101 if (cmd
== REISERFS_IOC_UNPACK32
)
2102 cmd
= REISERFS_IOC_UNPACK
;
2104 return sys_ioctl(fd
,cmd
,ptr
);
2107 struct raw32_config_request
2109 compat_int_t raw_minor
;
2112 } __attribute__((packed
));
2114 static int get_raw32_request(struct raw_config_request
*req
, struct raw32_config_request __user
*user_req
)
2118 if (!access_ok(VERIFY_READ
, user_req
, sizeof(struct raw32_config_request
)))
2121 ret
= __get_user(req
->raw_minor
, &user_req
->raw_minor
);
2122 ret
|= __get_user(req
->block_major
, &user_req
->block_major
);
2123 ret
|= __get_user(req
->block_minor
, &user_req
->block_minor
);
2125 return ret
? -EFAULT
: 0;
2128 static int set_raw32_request(struct raw_config_request
*req
, struct raw32_config_request __user
*user_req
)
2132 if (!access_ok(VERIFY_WRITE
, user_req
, sizeof(struct raw32_config_request
)))
2135 ret
= __put_user(req
->raw_minor
, &user_req
->raw_minor
);
2136 ret
|= __put_user(req
->block_major
, &user_req
->block_major
);
2137 ret
|= __put_user(req
->block_minor
, &user_req
->block_minor
);
2139 return ret
? -EFAULT
: 0;
2142 static int raw_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
2149 struct raw_config_request req
;
2150 struct raw32_config_request __user
*user_req
= compat_ptr(arg
);
2151 mm_segment_t oldfs
= get_fs();
2153 if ((ret
= get_raw32_request(&req
, user_req
)))
2157 ret
= sys_ioctl(fd
,cmd
,(unsigned long)&req
);
2160 if ((!ret
) && (cmd
== RAW_GETBIND
)) {
2161 ret
= set_raw32_request(&req
, user_req
);
2166 ret
= sys_ioctl(fd
, cmd
, arg
);
2172 struct serial_struct32
{
2178 compat_int_t xmit_fifo_size
;
2179 compat_int_t custom_divisor
;
2180 compat_int_t baud_base
;
2181 unsigned short close_delay
;
2183 char reserved_char
[1];
2185 unsigned short closing_wait
; /* time to wait before closing */
2186 unsigned short closing_wait2
; /* no longer used... */
2187 compat_uint_t iomem_base
;
2188 unsigned short iomem_reg_shift
;
2189 unsigned int port_high
;
2190 /* compat_ulong_t iomap_base FIXME */
2191 compat_int_t reserved
[1];
2194 static int serial_struct_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
2196 typedef struct serial_struct SS
;
2197 typedef struct serial_struct32 SS32
;
2198 struct serial_struct32 __user
*ss32
= compat_ptr(arg
);
2200 struct serial_struct ss
;
2201 mm_segment_t oldseg
= get_fs();
2204 if (cmd
== TIOCSSERIAL
) {
2205 if (!access_ok(VERIFY_READ
, ss32
, sizeof(SS32
)))
2207 if (__copy_from_user(&ss
, ss32
, offsetof(SS32
, iomem_base
)))
2209 __get_user(udata
, &ss32
->iomem_base
);
2210 ss
.iomem_base
= compat_ptr(udata
);
2211 __get_user(ss
.iomem_reg_shift
, &ss32
->iomem_reg_shift
);
2212 __get_user(ss
.port_high
, &ss32
->port_high
);
2213 ss
.iomap_base
= 0UL;
2216 err
= sys_ioctl(fd
,cmd
,(unsigned long)(&ss
));
2218 if (cmd
== TIOCGSERIAL
&& err
>= 0) {
2219 if (!access_ok(VERIFY_WRITE
, ss32
, sizeof(SS32
)))
2221 if (__copy_to_user(ss32
,&ss
,offsetof(SS32
,iomem_base
)))
2223 __put_user((unsigned long)ss
.iomem_base
>> 32 ?
2224 0xffffffff : (unsigned)(unsigned long)ss
.iomem_base
,
2226 __put_user(ss
.iomem_reg_shift
, &ss32
->iomem_reg_shift
);
2227 __put_user(ss
.port_high
, &ss32
->port_high
);
2233 struct usbdevfs_ctrltransfer32
{
2239 u32 timeout
; /* in milliseconds */
2240 compat_caddr_t data
;
2243 #define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
2245 static int do_usbdevfs_control(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2247 struct usbdevfs_ctrltransfer32 __user
*p32
= compat_ptr(arg
);
2248 struct usbdevfs_ctrltransfer __user
*p
;
2250 p
= compat_alloc_user_space(sizeof(*p
));
2251 if (copy_in_user(p
, p32
, (sizeof(*p32
) - sizeof(compat_caddr_t
))) ||
2252 get_user(udata
, &p32
->data
) ||
2253 put_user(compat_ptr(udata
), &p
->data
))
2255 return sys_ioctl(fd
, USBDEVFS_CONTROL
, (unsigned long)p
);
2259 struct usbdevfs_bulktransfer32
{
2262 compat_uint_t timeout
; /* in milliseconds */
2263 compat_caddr_t data
;
2266 #define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
2268 static int do_usbdevfs_bulk(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2270 struct usbdevfs_bulktransfer32 __user
*p32
= compat_ptr(arg
);
2271 struct usbdevfs_bulktransfer __user
*p
;
2273 compat_caddr_t addr
;
2275 p
= compat_alloc_user_space(sizeof(*p
));
2277 if (get_user(n
, &p32
->ep
) || put_user(n
, &p
->ep
) ||
2278 get_user(n
, &p32
->len
) || put_user(n
, &p
->len
) ||
2279 get_user(n
, &p32
->timeout
) || put_user(n
, &p
->timeout
) ||
2280 get_user(addr
, &p32
->data
) || put_user(compat_ptr(addr
), &p
->data
))
2283 return sys_ioctl(fd
, USBDEVFS_BULK
, (unsigned long)p
);
2288 * USBDEVFS_SUBMITURB, USBDEVFS_REAPURB and USBDEVFS_REAPURBNDELAY
2289 * are handled in usbdevfs core. -Christopher Li
2292 struct usbdevfs_disconnectsignal32
{
2294 compat_caddr_t context
;
2297 #define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
2299 static int do_usbdevfs_discsignal(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2301 struct usbdevfs_disconnectsignal kdis
;
2302 struct usbdevfs_disconnectsignal32 __user
*udis
;
2303 mm_segment_t old_fs
;
2307 udis
= compat_ptr(arg
);
2309 if (get_user(kdis
.signr
, &udis
->signr
) ||
2310 __get_user(uctx
, &udis
->context
))
2313 kdis
.context
= compat_ptr(uctx
);
2317 err
= sys_ioctl(fd
, USBDEVFS_DISCSIGNAL
, (unsigned long) &kdis
);
2334 struct i2c_rdwr_ioctl_data32
{
2335 compat_caddr_t msgs
; /* struct i2c_msg __user *msgs */
2339 struct i2c_smbus_ioctl_data32
{
2343 compat_caddr_t data
; /* union i2c_smbus_data *data */
2346 struct i2c_rdwr_aligned
{
2347 struct i2c_rdwr_ioctl_data cmd
;
2348 struct i2c_msg msgs
[0];
2351 static int do_i2c_rdwr_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2353 struct i2c_rdwr_ioctl_data32 __user
*udata
= compat_ptr(arg
);
2354 struct i2c_rdwr_aligned __user
*tdata
;
2355 struct i2c_msg __user
*tmsgs
;
2356 struct i2c_msg32 __user
*umsgs
;
2357 compat_caddr_t datap
;
2360 if (get_user(nmsgs
, &udata
->nmsgs
))
2362 if (nmsgs
> I2C_RDRW_IOCTL_MAX_MSGS
)
2365 if (get_user(datap
, &udata
->msgs
))
2367 umsgs
= compat_ptr(datap
);
2369 tdata
= compat_alloc_user_space(sizeof(*tdata
) +
2370 nmsgs
* sizeof(struct i2c_msg
));
2371 tmsgs
= &tdata
->msgs
[0];
2373 if (put_user(nmsgs
, &tdata
->cmd
.nmsgs
) ||
2374 put_user(tmsgs
, &tdata
->cmd
.msgs
))
2377 for (i
= 0; i
< nmsgs
; i
++) {
2378 if (copy_in_user(&tmsgs
[i
].addr
, &umsgs
[i
].addr
, 3*sizeof(u16
)))
2380 if (get_user(datap
, &umsgs
[i
].buf
) ||
2381 put_user(compat_ptr(datap
), &tmsgs
[i
].buf
))
2384 return sys_ioctl(fd
, cmd
, (unsigned long)tdata
);
2387 static int do_i2c_smbus_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2389 struct i2c_smbus_ioctl_data __user
*tdata
;
2390 struct i2c_smbus_ioctl_data32 __user
*udata
;
2391 compat_caddr_t datap
;
2393 tdata
= compat_alloc_user_space(sizeof(*tdata
));
2396 if (!access_ok(VERIFY_WRITE
, tdata
, sizeof(*tdata
)))
2399 udata
= compat_ptr(arg
);
2400 if (!access_ok(VERIFY_READ
, udata
, sizeof(*udata
)))
2403 if (__copy_in_user(&tdata
->read_write
, &udata
->read_write
, 2 * sizeof(u8
)))
2405 if (__copy_in_user(&tdata
->size
, &udata
->size
, 2 * sizeof(u32
)))
2407 if (__get_user(datap
, &udata
->data
) ||
2408 __put_user(compat_ptr(datap
), &tdata
->data
))
2411 return sys_ioctl(fd
, cmd
, (unsigned long)tdata
);
2414 struct compat_iw_point
{
2415 compat_caddr_t pointer
;
2420 static int do_wireless_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2422 struct iwreq __user
*iwr
;
2423 struct iwreq __user
*iwr_u
;
2424 struct iw_point __user
*iwp
;
2425 struct compat_iw_point __user
*iwp_u
;
2426 compat_caddr_t pointer
;
2427 __u16 length
, flags
;
2429 iwr_u
= compat_ptr(arg
);
2430 iwp_u
= (struct compat_iw_point __user
*) &iwr_u
->u
.data
;
2431 iwr
= compat_alloc_user_space(sizeof(*iwr
));
2437 if (!access_ok(VERIFY_WRITE
, iwr
, sizeof(*iwr
)))
2440 if (__copy_in_user(&iwr
->ifr_ifrn
.ifrn_name
[0],
2441 &iwr_u
->ifr_ifrn
.ifrn_name
[0],
2442 sizeof(iwr
->ifr_ifrn
.ifrn_name
)))
2445 if (__get_user(pointer
, &iwp_u
->pointer
) ||
2446 __get_user(length
, &iwp_u
->length
) ||
2447 __get_user(flags
, &iwp_u
->flags
))
2450 if (__put_user(compat_ptr(pointer
), &iwp
->pointer
) ||
2451 __put_user(length
, &iwp
->length
) ||
2452 __put_user(flags
, &iwp
->flags
))
2455 return sys_ioctl(fd
, cmd
, (unsigned long) iwr
);
2458 /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
2459 * for some operations; this forces use of the newer bridge-utils that
2460 * use compatiable ioctls
2462 static int old_bridge_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2466 if (get_user(tmp
, (u32 __user
*) arg
))
2468 if (tmp
== BRCTL_GET_VERSION
)
2469 return BRCTL_VERSION
+ 1;
2473 #define RTC_IRQP_READ32 _IOR('p', 0x0b, compat_ulong_t)
2474 #define RTC_IRQP_SET32 _IOW('p', 0x0c, compat_ulong_t)
2475 #define RTC_EPOCH_READ32 _IOR('p', 0x0d, compat_ulong_t)
2476 #define RTC_EPOCH_SET32 _IOW('p', 0x0e, compat_ulong_t)
2478 static int rtc_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
2480 mm_segment_t oldfs
= get_fs();
2481 compat_ulong_t val32
;
2486 case RTC_IRQP_READ32
:
2487 case RTC_EPOCH_READ32
:
2489 ret
= sys_ioctl(fd
, (cmd
== RTC_IRQP_READ32
) ?
2490 RTC_IRQP_READ
: RTC_EPOCH_READ
,
2491 (unsigned long)&kval
);
2496 return put_user(val32
, (unsigned int __user
*)arg
);
2497 case RTC_IRQP_SET32
:
2498 case RTC_EPOCH_SET32
:
2499 ret
= get_user(val32
, (unsigned int __user
*)arg
);
2505 ret
= sys_ioctl(fd
, (cmd
== RTC_IRQP_SET32
) ?
2506 RTC_IRQP_SET
: RTC_EPOCH_SET
,
2507 (unsigned long)&kval
);
2512 return -ENOIOCTLCMD
;
2516 #if defined(CONFIG_NCP_FS) || defined(CONFIG_NCP_FS_MODULE)
2517 struct ncp_ioctl_request_32
{
2520 compat_caddr_t data
;
2523 struct ncp_fs_info_v2_32
{
2537 struct ncp_objectname_ioctl_32
2540 u32 object_name_len
;
2541 compat_caddr_t object_name
; /* an userspace data, in most cases user name */
2544 struct ncp_privatedata_ioctl_32
2547 compat_caddr_t data
; /* ~1000 for NDS */
2550 #define NCP_IOC_NCPREQUEST_32 _IOR('n', 1, struct ncp_ioctl_request_32)
2551 #define NCP_IOC_GETMOUNTUID2_32 _IOW('n', 2, u32)
2552 #define NCP_IOC_GET_FS_INFO_V2_32 _IOWR('n', 4, struct ncp_fs_info_v2_32)
2553 #define NCP_IOC_GETOBJECTNAME_32 _IOWR('n', 9, struct ncp_objectname_ioctl_32)
2554 #define NCP_IOC_SETOBJECTNAME_32 _IOR('n', 9, struct ncp_objectname_ioctl_32)
2555 #define NCP_IOC_GETPRIVATEDATA_32 _IOWR('n', 10, struct ncp_privatedata_ioctl_32)
2556 #define NCP_IOC_SETPRIVATEDATA_32 _IOR('n', 10, struct ncp_privatedata_ioctl_32)
2558 static int do_ncp_ncprequest(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2560 struct ncp_ioctl_request_32 n32
;
2561 struct ncp_ioctl_request __user
*p
= compat_alloc_user_space(sizeof(*p
));
2563 if (copy_from_user(&n32
, compat_ptr(arg
), sizeof(n32
)) ||
2564 put_user(n32
.function
, &p
->function
) ||
2565 put_user(n32
.size
, &p
->size
) ||
2566 put_user(compat_ptr(n32
.data
), &p
->data
))
2569 return sys_ioctl(fd
, NCP_IOC_NCPREQUEST
, (unsigned long)p
);
2572 static int do_ncp_getmountuid2(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2574 mm_segment_t old_fs
= get_fs();
2575 __kernel_uid_t kuid
;
2578 cmd
= NCP_IOC_GETMOUNTUID2
;
2581 err
= sys_ioctl(fd
, cmd
, (unsigned long)&kuid
);
2585 err
= put_user(kuid
,
2586 (unsigned int __user
*) compat_ptr(arg
));
2591 static int do_ncp_getfsinfo2(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2593 mm_segment_t old_fs
= get_fs();
2594 struct ncp_fs_info_v2_32 n32
;
2595 struct ncp_fs_info_v2 n
;
2598 if (copy_from_user(&n32
, compat_ptr(arg
), sizeof(n32
)))
2600 if (n32
.version
!= NCP_GET_FS_INFO_VERSION_V2
)
2602 n
.version
= NCP_GET_FS_INFO_VERSION_V2
;
2605 err
= sys_ioctl(fd
, NCP_IOC_GET_FS_INFO_V2
, (unsigned long)&n
);
2609 n32
.version
= n
.version
;
2610 n32
.mounted_uid
= n
.mounted_uid
;
2611 n32
.connection
= n
.connection
;
2612 n32
.buffer_size
= n
.buffer_size
;
2613 n32
.volume_number
= n
.volume_number
;
2614 n32
.directory_id
= n
.directory_id
;
2615 n32
.dummy1
= n
.dummy1
;
2616 n32
.dummy2
= n
.dummy2
;
2617 n32
.dummy3
= n
.dummy3
;
2618 err
= copy_to_user(compat_ptr(arg
), &n32
, sizeof(n32
)) ? -EFAULT
: 0;
2623 static int do_ncp_getobjectname(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2625 struct ncp_objectname_ioctl_32 n32
, __user
*p32
= compat_ptr(arg
);
2626 struct ncp_objectname_ioctl __user
*p
= compat_alloc_user_space(sizeof(*p
));
2631 if (copy_from_user(&n32
, p32
, sizeof(n32
)) ||
2632 put_user(n32
.object_name_len
, &p
->object_name_len
) ||
2633 put_user(compat_ptr(n32
.object_name
), &p
->object_name
))
2636 err
= sys_ioctl(fd
, NCP_IOC_GETOBJECTNAME
, (unsigned long)p
);
2640 if (get_user(auth_type
, &p
->auth_type
) ||
2641 put_user(auth_type
, &p32
->auth_type
) ||
2642 get_user(name_len
, &p
->object_name_len
) ||
2643 put_user(name_len
, &p32
->object_name_len
))
2649 static int do_ncp_setobjectname(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2651 struct ncp_objectname_ioctl_32 n32
, __user
*p32
= compat_ptr(arg
);
2652 struct ncp_objectname_ioctl __user
*p
= compat_alloc_user_space(sizeof(*p
));
2654 if (copy_from_user(&n32
, p32
, sizeof(n32
)) ||
2655 put_user(n32
.auth_type
, &p
->auth_type
) ||
2656 put_user(n32
.object_name_len
, &p
->object_name_len
) ||
2657 put_user(compat_ptr(n32
.object_name
), &p
->object_name
))
2660 return sys_ioctl(fd
, NCP_IOC_SETOBJECTNAME
, (unsigned long)p
);
2663 static int do_ncp_getprivatedata(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2665 struct ncp_privatedata_ioctl_32 n32
, __user
*p32
= compat_ptr(arg
);
2666 struct ncp_privatedata_ioctl __user
*p
=
2667 compat_alloc_user_space(sizeof(*p
));
2671 if (copy_from_user(&n32
, p32
, sizeof(n32
)) ||
2672 put_user(n32
.len
, &p
->len
) ||
2673 put_user(compat_ptr(n32
.data
), &p
->data
))
2676 err
= sys_ioctl(fd
, NCP_IOC_GETPRIVATEDATA
, (unsigned long)p
);
2680 if (get_user(len
, &p
->len
) ||
2681 put_user(len
, &p32
->len
))
2687 static int do_ncp_setprivatedata(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2689 struct ncp_privatedata_ioctl_32 n32
;
2690 struct ncp_privatedata_ioctl_32 __user
*p32
= compat_ptr(arg
);
2691 struct ncp_privatedata_ioctl __user
*p
=
2692 compat_alloc_user_space(sizeof(*p
));
2694 if (copy_from_user(&n32
, p32
, sizeof(n32
)) ||
2695 put_user(n32
.len
, &p
->len
) ||
2696 put_user(compat_ptr(n32
.data
), &p
->data
))
2699 return sys_ioctl(fd
, NCP_IOC_SETPRIVATEDATA
, (unsigned long)p
);
2703 #define HANDLE_IOCTL(cmd,handler) \
2704 { (cmd), (ioctl_trans_handler_t)(handler) },
2706 /* pointer to compatible structure or no argument */
2707 #define COMPATIBLE_IOCTL(cmd) \
2708 { (cmd), do_ioctl32_pointer },
2710 /* argument is an unsigned long integer, not a pointer */
2711 #define ULONG_IOCTL(cmd) \
2712 { (cmd), (ioctl_trans_handler_t)sys_ioctl },
2715 struct ioctl_trans ioctl_start
[] = {
2716 #include <linux/compat_ioctl.h>
2717 HANDLE_IOCTL(MEMREADOOB32
, mtd_rw_oob
)
2718 HANDLE_IOCTL(MEMWRITEOOB32
, mtd_rw_oob
)
2720 HANDLE_IOCTL(SIOCGIFNAME
, dev_ifname32
)
2721 HANDLE_IOCTL(SIOCGIFCONF
, dev_ifconf
)
2722 HANDLE_IOCTL(SIOCGIFFLAGS
, dev_ifsioc
)
2723 HANDLE_IOCTL(SIOCSIFFLAGS
, dev_ifsioc
)
2724 HANDLE_IOCTL(SIOCGIFMETRIC
, dev_ifsioc
)
2725 HANDLE_IOCTL(SIOCSIFMETRIC
, dev_ifsioc
)
2726 HANDLE_IOCTL(SIOCGIFMTU
, dev_ifsioc
)
2727 HANDLE_IOCTL(SIOCSIFMTU
, dev_ifsioc
)
2728 HANDLE_IOCTL(SIOCGIFMEM
, dev_ifsioc
)
2729 HANDLE_IOCTL(SIOCSIFMEM
, dev_ifsioc
)
2730 HANDLE_IOCTL(SIOCGIFHWADDR
, dev_ifsioc
)
2731 HANDLE_IOCTL(SIOCSIFHWADDR
, dev_ifsioc
)
2732 HANDLE_IOCTL(SIOCADDMULTI
, dev_ifsioc
)
2733 HANDLE_IOCTL(SIOCDELMULTI
, dev_ifsioc
)
2734 HANDLE_IOCTL(SIOCGIFINDEX
, dev_ifsioc
)
2735 HANDLE_IOCTL(SIOCGIFMAP
, dev_ifsioc
)
2736 HANDLE_IOCTL(SIOCSIFMAP
, dev_ifsioc
)
2737 HANDLE_IOCTL(SIOCGIFADDR
, dev_ifsioc
)
2738 HANDLE_IOCTL(SIOCSIFADDR
, dev_ifsioc
)
2740 /* ioctls used by appletalk ddp.c */
2741 HANDLE_IOCTL(SIOCATALKDIFADDR
, dev_ifsioc
)
2742 HANDLE_IOCTL(SIOCDIFADDR
, dev_ifsioc
)
2743 HANDLE_IOCTL(SIOCSARP
, dev_ifsioc
)
2744 HANDLE_IOCTL(SIOCDARP
, dev_ifsioc
)
2746 HANDLE_IOCTL(SIOCGIFBRDADDR
, dev_ifsioc
)
2747 HANDLE_IOCTL(SIOCSIFBRDADDR
, dev_ifsioc
)
2748 HANDLE_IOCTL(SIOCGIFDSTADDR
, dev_ifsioc
)
2749 HANDLE_IOCTL(SIOCSIFDSTADDR
, dev_ifsioc
)
2750 HANDLE_IOCTL(SIOCGIFNETMASK
, dev_ifsioc
)
2751 HANDLE_IOCTL(SIOCSIFNETMASK
, dev_ifsioc
)
2752 HANDLE_IOCTL(SIOCSIFPFLAGS
, dev_ifsioc
)
2753 HANDLE_IOCTL(SIOCGIFPFLAGS
, dev_ifsioc
)
2754 HANDLE_IOCTL(SIOCGIFTXQLEN
, dev_ifsioc
)
2755 HANDLE_IOCTL(SIOCSIFTXQLEN
, dev_ifsioc
)
2756 HANDLE_IOCTL(TUNSETIFF
, dev_ifsioc
)
2757 HANDLE_IOCTL(SIOCETHTOOL
, ethtool_ioctl
)
2758 HANDLE_IOCTL(SIOCBONDENSLAVE
, bond_ioctl
)
2759 HANDLE_IOCTL(SIOCBONDRELEASE
, bond_ioctl
)
2760 HANDLE_IOCTL(SIOCBONDSETHWADDR
, bond_ioctl
)
2761 HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY
, bond_ioctl
)
2762 HANDLE_IOCTL(SIOCBONDINFOQUERY
, bond_ioctl
)
2763 HANDLE_IOCTL(SIOCBONDCHANGEACTIVE
, bond_ioctl
)
2764 HANDLE_IOCTL(SIOCADDRT
, routing_ioctl
)
2765 HANDLE_IOCTL(SIOCDELRT
, routing_ioctl
)
2766 HANDLE_IOCTL(SIOCBRADDIF
, dev_ifsioc
)
2767 HANDLE_IOCTL(SIOCBRDELIF
, dev_ifsioc
)
2768 /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
2769 HANDLE_IOCTL(SIOCRTMSG
, ret_einval
)
2770 HANDLE_IOCTL(SIOCGSTAMP
, do_siocgstamp
)
2772 HANDLE_IOCTL(HDIO_GETGEO
, hdio_getgeo
)
2773 HANDLE_IOCTL(BLKRAGET
, w_long
)
2774 HANDLE_IOCTL(BLKGETSIZE
, w_long
)
2775 HANDLE_IOCTL(0x1260, broken_blkgetsize
)
2776 HANDLE_IOCTL(BLKFRAGET
, w_long
)
2777 HANDLE_IOCTL(BLKSECTGET
, w_long
)
2778 HANDLE_IOCTL(BLKPG
, blkpg_ioctl_trans
)
2779 HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS
, hdio_ioctl_trans
)
2780 HANDLE_IOCTL(HDIO_GET_UNMASKINTR
, hdio_ioctl_trans
)
2781 HANDLE_IOCTL(HDIO_GET_DMA
, hdio_ioctl_trans
)
2782 HANDLE_IOCTL(HDIO_GET_32BIT
, hdio_ioctl_trans
)
2783 HANDLE_IOCTL(HDIO_GET_MULTCOUNT
, hdio_ioctl_trans
)
2784 HANDLE_IOCTL(HDIO_GET_NOWERR
, hdio_ioctl_trans
)
2785 HANDLE_IOCTL(HDIO_GET_NICE
, hdio_ioctl_trans
)
2786 HANDLE_IOCTL(FDSETPRM32
, fd_ioctl_trans
)
2787 HANDLE_IOCTL(FDDEFPRM32
, fd_ioctl_trans
)
2788 HANDLE_IOCTL(FDGETPRM32
, fd_ioctl_trans
)
2789 HANDLE_IOCTL(FDSETDRVPRM32
, fd_ioctl_trans
)
2790 HANDLE_IOCTL(FDGETDRVPRM32
, fd_ioctl_trans
)
2791 HANDLE_IOCTL(FDGETDRVSTAT32
, fd_ioctl_trans
)
2792 HANDLE_IOCTL(FDPOLLDRVSTAT32
, fd_ioctl_trans
)
2793 HANDLE_IOCTL(FDGETFDCSTAT32
, fd_ioctl_trans
)
2794 HANDLE_IOCTL(FDWERRORGET32
, fd_ioctl_trans
)
2795 HANDLE_IOCTL(SG_IO
,sg_ioctl_trans
)
2796 HANDLE_IOCTL(PPPIOCGIDLE32
, ppp_ioctl_trans
)
2797 HANDLE_IOCTL(PPPIOCSCOMPRESS32
, ppp_ioctl_trans
)
2798 HANDLE_IOCTL(PPPIOCSPASS32
, ppp_sock_fprog_ioctl_trans
)
2799 HANDLE_IOCTL(PPPIOCSACTIVE32
, ppp_sock_fprog_ioctl_trans
)
2800 HANDLE_IOCTL(MTIOCGET32
, mt_ioctl_trans
)
2801 HANDLE_IOCTL(MTIOCPOS32
, mt_ioctl_trans
)
2802 HANDLE_IOCTL(CDROMREADAUDIO
, cdrom_ioctl_trans
)
2803 HANDLE_IOCTL(CDROM_SEND_PACKET
, cdrom_ioctl_trans
)
2804 HANDLE_IOCTL(LOOP_SET_STATUS
, loop_status
)
2805 HANDLE_IOCTL(LOOP_GET_STATUS
, loop_status
)
2806 #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
2807 HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32
, ioc_settimeout
)
2809 HANDLE_IOCTL(PIO_FONTX
, do_fontx_ioctl
)
2810 HANDLE_IOCTL(GIO_FONTX
, do_fontx_ioctl
)
2811 HANDLE_IOCTL(PIO_UNIMAP
, do_unimap_ioctl
)
2812 HANDLE_IOCTL(GIO_UNIMAP
, do_unimap_ioctl
)
2813 HANDLE_IOCTL(KDFONTOP
, do_kdfontop_ioctl
)
2815 HANDLE_IOCTL(EXT2_IOC32_GETFLAGS
, do_ext2_ioctl
)
2816 HANDLE_IOCTL(EXT2_IOC32_SETFLAGS
, do_ext2_ioctl
)
2817 HANDLE_IOCTL(EXT2_IOC32_GETVERSION
, do_ext2_ioctl
)
2818 HANDLE_IOCTL(EXT2_IOC32_SETVERSION
, do_ext2_ioctl
)
2819 HANDLE_IOCTL(EXT3_IOC32_GETVERSION
, do_ext3_ioctl
)
2820 HANDLE_IOCTL(EXT3_IOC32_SETVERSION
, do_ext3_ioctl
)
2821 HANDLE_IOCTL(EXT3_IOC32_GETRSVSZ
, do_ext3_ioctl
)
2822 HANDLE_IOCTL(EXT3_IOC32_SETRSVSZ
, do_ext3_ioctl
)
2823 HANDLE_IOCTL(EXT3_IOC32_GROUP_EXTEND
, do_ext3_ioctl
)
2824 COMPATIBLE_IOCTL(EXT3_IOC_GROUP_ADD
)
2825 #ifdef CONFIG_JBD_DEBUG
2826 HANDLE_IOCTL(EXT3_IOC32_WAIT_FOR_READONLY
, do_ext3_ioctl
)
2828 /* One SMB ioctl needs translations. */
2829 #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
2830 HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32
, do_smb_getmountuid
)
2831 HANDLE_IOCTL(ATM_GETLINKRATE32
, do_atm_ioctl
)
2832 HANDLE_IOCTL(ATM_GETNAMES32
, do_atm_ioctl
)
2833 HANDLE_IOCTL(ATM_GETTYPE32
, do_atm_ioctl
)
2834 HANDLE_IOCTL(ATM_GETESI32
, do_atm_ioctl
)
2835 HANDLE_IOCTL(ATM_GETADDR32
, do_atm_ioctl
)
2836 HANDLE_IOCTL(ATM_RSTADDR32
, do_atm_ioctl
)
2837 HANDLE_IOCTL(ATM_ADDADDR32
, do_atm_ioctl
)
2838 HANDLE_IOCTL(ATM_DELADDR32
, do_atm_ioctl
)
2839 HANDLE_IOCTL(ATM_GETCIRANGE32
, do_atm_ioctl
)
2840 HANDLE_IOCTL(ATM_SETCIRANGE32
, do_atm_ioctl
)
2841 HANDLE_IOCTL(ATM_SETESI32
, do_atm_ioctl
)
2842 HANDLE_IOCTL(ATM_SETESIF32
, do_atm_ioctl
)
2843 HANDLE_IOCTL(ATM_GETSTAT32
, do_atm_ioctl
)
2844 HANDLE_IOCTL(ATM_GETSTATZ32
, do_atm_ioctl
)
2845 HANDLE_IOCTL(ATM_GETLOOP32
, do_atm_ioctl
)
2846 HANDLE_IOCTL(ATM_SETLOOP32
, do_atm_ioctl
)
2847 HANDLE_IOCTL(ATM_QUERYLOOP32
, do_atm_ioctl
)
2848 HANDLE_IOCTL(SONET_GETSTAT
, do_atm_ioctl
)
2849 HANDLE_IOCTL(SONET_GETSTATZ
, do_atm_ioctl
)
2850 HANDLE_IOCTL(SONET_GETDIAG
, do_atm_ioctl
)
2851 HANDLE_IOCTL(SONET_SETDIAG
, do_atm_ioctl
)
2852 HANDLE_IOCTL(SONET_CLRDIAG
, do_atm_ioctl
)
2853 HANDLE_IOCTL(SONET_SETFRAMING
, do_atm_ioctl
)
2854 HANDLE_IOCTL(SONET_GETFRAMING
, do_atm_ioctl
)
2855 HANDLE_IOCTL(SONET_GETFRSENSE
, do_atm_ioctl
)
2857 HANDLE_IOCTL(BLKBSZGET_32
, do_blkbszget
)
2858 HANDLE_IOCTL(BLKBSZSET_32
, do_blkbszset
)
2859 HANDLE_IOCTL(BLKGETSIZE64_32
, do_blkgetsize64
)
2861 HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32
, vfat_ioctl32
)
2862 HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32
, vfat_ioctl32
)
2863 HANDLE_IOCTL(REISERFS_IOC_UNPACK32
, reiserfs_ioctl32
)
2865 HANDLE_IOCTL(RAW_SETBIND
, raw_ioctl
)
2866 HANDLE_IOCTL(RAW_GETBIND
, raw_ioctl
)
2868 HANDLE_IOCTL(TIOCGSERIAL
, serial_struct_ioctl
)
2869 HANDLE_IOCTL(TIOCSSERIAL
, serial_struct_ioctl
)
2871 COMPATIBLE_IOCTL(TIOCGLTC
)
2872 COMPATIBLE_IOCTL(TIOCSLTC
)
2876 * For these two we have defintions in ioctls.h and/or termios.h on
2877 * some architectures but no actual implemention. Some applications
2878 * like bash call them if they are defined in the headers, so we provide
2879 * entries here to avoid syslog message spew.
2881 COMPATIBLE_IOCTL(TIOCSTART
)
2882 COMPATIBLE_IOCTL(TIOCSTOP
)
2885 HANDLE_IOCTL(USBDEVFS_CONTROL32
, do_usbdevfs_control
)
2886 HANDLE_IOCTL(USBDEVFS_BULK32
, do_usbdevfs_bulk
)
2887 HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32
, do_usbdevfs_discsignal
)
2888 COMPATIBLE_IOCTL(USBDEVFS_IOCTL32
)
2890 HANDLE_IOCTL(I2C_FUNCS
, w_long
)
2891 HANDLE_IOCTL(I2C_RDWR
, do_i2c_rdwr_ioctl
)
2892 HANDLE_IOCTL(I2C_SMBUS
, do_i2c_smbus_ioctl
)
2894 HANDLE_IOCTL(SIOCGIWRANGE
, do_wireless_ioctl
)
2895 HANDLE_IOCTL(SIOCSIWSPY
, do_wireless_ioctl
)
2896 HANDLE_IOCTL(SIOCGIWSPY
, do_wireless_ioctl
)
2897 HANDLE_IOCTL(SIOCSIWTHRSPY
, do_wireless_ioctl
)
2898 HANDLE_IOCTL(SIOCGIWTHRSPY
, do_wireless_ioctl
)
2899 HANDLE_IOCTL(SIOCGIWAPLIST
, do_wireless_ioctl
)
2900 HANDLE_IOCTL(SIOCGIWSCAN
, do_wireless_ioctl
)
2901 HANDLE_IOCTL(SIOCSIWESSID
, do_wireless_ioctl
)
2902 HANDLE_IOCTL(SIOCGIWESSID
, do_wireless_ioctl
)
2903 HANDLE_IOCTL(SIOCSIWNICKN
, do_wireless_ioctl
)
2904 HANDLE_IOCTL(SIOCGIWNICKN
, do_wireless_ioctl
)
2905 HANDLE_IOCTL(SIOCSIWENCODE
, do_wireless_ioctl
)
2906 HANDLE_IOCTL(SIOCGIWENCODE
, do_wireless_ioctl
)
2907 HANDLE_IOCTL(SIOCSIFBR
, old_bridge_ioctl
)
2908 HANDLE_IOCTL(SIOCGIFBR
, old_bridge_ioctl
)
2909 HANDLE_IOCTL(RTC_IRQP_READ32
, rtc_ioctl
)
2910 HANDLE_IOCTL(RTC_IRQP_SET32
, rtc_ioctl
)
2911 HANDLE_IOCTL(RTC_EPOCH_READ32
, rtc_ioctl
)
2912 HANDLE_IOCTL(RTC_EPOCH_SET32
, rtc_ioctl
)
2914 #if defined(CONFIG_NCP_FS) || defined(CONFIG_NCP_FS_MODULE)
2915 HANDLE_IOCTL(NCP_IOC_NCPREQUEST_32
, do_ncp_ncprequest
)
2916 HANDLE_IOCTL(NCP_IOC_GETMOUNTUID2_32
, do_ncp_getmountuid2
)
2917 HANDLE_IOCTL(NCP_IOC_GET_FS_INFO_V2_32
, do_ncp_getfsinfo2
)
2918 HANDLE_IOCTL(NCP_IOC_GETOBJECTNAME_32
, do_ncp_getobjectname
)
2919 HANDLE_IOCTL(NCP_IOC_SETOBJECTNAME_32
, do_ncp_setobjectname
)
2920 HANDLE_IOCTL(NCP_IOC_GETPRIVATEDATA_32
, do_ncp_getprivatedata
)
2921 HANDLE_IOCTL(NCP_IOC_SETPRIVATEDATA_32
, do_ncp_setprivatedata
)
2925 HANDLE_IOCTL(DMX_GET_EVENT
, do_dmx_get_event
)
2926 HANDLE_IOCTL(VIDEO_GET_EVENT
, do_video_get_event
)
2927 HANDLE_IOCTL(VIDEO_STILLPICTURE
, do_video_stillpicture
)
2928 HANDLE_IOCTL(VIDEO_SET_SPU_PALETTE
, do_video_set_spu_palette
)
2931 int ioctl_table_size
= ARRAY_SIZE(ioctl_start
);