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
14 #include <linux/config.h>
15 #include <linux/types.h>
16 #include <linux/compat.h>
17 #include <linux/kernel.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/slab.h>
24 #include <linux/hdreg.h>
25 #include <linux/raid/md.h>
27 #include <linux/dirent.h>
28 #include <linux/route.h>
29 #include <linux/in6.h>
30 #include <linux/ipv6_route.h>
31 #include <linux/skbuff.h>
32 #include <linux/netlink.h>
35 #include <linux/file.h>
37 #include <linux/ppp_defs.h>
38 #include <linux/if_ppp.h>
39 #include <linux/if_pppox.h>
40 #include <linux/mtio.h>
41 #include <linux/cdrom.h>
42 #include <linux/loop.h>
43 #include <linux/auto_fs.h>
44 #include <linux/auto_fs4.h>
45 #include <linux/devfs_fs.h>
46 #include <linux/tty.h>
47 #include <linux/vt_kern.h>
49 #include <linux/ext2_fs.h>
50 #include <linux/videodev.h>
51 #include <linux/netdevice.h>
52 #include <linux/raw.h>
53 #include <linux/smb_fs.h>
54 #include <linux/blkpg.h>
55 #include <linux/blkdev.h>
56 #include <linux/elevator.h>
57 #include <linux/rtc.h>
58 #include <linux/pci.h>
59 #include <linux/module.h>
60 #include <linux/serial.h>
61 #include <linux/reiserfs_fs.h>
62 #include <linux/if_tun.h>
63 #include <linux/ctype.h>
64 #include <linux/ioctl32.h>
65 #include <linux/syscalls.h>
66 #include <linux/ncp_fs.h>
67 #include <linux/i2c.h>
68 #include <linux/i2c-dev.h>
69 #include <linux/wireless.h>
71 #include <net/sock.h> /* siocdevprivate_ioctl */
72 #include <net/bluetooth/bluetooth.h>
73 #include <net/bluetooth/rfcomm.h>
74 #include <net/bluetooth/hci.h>
76 #include <scsi/scsi.h>
79 #include <scsi/scsi_ioctl.h>
83 #include <asm/types.h>
84 #include <asm/uaccess.h>
85 #include <linux/ethtool.h>
86 #include <linux/mii.h>
87 #include <linux/if_bonding.h>
88 #include <linux/watchdog.h>
89 #include <linux/dm-ioctl.h>
91 #include <asm/module.h>
92 #include <linux/soundcard.h>
95 #include <linux/atm.h>
96 #include <linux/atmarp.h>
97 #include <linux/atmclip.h>
98 #include <linux/atmdev.h>
99 #include <linux/atmioc.h>
100 #include <linux/atmlec.h>
101 #include <linux/atmmpc.h>
102 #include <linux/atmsvc.h>
103 #include <linux/atm_tcp.h>
104 #include <linux/sonet.h>
105 #include <linux/atm_suni.h>
106 #include <linux/mtd/mtd.h>
108 #include <linux/usb.h>
109 #include <linux/usbdevice_fs.h>
110 #include <linux/nbd.h>
111 #include <linux/random.h>
112 #include <linux/filter.h>
113 #include <linux/msdos_fs.h>
120 /* Aiee. Someone does not find a difference between int and long */
121 #define EXT2_IOC32_GETFLAGS _IOR('f', 1, int)
122 #define EXT2_IOC32_SETFLAGS _IOW('f', 2, int)
123 #define EXT2_IOC32_GETVERSION _IOR('v', 1, int)
124 #define EXT2_IOC32_SETVERSION _IOW('v', 2, int)
126 static int w_long(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
128 mm_segment_t old_fs
= get_fs();
133 err
= sys_ioctl(fd
, cmd
, (unsigned long)&val
);
135 if (!err
&& put_user(val
, (u32
*)compat_ptr(arg
)))
140 static int rw_long(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
142 mm_segment_t old_fs
= get_fs();
143 u32
*argptr
= compat_ptr(arg
);
147 if(get_user(val
, argptr
))
150 err
= sys_ioctl(fd
, cmd
, (unsigned long)&val
);
152 if (!err
&& put_user(val
, argptr
))
157 static int do_ext2_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
159 /* These are just misnamed, they actually get/put from/to user an int */
161 case EXT2_IOC32_GETFLAGS
: cmd
= EXT2_IOC_GETFLAGS
; break;
162 case EXT2_IOC32_SETFLAGS
: cmd
= EXT2_IOC_SETFLAGS
; break;
163 case EXT2_IOC32_GETVERSION
: cmd
= EXT2_IOC_GETVERSION
; break;
164 case EXT2_IOC32_SETVERSION
: cmd
= EXT2_IOC_SETVERSION
; break;
166 return sys_ioctl(fd
, cmd
, (unsigned long)compat_ptr(arg
));
169 struct video_tuner32
{
172 compat_ulong_t rangelow
, rangehigh
;
173 u32 flags
; /* It is really u32 in videodev.h */
177 static int get_video_tuner32(struct video_tuner
*kp
, struct video_tuner32
*up
)
181 if(get_user(kp
->tuner
, &up
->tuner
))
183 for(i
= 0; i
< 32; i
++)
184 __get_user(kp
->name
[i
], &up
->name
[i
]);
185 __get_user(kp
->rangelow
, &up
->rangelow
);
186 __get_user(kp
->rangehigh
, &up
->rangehigh
);
187 __get_user(kp
->flags
, &up
->flags
);
188 __get_user(kp
->mode
, &up
->mode
);
189 __get_user(kp
->signal
, &up
->signal
);
193 static int put_video_tuner32(struct video_tuner
*kp
, struct video_tuner32
*up
)
197 if(put_user(kp
->tuner
, &up
->tuner
))
199 for(i
= 0; i
< 32; i
++)
200 __put_user(kp
->name
[i
], &up
->name
[i
]);
201 __put_user(kp
->rangelow
, &up
->rangelow
);
202 __put_user(kp
->rangehigh
, &up
->rangehigh
);
203 __put_user(kp
->flags
, &up
->flags
);
204 __put_user(kp
->mode
, &up
->mode
);
205 __put_user(kp
->signal
, &up
->signal
);
209 struct video_buffer32
{
211 compat_int_t height
, width
, depth
, bytesperline
;
214 static int get_video_buffer32(struct video_buffer
*kp
, struct video_buffer32
*up
)
218 if(get_user(tmp
, &up
->base
))
220 kp
->base
= compat_ptr(tmp
);
221 __get_user(kp
->height
, &up
->height
);
222 __get_user(kp
->width
, &up
->width
);
223 __get_user(kp
->depth
, &up
->depth
);
224 __get_user(kp
->bytesperline
, &up
->bytesperline
);
228 static int put_video_buffer32(struct video_buffer
*kp
, struct video_buffer32
*up
)
230 u32 tmp
= (u32
)((unsigned long)kp
->base
);
232 if(put_user(tmp
, &up
->base
))
234 __put_user(kp
->height
, &up
->height
);
235 __put_user(kp
->width
, &up
->width
);
236 __put_user(kp
->depth
, &up
->depth
);
237 __put_user(kp
->bytesperline
, &up
->bytesperline
);
241 struct video_clip32
{
242 s32 x
, y
, width
, height
; /* Its really s32 in videodev.h */
246 struct video_window32
{
247 u32 x
, y
, width
, height
, chromakey
, flags
;
248 compat_caddr_t clips
;
249 compat_int_t clipcount
;
252 static void free_kvideo_clips(struct video_window
*kp
)
254 struct video_clip
*cp
;
261 static int get_video_window32(struct video_window
*kp
, struct video_window32
*up
)
263 struct video_clip32
*ucp
;
264 struct video_clip
*kcp
;
268 if(get_user(kp
->x
, &up
->x
))
270 __get_user(kp
->y
, &up
->y
);
271 __get_user(kp
->width
, &up
->width
);
272 __get_user(kp
->height
, &up
->height
);
273 __get_user(kp
->chromakey
, &up
->chromakey
);
274 __get_user(kp
->flags
, &up
->flags
);
275 __get_user(kp
->clipcount
, &up
->clipcount
);
276 __get_user(tmp
, &up
->clips
);
277 ucp
= compat_ptr(tmp
);
280 nclips
= kp
->clipcount
;
287 /* Peculiar interface... */
289 nclips
= VIDEO_CLIPMAP_SIZE
;
291 kcp
= kmalloc(nclips
* sizeof(struct video_clip
), GFP_KERNEL
);
294 goto cleanup_and_err
;
297 for(i
= 0; i
< nclips
; i
++) {
298 __get_user(kcp
[i
].x
, &ucp
[i
].x
);
299 __get_user(kcp
[i
].y
, &ucp
[i
].y
);
300 __get_user(kcp
[i
].width
, &ucp
[i
].width
);
301 __get_user(kcp
[i
].height
, &ucp
[i
].height
);
302 kcp
[nclips
].next
= NULL
;
308 free_kvideo_clips(kp
);
312 /* You get back everything except the clips... */
313 static int put_video_window32(struct video_window
*kp
, struct video_window32
*up
)
315 if(put_user(kp
->x
, &up
->x
))
317 __put_user(kp
->y
, &up
->y
);
318 __put_user(kp
->width
, &up
->width
);
319 __put_user(kp
->height
, &up
->height
);
320 __put_user(kp
->chromakey
, &up
->chromakey
);
321 __put_user(kp
->flags
, &up
->flags
);
322 __put_user(kp
->clipcount
, &up
->clipcount
);
326 #define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
327 #define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
328 #define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
329 #define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
330 #define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
331 #define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
332 #define VIDIOCGFREQ32 _IOR('v',14, u32)
333 #define VIDIOCSFREQ32 _IOW('v',15, u32)
335 static int do_video_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
338 struct video_tuner vt
;
339 struct video_buffer vb
;
340 struct video_window vw
;
343 mm_segment_t old_fs
= get_fs();
344 void *up
= compat_ptr(arg
);
347 /* First, convert the command. */
349 case VIDIOCGTUNER32
: cmd
= VIDIOCGTUNER
; break;
350 case VIDIOCSTUNER32
: cmd
= VIDIOCSTUNER
; break;
351 case VIDIOCGWIN32
: cmd
= VIDIOCGWIN
; break;
352 case VIDIOCSWIN32
: cmd
= VIDIOCSWIN
; break;
353 case VIDIOCGFBUF32
: cmd
= VIDIOCGFBUF
; break;
354 case VIDIOCSFBUF32
: cmd
= VIDIOCSFBUF
; break;
355 case VIDIOCGFREQ32
: cmd
= VIDIOCGFREQ
; break;
356 case VIDIOCSFREQ32
: cmd
= VIDIOCSFREQ
; break;
362 err
= get_video_tuner32(&karg
.vt
, up
);
366 err
= get_video_window32(&karg
.vw
, up
);
370 err
= get_video_buffer32(&karg
.vb
, up
);
374 err
= get_user(karg
.vx
, (u32
*)up
);
381 err
= sys_ioctl(fd
, cmd
, (unsigned long)&karg
);
384 if(cmd
== VIDIOCSWIN
)
385 free_kvideo_clips(&karg
.vw
);
390 err
= put_video_tuner32(&karg
.vt
, up
);
394 err
= put_video_window32(&karg
.vw
, up
);
398 err
= put_video_buffer32(&karg
.vb
, up
);
402 err
= put_user(((u32
)karg
.vx
), (u32
*)up
);
410 static int do_siocgstamp(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
412 struct compat_timeval
*up
= compat_ptr(arg
);
414 mm_segment_t old_fs
= get_fs();
418 err
= sys_ioctl(fd
, cmd
, (unsigned long)&ktv
);
421 err
= put_user(ktv
.tv_sec
, &up
->tv_sec
);
422 err
|= __put_user(ktv
.tv_usec
, &up
->tv_usec
);
428 compat_ulong_t mem_start
;
429 compat_ulong_t mem_end
;
430 unsigned short base_addr
;
437 #define IFHWADDRLEN 6
440 char ifrn_name
[IFNAMSIZ
]; /* if name, e.g. "en0" */
443 struct sockaddr ifru_addr
;
444 struct sockaddr ifru_dstaddr
;
445 struct sockaddr ifru_broadaddr
;
446 struct sockaddr ifru_netmask
;
447 struct sockaddr ifru_hwaddr
;
449 compat_int_t ifru_ivalue
;
450 compat_int_t ifru_mtu
;
451 struct ifmap32 ifru_map
;
452 char ifru_slave
[IFNAMSIZ
]; /* Just fits the size */
453 char ifru_newname
[IFNAMSIZ
];
454 compat_caddr_t ifru_data
;
455 /* XXXX? ifru_settings should be here */
460 compat_int_t ifc_len
; /* size of buffer */
461 compat_caddr_t ifcbuf
;
465 static int dev_ifname32(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
467 struct net_device
*dev
;
468 struct ifreq32 ifr32
;
471 if (copy_from_user(&ifr32
, compat_ptr(arg
), sizeof(ifr32
)))
474 dev
= dev_get_by_index(ifr32
.ifr_ifindex
);
478 strlcpy(ifr32
.ifr_name
, dev
->name
, sizeof(ifr32
.ifr_name
));
481 err
= copy_to_user(compat_ptr(arg
), &ifr32
, sizeof(ifr32
));
482 return (err
? -EFAULT
: 0);
486 static int dev_ifconf(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
488 struct ifconf32 ifc32
;
490 struct ifreq32
*ifr32
;
496 if (copy_from_user(&ifc32
, compat_ptr(arg
), sizeof(struct ifconf32
)))
499 if(ifc32
.ifcbuf
== 0) {
504 ifc
.ifc_len
= ((ifc32
.ifc_len
/ sizeof (struct ifreq32
)) + 1) *
505 sizeof (struct ifreq
);
506 /* should the size be limited? -arnd */
507 ifc
.ifc_buf
= kmalloc (ifc
.ifc_len
, GFP_KERNEL
);
512 ifr32
= compat_ptr(ifc32
.ifcbuf
);
513 for (i
= 0; i
< ifc32
.ifc_len
; i
+= sizeof (struct ifreq32
)) {
514 if (copy_from_user(ifr
, ifr32
, sizeof (struct ifreq32
))) {
521 old_fs
= get_fs(); set_fs (KERNEL_DS
);
522 err
= sys_ioctl (fd
, SIOCGIFCONF
, (unsigned long)&ifc
);
526 ifr32
= compat_ptr(ifc32
.ifcbuf
);
527 for (i
= 0, j
= 0; i
< ifc32
.ifc_len
&& j
< ifc
.ifc_len
;
528 i
+= sizeof (struct ifreq32
), j
+= sizeof (struct ifreq
)) {
529 int k
= copy_to_user(ifr32
, ifr
, sizeof (struct ifreq32
));
539 if (ifc32
.ifcbuf
== 0) {
540 /* Translate from 64-bit structure multiple to
544 i
= ((i
/ sizeof(struct ifreq
)) * sizeof(struct ifreq32
));
547 if (i
<= ifc32
.ifc_len
)
550 ifc32
.ifc_len
= i
- sizeof (struct ifreq32
);
552 if (copy_to_user(compat_ptr(arg
), &ifc32
, sizeof(struct ifconf32
)))
556 if(ifc
.ifc_buf
!= NULL
)
561 static int ethtool_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
564 struct ifreq32
*ifr32
;
568 ifr
= compat_alloc_user_space(sizeof(*ifr
));
569 ifr32
= compat_ptr(arg
);
571 if (copy_in_user(&ifr
->ifr_name
, &ifr32
->ifr_name
, IFNAMSIZ
))
574 if (get_user(data
, &ifr32
->ifr_ifru
.ifru_data
))
577 datap
= compat_ptr(data
);
578 if (put_user(datap
, &ifr
->ifr_ifru
.ifru_data
))
581 return sys_ioctl(fd
, cmd
, (unsigned long) ifr
);
584 static int bond_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
588 struct ifreq32
*ifr32
= compat_ptr(arg
);
595 case SIOCBONDENSLAVE
:
596 case SIOCBONDRELEASE
:
597 case SIOCBONDSETHWADDR
:
598 case SIOCBONDCHANGEACTIVE
:
599 if (copy_from_user(&kifr
, ifr32
, sizeof(struct ifreq32
)))
604 err
= sys_ioctl (fd
, cmd
, (unsigned long)&kifr
);
608 case SIOCBONDSLAVEINFOQUERY
:
609 case SIOCBONDINFOQUERY
:
610 uifr
= compat_alloc_user_space(sizeof(*uifr
));
611 if (copy_in_user(&uifr
->ifr_name
, &ifr32
->ifr_name
, IFNAMSIZ
))
614 if (get_user(data
, &ifr32
->ifr_ifru
.ifru_data
))
617 datap
= compat_ptr(data
);
618 if (put_user(datap
, &uifr
->ifr_ifru
.ifru_data
))
621 return sys_ioctl (fd
, cmd
, (unsigned long)uifr
);
627 int siocdevprivate_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
629 struct ifreq
*u_ifreq64
;
630 struct ifreq32
*u_ifreq32
= compat_ptr(arg
);
631 char tmp_buf
[IFNAMSIZ
];
635 if (copy_from_user(&tmp_buf
[0], &(u_ifreq32
->ifr_ifrn
.ifrn_name
[0]),
638 if (__get_user(data32
, &u_ifreq32
->ifr_ifru
.ifru_data
))
640 data64
= compat_ptr(data32
);
642 u_ifreq64
= compat_alloc_user_space(sizeof(*u_ifreq64
));
644 /* Don't check these user accesses, just let that get trapped
645 * in the ioctl handler instead.
647 copy_to_user(&u_ifreq64
->ifr_ifrn
.ifrn_name
[0], &tmp_buf
[0], IFNAMSIZ
);
648 __put_user(data64
, &u_ifreq64
->ifr_ifru
.ifru_data
);
650 return sys_ioctl(fd
, cmd
, (unsigned long) u_ifreq64
);
653 static int dev_ifsioc(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
656 struct ifreq32
*uifr32
;
657 struct ifmap32
*uifmap32
;
661 uifr32
= compat_ptr(arg
);
662 uifmap32
= &uifr32
->ifr_ifru
.ifru_map
;
665 err
= copy_from_user(&ifr
, uifr32
, sizeof(ifr
.ifr_name
));
666 err
|= __get_user(ifr
.ifr_map
.mem_start
, &uifmap32
->mem_start
);
667 err
|= __get_user(ifr
.ifr_map
.mem_end
, &uifmap32
->mem_end
);
668 err
|= __get_user(ifr
.ifr_map
.base_addr
, &uifmap32
->base_addr
);
669 err
|= __get_user(ifr
.ifr_map
.irq
, &uifmap32
->irq
);
670 err
|= __get_user(ifr
.ifr_map
.dma
, &uifmap32
->dma
);
671 err
|= __get_user(ifr
.ifr_map
.port
, &uifmap32
->port
);
676 if (copy_from_user(&ifr
, uifr32
, sizeof(*uifr32
)))
682 err
= sys_ioctl (fd
, cmd
, (unsigned long)&ifr
);
697 if (copy_to_user(uifr32
, &ifr
, sizeof(*uifr32
)))
701 err
= copy_to_user(uifr32
, &ifr
, sizeof(ifr
.ifr_name
));
702 err
|= __put_user(ifr
.ifr_map
.mem_start
, &uifmap32
->mem_start
);
703 err
|= __put_user(ifr
.ifr_map
.mem_end
, &uifmap32
->mem_end
);
704 err
|= __put_user(ifr
.ifr_map
.base_addr
, &uifmap32
->base_addr
);
705 err
|= __put_user(ifr
.ifr_map
.irq
, &uifmap32
->irq
);
706 err
|= __put_user(ifr
.ifr_map
.dma
, &uifmap32
->dma
);
707 err
|= __put_user(ifr
.ifr_map
.port
, &uifmap32
->port
);
718 struct sockaddr rt_dst
; /* target address */
719 struct sockaddr rt_gateway
; /* gateway addr (RTF_GATEWAY) */
720 struct sockaddr rt_genmask
; /* target network mask (IP) */
721 unsigned short rt_flags
;
724 unsigned char rt_tos
;
725 unsigned char rt_class
;
727 short rt_metric
; /* +1 for binary compatibility! */
728 /* char * */ u32 rt_dev
; /* forcing the device at add */
729 u32 rt_mtu
; /* per route MTU/Window */
730 u32 rt_window
; /* Window clamping */
731 unsigned short rt_irtt
; /* Initial RTT */
736 struct in6_addr rtmsg_dst
;
737 struct in6_addr rtmsg_src
;
738 struct in6_addr rtmsg_gateway
;
748 static int routing_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
756 mm_segment_t old_fs
= get_fs();
758 struct socket
*mysock
= sockfd_lookup(fd
, &ret
);
760 if (mysock
&& mysock
->sk
&& mysock
->sk
->sk_family
== AF_INET6
) { /* ipv6 */
761 struct in6_rtmsg32
*ur6
= compat_ptr(arg
);
762 ret
= copy_from_user (&r6
.rtmsg_dst
, &(ur6
->rtmsg_dst
),
763 3 * sizeof(struct in6_addr
));
764 ret
|= __get_user (r6
.rtmsg_type
, &(ur6
->rtmsg_type
));
765 ret
|= __get_user (r6
.rtmsg_dst_len
, &(ur6
->rtmsg_dst_len
));
766 ret
|= __get_user (r6
.rtmsg_src_len
, &(ur6
->rtmsg_src_len
));
767 ret
|= __get_user (r6
.rtmsg_metric
, &(ur6
->rtmsg_metric
));
768 ret
|= __get_user (r6
.rtmsg_info
, &(ur6
->rtmsg_info
));
769 ret
|= __get_user (r6
.rtmsg_flags
, &(ur6
->rtmsg_flags
));
770 ret
|= __get_user (r6
.rtmsg_ifindex
, &(ur6
->rtmsg_ifindex
));
774 struct rtentry32
*ur4
= compat_ptr(arg
);
775 ret
= copy_from_user (&r4
.rt_dst
, &(ur4
->rt_dst
),
776 3 * sizeof(struct sockaddr
));
777 ret
|= __get_user (r4
.rt_flags
, &(ur4
->rt_flags
));
778 ret
|= __get_user (r4
.rt_metric
, &(ur4
->rt_metric
));
779 ret
|= __get_user (r4
.rt_mtu
, &(ur4
->rt_mtu
));
780 ret
|= __get_user (r4
.rt_window
, &(ur4
->rt_window
));
781 ret
|= __get_user (r4
.rt_irtt
, &(ur4
->rt_irtt
));
782 ret
|= __get_user (rtdev
, &(ur4
->rt_dev
));
784 ret
|= copy_from_user (devname
, compat_ptr(rtdev
), 15);
785 r4
.rt_dev
= devname
; devname
[15] = 0;
796 ret
= sys_ioctl (fd
, cmd
, (unsigned long) r
);
805 struct hd_geometry32
{
807 unsigned char sectors
;
808 unsigned short cylinders
;
812 static int hdio_getgeo(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
814 mm_segment_t old_fs
= get_fs();
815 struct hd_geometry geo
;
816 struct hd_geometry32
*ugeo
;
820 err
= sys_ioctl(fd
, HDIO_GETGEO
, (unsigned long)&geo
);
822 ugeo
= compat_ptr(arg
);
824 err
= copy_to_user (ugeo
, &geo
, 4);
825 err
|= __put_user (geo
.start
, &ugeo
->start
);
827 return err
? -EFAULT
: 0;
830 struct fb_fix_screeninfo32
{
832 compat_caddr_t smem_start
;
841 compat_caddr_t mmio_start
;
851 compat_caddr_t green
;
853 compat_caddr_t transp
;
856 static int do_cmap_ptr(__u16
**ptr64
, __u32
*ptr32
)
861 if (get_user(data
, ptr32
))
863 datap
= compat_ptr(data
);
864 if (put_user(datap
, ptr64
))
869 static int fb_getput_cmap(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
871 struct fb_cmap
*cmap
;
872 struct fb_cmap32
*cmap32
;
875 cmap
= compat_alloc_user_space(sizeof(*cmap
));
876 cmap32
= compat_ptr(arg
);
878 if (copy_in_user(&cmap
->start
, &cmap32
->start
, 2 * sizeof(__u32
)))
881 if (do_cmap_ptr(&cmap
->red
, &cmap32
->red
) ||
882 do_cmap_ptr(&cmap
->green
, &cmap32
->green
) ||
883 do_cmap_ptr(&cmap
->blue
, &cmap32
->blue
) ||
884 do_cmap_ptr(&cmap
->transp
, &cmap32
->transp
))
887 err
= sys_ioctl(fd
, cmd
, (unsigned long) cmap
);
890 if (copy_in_user(&cmap32
->start
,
898 static int do_fscreeninfo_to_user(struct fb_fix_screeninfo
*fix
,
899 struct fb_fix_screeninfo32
*fix32
)
904 err
= copy_to_user(&fix32
->id
, &fix
->id
, sizeof(fix32
->id
));
906 data
= (__u32
) (unsigned long) fix
->smem_start
;
907 err
|= put_user(data
, &fix32
->smem_start
);
909 err
|= put_user(fix
->smem_len
, &fix32
->smem_len
);
910 err
|= put_user(fix
->type
, &fix32
->type
);
911 err
|= put_user(fix
->type_aux
, &fix32
->type_aux
);
912 err
|= put_user(fix
->visual
, &fix32
->visual
);
913 err
|= put_user(fix
->xpanstep
, &fix32
->xpanstep
);
914 err
|= put_user(fix
->ypanstep
, &fix32
->ypanstep
);
915 err
|= put_user(fix
->ywrapstep
, &fix32
->ywrapstep
);
916 err
|= put_user(fix
->line_length
, &fix32
->line_length
);
918 data
= (__u32
) (unsigned long) fix
->mmio_start
;
919 err
|= put_user(data
, &fix32
->mmio_start
);
921 err
|= put_user(fix
->mmio_len
, &fix32
->mmio_len
);
922 err
|= put_user(fix
->accel
, &fix32
->accel
);
923 err
|= copy_to_user(fix32
->reserved
, fix
->reserved
,
924 sizeof(fix
->reserved
));
929 static int fb_get_fscreeninfo(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
932 struct fb_fix_screeninfo fix
;
933 struct fb_fix_screeninfo32
*fix32
;
936 fix32
= compat_ptr(arg
);
940 err
= sys_ioctl(fd
, cmd
, (unsigned long) &fix
);
944 err
= do_fscreeninfo_to_user(&fix
, fix32
);
949 static int fb_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
954 case FBIOGET_FSCREENINFO
:
955 err
= fb_get_fscreeninfo(fd
,cmd
, arg
);
960 err
= fb_getput_cmap(fd
, cmd
, arg
);
967 printk("%s: Unknown fb ioctl cmd fd(%d) "
968 "cmd(%08x) arg(%08lx)\n",
969 __FUNCTION__
, fd
, cmd
, arg
);
978 static int hdio_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
980 mm_segment_t old_fs
= get_fs();
986 error
= sys_ioctl(fd
, cmd
, (long)&kval
);
990 uvp
= compat_ptr(arg
);
991 if(put_user(kval
, uvp
))
998 typedef struct sg_io_hdr32
{
999 compat_int_t interface_id
; /* [i] 'S' for SCSI generic (required) */
1000 compat_int_t dxfer_direction
; /* [i] data transfer direction */
1001 unsigned char cmd_len
; /* [i] SCSI command length ( <= 16 bytes) */
1002 unsigned char mx_sb_len
; /* [i] max length to write to sbp */
1003 unsigned short iovec_count
; /* [i] 0 implies no scatter gather */
1004 compat_uint_t dxfer_len
; /* [i] byte count of data transfer */
1005 compat_uint_t dxferp
; /* [i], [*io] points to data transfer memory
1006 or scatter gather list */
1007 compat_uptr_t cmdp
; /* [i], [*i] points to command to perform */
1008 compat_uptr_t sbp
; /* [i], [*o] points to sense_buffer memory */
1009 compat_uint_t timeout
; /* [i] MAX_UINT->no timeout (unit: millisec) */
1010 compat_uint_t flags
; /* [i] 0 -> default, see SG_FLAG... */
1011 compat_int_t pack_id
; /* [i->o] unused internally (normally) */
1012 compat_uptr_t usr_ptr
; /* [i->o] unused internally */
1013 unsigned char status
; /* [o] scsi status */
1014 unsigned char masked_status
; /* [o] shifted, masked scsi status */
1015 unsigned char msg_status
; /* [o] messaging level data (optional) */
1016 unsigned char sb_len_wr
; /* [o] byte count actually written to sbp */
1017 unsigned short host_status
; /* [o] errors from host adapter */
1018 unsigned short driver_status
; /* [o] errors from software driver */
1019 compat_int_t resid
; /* [o] dxfer_len - actual_transferred */
1020 compat_uint_t duration
; /* [o] time taken by cmd (unit: millisec) */
1021 compat_uint_t info
; /* [o] auxiliary information */
1022 } sg_io_hdr32_t
; /* 64 bytes long (on sparc32) */
1024 typedef struct sg_iovec32
{
1025 compat_uint_t iov_base
;
1026 compat_uint_t iov_len
;
1029 static int sg_build_iovec(sg_io_hdr_t
*sgio
, void *dxferp
, u16 iovec_count
)
1031 sg_iovec_t
*iov
= (sg_iovec_t
*) (sgio
+ 1);
1032 sg_iovec32_t
*iov32
= dxferp
;
1035 for (i
= 0; i
< iovec_count
; i
++) {
1038 if (get_user(base
, &iov32
[i
].iov_base
) ||
1039 get_user(len
, &iov32
[i
].iov_len
) ||
1040 put_user(compat_ptr(base
), &iov
[i
].iov_base
) ||
1041 put_user(len
, &iov
[i
].iov_len
))
1045 sgio
->dxferp
= iov
; /* FIXME: dereferencing user pointer? */
1049 static int sg_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1052 sg_io_hdr32_t
*sgio32
;
1058 sgio32
= compat_ptr(arg
);
1059 if (get_user(iovec_count
, &sgio32
->iovec_count
))
1065 top
= compat_alloc_user_space(0);
1066 new = compat_alloc_user_space(sizeof(sg_io_hdr_t
) +
1068 sizeof(sg_iovec_t
)));
1075 /* Ok, now construct. */
1076 if (copy_in_user(&sgio
->interface_id
, &sgio32
->interface_id
,
1078 (2 * sizeof(unsigned char)) +
1079 (1 * sizeof(unsigned short)) +
1080 (1 * sizeof(unsigned int))))
1083 if (get_user(data
, &sgio32
->dxferp
))
1085 dxferp
= compat_ptr(data
);
1087 if (sg_build_iovec(sgio
, dxferp
, iovec_count
))
1090 if (put_user(dxferp
, &sgio
->dxferp
))
1095 unsigned char *cmdp
, *sbp
;
1097 if (get_user(data
, &sgio32
->cmdp
))
1099 cmdp
= compat_ptr(data
);
1101 if (get_user(data
, &sgio32
->sbp
))
1103 sbp
= compat_ptr(data
);
1105 if (put_user(cmdp
, &sgio
->cmdp
) ||
1106 put_user(sbp
, &sgio
->sbp
))
1110 if (copy_in_user(&sgio
->timeout
, &sgio32
->timeout
,
1114 if (get_user(data
, &sgio32
->usr_ptr
))
1116 if (put_user(compat_ptr(data
), &sgio
->usr_ptr
))
1119 if (copy_in_user(&sgio
->status
, &sgio32
->status
,
1120 (4 * sizeof(unsigned char)) +
1121 (2 * sizeof(unsigned (short))) +
1125 err
= sys_ioctl(fd
, cmd
, (unsigned long) sgio
);
1130 if (copy_in_user(&sgio32
->pack_id
, &sgio
->pack_id
,
1132 get_user(datap
, &sgio
->usr_ptr
) ||
1133 put_user((u32
)(unsigned long)datap
,
1134 &sgio32
->usr_ptr
) ||
1135 copy_in_user(&sgio32
->status
, &sgio
->status
,
1136 (4 * sizeof(unsigned char)) +
1137 (2 * sizeof(unsigned short)) +
1145 struct sock_fprog32
{
1147 compat_caddr_t filter
;
1150 #define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
1151 #define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
1153 static int ppp_sock_fprog_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1155 struct sock_fprog32
*u_fprog32
= compat_ptr(arg
);
1156 struct sock_fprog
*u_fprog64
= compat_alloc_user_space(sizeof(struct sock_fprog
));
1161 if (get_user(flen
, &u_fprog32
->len
) ||
1162 get_user(fptr32
, &u_fprog32
->filter
))
1165 fptr64
= compat_ptr(fptr32
);
1167 if (put_user(flen
, &u_fprog64
->len
) ||
1168 put_user(fptr64
, &u_fprog64
->filter
))
1171 if (cmd
== PPPIOCSPASS32
)
1174 cmd
= PPPIOCSACTIVE
;
1176 return sys_ioctl(fd
, cmd
, (unsigned long) u_fprog64
);
1179 struct ppp_option_data32
{
1182 compat_int_t transmit
;
1184 #define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
1187 compat_time_t xmit_idle
;
1188 compat_time_t recv_idle
;
1190 #define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
1192 static int ppp_gidle(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1194 struct ppp_idle
*idle
;
1195 struct ppp_idle32
*idle32
;
1196 __kernel_time_t xmit
, recv
;
1199 idle
= compat_alloc_user_space(sizeof(*idle
));
1200 idle32
= compat_ptr(arg
);
1202 err
= sys_ioctl(fd
, PPPIOCGIDLE
, (unsigned long) idle
);
1205 if (get_user(xmit
, &idle
->xmit_idle
) ||
1206 get_user(recv
, &idle
->recv_idle
) ||
1207 put_user(xmit
, &idle32
->xmit_idle
) ||
1208 put_user(recv
, &idle32
->recv_idle
))
1214 static int ppp_scompress(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1216 struct ppp_option_data
*odata
;
1217 struct ppp_option_data32
*odata32
;
1221 odata
= compat_alloc_user_space(sizeof(*odata
));
1222 odata32
= compat_ptr(arg
);
1224 if (get_user(data
, &odata32
->ptr
))
1227 datap
= compat_ptr(data
);
1228 if (put_user(datap
, &odata
->ptr
))
1231 if (copy_in_user(&odata
->length
, &odata32
->length
,
1232 sizeof(__u32
) + sizeof(int)))
1235 return sys_ioctl(fd
, PPPIOCSCOMPRESS
, (unsigned long) odata
);
1238 static int ppp_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1244 err
= ppp_gidle(fd
, cmd
, arg
);
1247 case PPPIOCSCOMPRESS32
:
1248 err
= ppp_scompress(fd
, cmd
, arg
);
1255 printk("ppp_ioctl: Unknown cmd fd(%d) "
1256 "cmd(%08x) arg(%08x)\n",
1257 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1268 compat_long_t mt_type
;
1269 compat_long_t mt_resid
;
1270 compat_long_t mt_dsreg
;
1271 compat_long_t mt_gstat
;
1272 compat_long_t mt_erreg
;
1273 compat_daddr_t mt_fileno
;
1274 compat_daddr_t mt_blkno
;
1276 #define MTIOCGET32 _IOR('m', 2, struct mtget32)
1279 compat_long_t mt_blkno
;
1281 #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
1283 struct mtconfiginfo32
{
1284 compat_long_t mt_type
;
1285 compat_long_t ifc_type
;
1286 unsigned short irqnr
;
1287 unsigned short dmanr
;
1288 unsigned short port
;
1289 compat_ulong_t debug
;
1290 compat_uint_t have_dens
:1;
1291 compat_uint_t have_bsf
:1;
1292 compat_uint_t have_fsr
:1;
1293 compat_uint_t have_bsr
:1;
1294 compat_uint_t have_eod
:1;
1295 compat_uint_t have_seek
:1;
1296 compat_uint_t have_tell
:1;
1297 compat_uint_t have_ras1
:1;
1298 compat_uint_t have_ras2
:1;
1299 compat_uint_t have_ras3
:1;
1300 compat_uint_t have_qfa
:1;
1301 compat_uint_t pad1
:5;
1304 #define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
1305 #define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
1307 static int mt_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1309 mm_segment_t old_fs
= get_fs();
1310 struct mtconfiginfo info
;
1311 struct mtconfiginfo32
*uinfo32
;
1313 struct mtget32
*umget32
;
1315 struct mtpos32
*upos32
;
1329 case MTIOCGETCONFIG32
:
1330 kcmd
= MTIOCGETCONFIG
;
1333 case MTIOCSETCONFIG32
:
1334 kcmd
= MTIOCSETCONFIG
;
1336 uinfo32
= compat_ptr(arg
);
1337 err
= __get_user(info
.mt_type
, &uinfo32
->mt_type
);
1338 err
|= __get_user(info
.ifc_type
, &uinfo32
->ifc_type
);
1339 err
|= __get_user(info
.irqnr
, &uinfo32
->irqnr
);
1340 err
|= __get_user(info
.dmanr
, &uinfo32
->dmanr
);
1341 err
|= __get_user(info
.port
, &uinfo32
->port
);
1342 err
|= __get_user(info
.debug
, &uinfo32
->debug
);
1343 err
|= __copy_from_user((char *)&info
.debug
1344 + sizeof(info
.debug
),
1345 (char *)&uinfo32
->debug
1346 + sizeof(uinfo32
->debug
), sizeof(__u32
));
1354 printk("mt_ioctl: Unknown cmd fd(%d) "
1355 "cmd(%08x) arg(%08x)\n",
1356 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1361 err
= sys_ioctl (fd
, kcmd
, (unsigned long)karg
);
1367 upos32
= compat_ptr(arg
);
1368 err
= __put_user(pos
.mt_blkno
, &upos32
->mt_blkno
);
1371 umget32
= compat_ptr(arg
);
1372 err
= __put_user(get
.mt_type
, &umget32
->mt_type
);
1373 err
|= __put_user(get
.mt_resid
, &umget32
->mt_resid
);
1374 err
|= __put_user(get
.mt_dsreg
, &umget32
->mt_dsreg
);
1375 err
|= __put_user(get
.mt_gstat
, &umget32
->mt_gstat
);
1376 err
|= __put_user(get
.mt_erreg
, &umget32
->mt_erreg
);
1377 err
|= __put_user(get
.mt_fileno
, &umget32
->mt_fileno
);
1378 err
|= __put_user(get
.mt_blkno
, &umget32
->mt_blkno
);
1380 case MTIOCGETCONFIG32
:
1381 uinfo32
= compat_ptr(arg
);
1382 err
= __put_user(info
.mt_type
, &uinfo32
->mt_type
);
1383 err
|= __put_user(info
.ifc_type
, &uinfo32
->ifc_type
);
1384 err
|= __put_user(info
.irqnr
, &uinfo32
->irqnr
);
1385 err
|= __put_user(info
.dmanr
, &uinfo32
->dmanr
);
1386 err
|= __put_user(info
.port
, &uinfo32
->port
);
1387 err
|= __put_user(info
.debug
, &uinfo32
->debug
);
1388 err
|= __copy_to_user((char *)&uinfo32
->debug
1389 + sizeof(uinfo32
->debug
),
1390 (char *)&info
.debug
+ sizeof(info
.debug
), sizeof(__u32
));
1392 case MTIOCSETCONFIG32
:
1395 return err
? -EFAULT
: 0;
1398 struct cdrom_read_audio32
{
1399 union cdrom_addr addr
;
1401 compat_int_t nframes
;
1405 struct cdrom_generic_command32
{
1406 unsigned char cmd
[CDROM_PACKET_SIZE
];
1407 compat_caddr_t buffer
;
1408 compat_uint_t buflen
;
1410 compat_caddr_t sense
;
1411 unsigned char data_direction
;
1413 compat_int_t timeout
;
1414 compat_caddr_t reserved
[1];
1417 static int cdrom_do_read_audio(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1419 struct cdrom_read_audio
*cdread_audio
;
1420 struct cdrom_read_audio32
*cdread_audio32
;
1424 cdread_audio
= compat_alloc_user_space(sizeof(*cdread_audio
));
1425 cdread_audio32
= compat_ptr(arg
);
1427 if (copy_in_user(&cdread_audio
->addr
,
1428 &cdread_audio32
->addr
,
1429 (sizeof(*cdread_audio32
) -
1430 sizeof(compat_caddr_t
))))
1433 if (get_user(data
, &cdread_audio32
->buf
))
1435 datap
= compat_ptr(data
);
1436 if (put_user(datap
, &cdread_audio
->buf
))
1439 return sys_ioctl(fd
, cmd
, (unsigned long) cdread_audio
);
1442 static int __cgc_do_ptr(void **ptr64
, __u32
*ptr32
)
1447 if (get_user(data
, ptr32
))
1449 datap
= compat_ptr(data
);
1450 if (put_user(datap
, ptr64
))
1456 static int cdrom_do_generic_command(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1458 struct cdrom_generic_command
*cgc
;
1459 struct cdrom_generic_command32
*cgc32
;
1463 cgc
= compat_alloc_user_space(sizeof(*cgc
));
1464 cgc32
= compat_ptr(arg
);
1466 if (copy_in_user(&cgc
->cmd
, &cgc32
->cmd
, sizeof(cgc
->cmd
)) ||
1467 __cgc_do_ptr((void **) &cgc
->buffer
, &cgc32
->buffer
) ||
1468 copy_in_user(&cgc
->buflen
, &cgc32
->buflen
,
1469 (sizeof(unsigned int) + sizeof(int))) ||
1470 __cgc_do_ptr((void **) &cgc
->sense
, &cgc32
->sense
))
1473 if (get_user(dir
, &cgc32
->data_direction
) ||
1474 put_user(dir
, &cgc
->data_direction
))
1477 if (get_user(itmp
, &cgc32
->quiet
) ||
1478 put_user(itmp
, &cgc
->quiet
))
1481 if (get_user(itmp
, &cgc32
->timeout
) ||
1482 put_user(itmp
, &cgc
->timeout
))
1485 if (__cgc_do_ptr(&cgc
->reserved
[0], &cgc32
->reserved
[0]))
1488 return sys_ioctl(fd
, cmd
, (unsigned long) cgc
);
1491 static int cdrom_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1496 case CDROMREADAUDIO
:
1497 err
= cdrom_do_read_audio(fd
, cmd
, arg
);
1500 case CDROM_SEND_PACKET
:
1501 err
= cdrom_do_generic_command(fd
, cmd
, arg
);
1508 printk("cdrom_ioctl: Unknown cmd fd(%d) "
1509 "cmd(%08x) arg(%08x)\n",
1510 (int)fd
, (unsigned int)cmd
, (unsigned int)arg
);
1519 struct loop_info32
{
1520 compat_int_t lo_number
; /* ioctl r/o */
1521 compat_dev_t lo_device
; /* ioctl r/o */
1522 compat_ulong_t lo_inode
; /* ioctl r/o */
1523 compat_dev_t lo_rdevice
; /* ioctl r/o */
1524 compat_int_t lo_offset
;
1525 compat_int_t lo_encrypt_type
;
1526 compat_int_t lo_encrypt_key_size
; /* ioctl w/o */
1527 compat_int_t lo_flags
; /* ioctl r/o */
1528 char lo_name
[LO_NAME_SIZE
];
1529 unsigned char lo_encrypt_key
[LO_KEY_SIZE
]; /* ioctl w/o */
1530 compat_ulong_t lo_init
[2];
1534 static int loop_status(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1536 mm_segment_t old_fs
= get_fs();
1538 struct loop_info32
*ul
;
1541 ul
= compat_ptr(arg
);
1543 case LOOP_SET_STATUS
:
1544 err
= get_user(l
.lo_number
, &ul
->lo_number
);
1545 err
|= __get_user(l
.lo_device
, &ul
->lo_device
);
1546 err
|= __get_user(l
.lo_inode
, &ul
->lo_inode
);
1547 err
|= __get_user(l
.lo_rdevice
, &ul
->lo_rdevice
);
1548 err
|= __copy_from_user(&l
.lo_offset
, &ul
->lo_offset
,
1549 8 + (unsigned long)l
.lo_init
- (unsigned long)&l
.lo_offset
);
1554 err
= sys_ioctl (fd
, cmd
, (unsigned long)&l
);
1558 case LOOP_GET_STATUS
:
1560 err
= sys_ioctl (fd
, cmd
, (unsigned long)&l
);
1563 err
= put_user(l
.lo_number
, &ul
->lo_number
);
1564 err
|= __put_user(l
.lo_device
, &ul
->lo_device
);
1565 err
|= __put_user(l
.lo_inode
, &ul
->lo_inode
);
1566 err
|= __put_user(l
.lo_rdevice
, &ul
->lo_rdevice
);
1567 err
|= __copy_to_user(&ul
->lo_offset
, &l
.lo_offset
,
1568 (unsigned long)l
.lo_init
- (unsigned long)&l
.lo_offset
);
1576 printk("%s: Unknown loop ioctl cmd, fd(%d) "
1577 "cmd(%08x) arg(%08lx)\n",
1578 __FUNCTION__
, fd
, cmd
, arg
);
1584 extern int tty_ioctl(struct inode
* inode
, struct file
* file
, unsigned int cmd
, unsigned long arg
);
1588 static int vt_check(struct file
*file
)
1590 struct tty_struct
*tty
;
1591 struct inode
*inode
= file
->f_dentry
->d_inode
;
1593 if (file
->f_op
->ioctl
!= tty_ioctl
)
1596 tty
= (struct tty_struct
*)file
->private_data
;
1597 if (tty_paranoia_check(tty
, inode
, "tty_ioctl"))
1600 if (tty
->driver
->ioctl
!= vt_ioctl
)
1604 * To have permissions to do most of the vt ioctls, we either have
1605 * to be the owner of the tty, or super-user.
1607 if (current
->tty
== tty
|| capable(CAP_SYS_ADMIN
))
1612 struct consolefontdesc32
{
1613 unsigned short charcount
; /* characters in font (256 or 512) */
1614 unsigned short charheight
; /* scan lines per character (1-32) */
1615 compat_caddr_t chardata
; /* font data in expanded form */
1618 static int do_fontx_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1620 struct consolefontdesc cfdarg
;
1621 struct console_font_op op
;
1622 struct consolefontdesc32
*user_cfd
= compat_ptr(arg
);
1625 perm
= vt_check(file
);
1626 if (perm
< 0) return perm
;
1628 if (copy_from_user(&cfdarg
, user_cfd
, sizeof(struct consolefontdesc32
)))
1631 cfdarg
.chardata
= compat_ptr(((struct consolefontdesc32
*)&cfdarg
)->chardata
);
1637 op
.op
= KD_FONT_OP_SET
;
1640 op
.height
= cfdarg
.charheight
;
1641 op
.charcount
= cfdarg
.charcount
;
1642 op
.data
= cfdarg
.chardata
;
1643 return con_font_op(fg_console
, &op
);
1645 if (!cfdarg
.chardata
)
1647 op
.op
= KD_FONT_OP_GET
;
1650 op
.height
= cfdarg
.charheight
;
1651 op
.charcount
= cfdarg
.charcount
;
1652 op
.data
= cfdarg
.chardata
;
1653 i
= con_font_op(fg_console
, &op
);
1656 cfdarg
.charheight
= op
.height
;
1657 cfdarg
.charcount
= op
.charcount
;
1658 ((struct consolefontdesc32
*)&cfdarg
)->chardata
= (unsigned long)cfdarg
.chardata
;
1659 if (copy_to_user(user_cfd
, &cfdarg
, sizeof(struct consolefontdesc32
)))
1666 struct console_font_op32
{
1667 compat_uint_t op
; /* operation code KD_FONT_OP_* */
1668 compat_uint_t flags
; /* KD_FONT_FLAG_* */
1669 compat_uint_t width
, height
; /* font size */
1670 compat_uint_t charcount
;
1671 compat_caddr_t data
; /* font data with height fixed to 32 */
1674 static int do_kdfontop_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1676 struct console_font_op op
;
1677 struct console_font_op32
*fontop
= compat_ptr(arg
);
1678 int perm
= vt_check(file
), i
;
1679 struct vt_struct
*vt
;
1681 if (perm
< 0) return perm
;
1683 if (copy_from_user(&op
, (void *) fontop
, sizeof(struct console_font_op32
)))
1685 if (!perm
&& op
.op
!= KD_FONT_OP_GET
)
1687 op
.data
= compat_ptr(((struct console_font_op32
*)&op
)->data
);
1688 op
.flags
|= KD_FONT_FLAG_OLD
;
1689 vt
= (struct vt_struct
*)((struct tty_struct
*)file
->private_data
)->driver_data
;
1690 i
= con_font_op(vt
->vc_num
, &op
);
1692 ((struct console_font_op32
*)&op
)->data
= (unsigned long)op
.data
;
1693 if (copy_to_user((void *) fontop
, &op
, sizeof(struct console_font_op32
)))
1698 struct unimapdesc32
{
1699 unsigned short entry_ct
;
1700 compat_caddr_t entries
;
1703 static int do_unimap_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
, struct file
*file
)
1705 struct unimapdesc32 tmp
;
1706 struct unimapdesc32
*user_ud
= compat_ptr(arg
);
1707 int perm
= vt_check(file
);
1709 if (perm
< 0) return perm
;
1710 if (copy_from_user(&tmp
, user_ud
, sizeof tmp
))
1714 if (!perm
) return -EPERM
;
1715 return con_set_unimap(fg_console
, tmp
.entry_ct
, compat_ptr(tmp
.entries
));
1717 return con_get_unimap(fg_console
, tmp
.entry_ct
, &(user_ud
->entry_ct
), compat_ptr(tmp
.entries
));
1722 #endif /* CONFIG_VT */
1724 static int do_smb_getmountuid(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1726 mm_segment_t old_fs
= get_fs();
1727 __kernel_uid_t kuid
;
1730 cmd
= SMB_IOC_GETMOUNTUID
;
1733 err
= sys_ioctl(fd
, cmd
, (unsigned long)&kuid
);
1737 err
= put_user(kuid
, (compat_uid_t
*)compat_ptr(arg
));
1742 struct atmif_sioc32
{
1743 compat_int_t number
;
1744 compat_int_t length
;
1748 struct atm_iobuf32
{
1749 compat_int_t length
;
1750 compat_caddr_t buffer
;
1753 #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
1754 #define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
1755 #define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
1756 #define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
1757 #define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
1758 #define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
1759 #define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
1760 #define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
1761 #define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
1762 #define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
1763 #define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
1764 #define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
1765 #define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
1766 #define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
1767 #define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
1768 #define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
1769 #define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
1774 } atm_ioctl_map
[] = {
1775 { ATM_GETLINKRATE32
, ATM_GETLINKRATE
},
1776 { ATM_GETNAMES32
, ATM_GETNAMES
},
1777 { ATM_GETTYPE32
, ATM_GETTYPE
},
1778 { ATM_GETESI32
, ATM_GETESI
},
1779 { ATM_GETADDR32
, ATM_GETADDR
},
1780 { ATM_RSTADDR32
, ATM_RSTADDR
},
1781 { ATM_ADDADDR32
, ATM_ADDADDR
},
1782 { ATM_DELADDR32
, ATM_DELADDR
},
1783 { ATM_GETCIRANGE32
, ATM_GETCIRANGE
},
1784 { ATM_SETCIRANGE32
, ATM_SETCIRANGE
},
1785 { ATM_SETESI32
, ATM_SETESI
},
1786 { ATM_SETESIF32
, ATM_SETESIF
},
1787 { ATM_GETSTAT32
, ATM_GETSTAT
},
1788 { ATM_GETSTATZ32
, ATM_GETSTATZ
},
1789 { ATM_GETLOOP32
, ATM_GETLOOP
},
1790 { ATM_SETLOOP32
, ATM_SETLOOP
},
1791 { ATM_QUERYLOOP32
, ATM_QUERYLOOP
}
1794 #define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
1797 static int do_atm_iobuf(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1799 struct atm_iobuf
*iobuf
;
1800 struct atm_iobuf32
*iobuf32
;
1805 iobuf
= compat_alloc_user_space(sizeof(*iobuf
));
1806 iobuf32
= compat_ptr(arg
);
1808 if (get_user(len
, &iobuf32
->length
) ||
1809 get_user(data
, &iobuf32
->buffer
))
1811 datap
= compat_ptr(data
);
1812 if (put_user(len
, &iobuf
->length
) ||
1813 put_user(datap
, &iobuf
->buffer
))
1816 err
= sys_ioctl(fd
, cmd
, (unsigned long)iobuf
);
1819 if (copy_in_user(&iobuf32
->length
, &iobuf
->length
,
1827 static int do_atmif_sioc(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1829 struct atmif_sioc
*sioc
;
1830 struct atmif_sioc32
*sioc32
;
1835 sioc
= compat_alloc_user_space(sizeof(*sioc
));
1836 sioc32
= compat_ptr(arg
);
1838 if (copy_in_user(&sioc
->number
, &sioc32
->number
, 2 * sizeof(int)) ||
1839 get_user(data
, &sioc32
->arg
))
1841 datap
= compat_ptr(data
);
1842 if (put_user(datap
, &sioc
->arg
))
1845 err
= sys_ioctl(fd
, cmd
, (unsigned long) sioc
);
1848 if (copy_in_user(&sioc32
->length
, &sioc
->length
,
1855 static int do_atm_ioctl(unsigned int fd
, unsigned int cmd32
, unsigned long arg
)
1858 unsigned int cmd
= 0;
1862 case SONET_GETSTATZ
:
1866 case SONET_SETFRAMING
:
1867 case SONET_GETFRAMING
:
1868 case SONET_GETFRSENSE
:
1869 return do_atmif_sioc(fd
, cmd32
, arg
);
1872 for (i
= 0; i
< NR_ATM_IOCTL
; i
++) {
1873 if (cmd32
== atm_ioctl_map
[i
].cmd32
) {
1874 cmd
= atm_ioctl_map
[i
].cmd
;
1878 if (i
== NR_ATM_IOCTL
)
1883 return do_atm_iobuf(fd
, cmd
, arg
);
1885 case ATM_GETLINKRATE
:
1892 case ATM_GETCIRANGE
:
1893 case ATM_SETCIRANGE
:
1901 return do_atmif_sioc(fd
, cmd
, arg
);
1907 static int ret_einval(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1912 static int broken_blkgetsize(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1914 /* The mkswap binary hard codes it to Intel value :-((( */
1915 return w_long(fd
, BLKGETSIZE
, arg
);
1918 struct blkpg_ioctl_arg32
{
1921 compat_int_t datalen
;
1922 compat_caddr_t data
;
1925 static int blkpg_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1927 struct blkpg_ioctl_arg a
;
1928 struct blkpg_ioctl_arg32
*ua32
;
1929 struct blkpg_partition p
;
1930 struct blkpg_partition
*up32
;
1931 compat_caddr_t udata
;
1933 mm_segment_t old_fs
= get_fs();
1935 ua32
= compat_ptr(arg
);
1936 err
= get_user(a
.op
, &ua32
->op
);
1937 err
|= __get_user(a
.flags
, &ua32
->flags
);
1938 err
|= __get_user(a
.datalen
, &ua32
->datalen
);
1939 err
|= __get_user(udata
, &ua32
->data
);
1940 up32
= compat_ptr(udata
);
1945 case BLKPG_ADD_PARTITION
:
1946 case BLKPG_DEL_PARTITION
:
1947 if (a
.datalen
< sizeof(struct blkpg_partition
))
1949 if (copy_from_user(&p
, up32
, sizeof(struct blkpg_partition
)))
1953 err
= sys_ioctl(fd
, cmd
, (unsigned long)&a
);
1962 static int ioc_settimeout(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1964 return rw_long(fd
, AUTOFS_IOC_SETTIMEOUT
, arg
);
1967 /* Fix sizeof(sizeof()) breakage */
1968 #define BLKBSZGET_32 _IOR(0x12,112,int)
1969 #define BLKBSZSET_32 _IOW(0x12,113,int)
1970 #define BLKGETSIZE64_32 _IOR(0x12,114,int)
1972 static int do_blkbszget(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1974 return sys_ioctl(fd
, BLKBSZGET
, (unsigned long)compat_ptr(arg
));
1977 static int do_blkbszset(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
1979 return sys_ioctl(fd
, BLKBSZSET
, (unsigned long)compat_ptr(arg
));
1982 static int do_blkgetsize64(unsigned int fd
, unsigned int cmd
,
1985 return sys_ioctl(fd
, BLKGETSIZE64
, (unsigned long)compat_ptr(arg
));
1988 /* Bluetooth ioctls */
1989 #define HCIUARTSETPROTO _IOW('U', 200, int)
1990 #define HCIUARTGETPROTO _IOR('U', 201, int)
1992 #define BNEPCONNADD _IOW('B', 200, int)
1993 #define BNEPCONNDEL _IOW('B', 201, int)
1994 #define BNEPGETCONNLIST _IOR('B', 210, int)
1995 #define BNEPGETCONNINFO _IOR('B', 211, int)
1997 #define CMTPCONNADD _IOW('C', 200, int)
1998 #define CMTPCONNDEL _IOW('C', 201, int)
1999 #define CMTPGETCONNLIST _IOR('C', 210, int)
2000 #define CMTPGETCONNINFO _IOR('C', 211, int)
2002 struct floppy_struct32
{
2006 compat_uint_t track
;
2007 compat_uint_t stretch
;
2010 unsigned char spec1
;
2011 unsigned char fmt_gap
;
2012 const compat_caddr_t name
;
2015 struct floppy_drive_params32
{
2017 compat_ulong_t max_dtr
;
2021 compat_ulong_t spinup
;
2022 compat_ulong_t spindown
;
2023 unsigned char spindown_offset
;
2024 unsigned char select_delay
;
2026 unsigned char tracks
;
2027 compat_ulong_t timeout
;
2028 unsigned char interleave_sect
;
2029 struct floppy_max_errors max_errors
;
2032 short autodetect
[8];
2033 compat_int_t checkfreq
;
2034 compat_int_t native_format
;
2037 struct floppy_drive_struct32
{
2039 compat_ulong_t spinup_date
;
2040 compat_ulong_t select_date
;
2041 compat_ulong_t first_read_date
;
2042 short probed_format
;
2046 compat_int_t generation
;
2047 compat_int_t keep_data
;
2048 compat_int_t fd_ref
;
2049 compat_int_t fd_device
;
2050 compat_int_t last_checked
;
2051 compat_caddr_t dmabuf
;
2052 compat_int_t bufblocks
;
2055 struct floppy_fdc_state32
{
2059 unsigned char version
;
2061 compat_ulong_t address
;
2062 unsigned int rawcmd
:2;
2063 unsigned int reset
:1;
2064 unsigned int need_configure
:1;
2065 unsigned int perp_mode
:2;
2066 unsigned int has_fifo
:1;
2067 unsigned int driver_version
;
2068 unsigned char track
[4];
2071 struct floppy_write_errors32
{
2072 unsigned int write_errors
;
2073 compat_ulong_t first_error_sector
;
2074 compat_int_t first_error_generation
;
2075 compat_ulong_t last_error_sector
;
2076 compat_int_t last_error_generation
;
2077 compat_uint_t badness
;
2080 #define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
2081 #define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
2082 #define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
2083 #define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
2084 #define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
2085 #define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
2086 #define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
2087 #define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
2088 #define FDWERRORGET32 _IOR(2, 0x17, struct floppy_write_errors32)
2093 } fd_ioctl_trans_table
[] = {
2094 { FDSETPRM32
, FDSETPRM
},
2095 { FDDEFPRM32
, FDDEFPRM
},
2096 { FDGETPRM32
, FDGETPRM
},
2097 { FDSETDRVPRM32
, FDSETDRVPRM
},
2098 { FDGETDRVPRM32
, FDGETDRVPRM
},
2099 { FDGETDRVSTAT32
, FDGETDRVSTAT
},
2100 { FDPOLLDRVSTAT32
, FDPOLLDRVSTAT
},
2101 { FDGETFDCSTAT32
, FDGETFDCSTAT
},
2102 { FDWERRORGET32
, FDWERRORGET
}
2105 #define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
2107 static int fd_ioctl_trans(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2109 mm_segment_t old_fs
= get_fs();
2111 unsigned int kcmd
= 0;
2114 for (i
= 0; i
< NR_FD_IOCTL_TRANS
; i
++)
2115 if (cmd
== fd_ioctl_trans_table
[i
].cmd32
) {
2116 kcmd
= fd_ioctl_trans_table
[i
].cmd
;
2128 struct floppy_struct32
*uf
;
2129 struct floppy_struct
*f
;
2131 uf
= compat_ptr(arg
);
2132 f
= karg
= kmalloc(sizeof(struct floppy_struct
), GFP_KERNEL
);
2135 if (cmd
== FDGETPRM32
)
2137 err
= __get_user(f
->size
, &uf
->size
);
2138 err
|= __get_user(f
->sect
, &uf
->sect
);
2139 err
|= __get_user(f
->head
, &uf
->head
);
2140 err
|= __get_user(f
->track
, &uf
->track
);
2141 err
|= __get_user(f
->stretch
, &uf
->stretch
);
2142 err
|= __get_user(f
->gap
, &uf
->gap
);
2143 err
|= __get_user(f
->rate
, &uf
->rate
);
2144 err
|= __get_user(f
->spec1
, &uf
->spec1
);
2145 err
|= __get_user(f
->fmt_gap
, &uf
->fmt_gap
);
2146 err
|= __get_user(name
, &uf
->name
);
2147 f
->name
= compat_ptr(name
);
2157 struct floppy_drive_params32
*uf
;
2158 struct floppy_drive_params
*f
;
2160 uf
= compat_ptr(arg
);
2161 f
= karg
= kmalloc(sizeof(struct floppy_drive_params
), GFP_KERNEL
);
2164 if (cmd
== FDGETDRVPRM32
)
2166 err
= __get_user(f
->cmos
, &uf
->cmos
);
2167 err
|= __get_user(f
->max_dtr
, &uf
->max_dtr
);
2168 err
|= __get_user(f
->hlt
, &uf
->hlt
);
2169 err
|= __get_user(f
->hut
, &uf
->hut
);
2170 err
|= __get_user(f
->srt
, &uf
->srt
);
2171 err
|= __get_user(f
->spinup
, &uf
->spinup
);
2172 err
|= __get_user(f
->spindown
, &uf
->spindown
);
2173 err
|= __get_user(f
->spindown_offset
, &uf
->spindown_offset
);
2174 err
|= __get_user(f
->select_delay
, &uf
->select_delay
);
2175 err
|= __get_user(f
->rps
, &uf
->rps
);
2176 err
|= __get_user(f
->tracks
, &uf
->tracks
);
2177 err
|= __get_user(f
->timeout
, &uf
->timeout
);
2178 err
|= __get_user(f
->interleave_sect
, &uf
->interleave_sect
);
2179 err
|= __copy_from_user(&f
->max_errors
, &uf
->max_errors
, sizeof(f
->max_errors
));
2180 err
|= __get_user(f
->flags
, &uf
->flags
);
2181 err
|= __get_user(f
->read_track
, &uf
->read_track
);
2182 err
|= __copy_from_user(f
->autodetect
, uf
->autodetect
, sizeof(f
->autodetect
));
2183 err
|= __get_user(f
->checkfreq
, &uf
->checkfreq
);
2184 err
|= __get_user(f
->native_format
, &uf
->native_format
);
2191 case FDGETDRVSTAT32
:
2192 case FDPOLLDRVSTAT32
:
2193 karg
= kmalloc(sizeof(struct floppy_drive_struct
), GFP_KERNEL
);
2197 case FDGETFDCSTAT32
:
2198 karg
= kmalloc(sizeof(struct floppy_fdc_state
), GFP_KERNEL
);
2203 karg
= kmalloc(sizeof(struct floppy_write_errors
), GFP_KERNEL
);
2211 err
= sys_ioctl (fd
, kcmd
, (unsigned long)karg
);
2218 struct floppy_struct
*f
= karg
;
2220 err
= __put_user(f
->size
, &((struct floppy_struct32
*)arg
)->size
);
2221 err
|= __put_user(f
->sect
, &((struct floppy_struct32
*)arg
)->sect
);
2222 err
|= __put_user(f
->head
, &((struct floppy_struct32
*)arg
)->head
);
2223 err
|= __put_user(f
->track
, &((struct floppy_struct32
*)arg
)->track
);
2224 err
|= __put_user(f
->stretch
, &((struct floppy_struct32
*)arg
)->stretch
);
2225 err
|= __put_user(f
->gap
, &((struct floppy_struct32
*)arg
)->gap
);
2226 err
|= __put_user(f
->rate
, &((struct floppy_struct32
*)arg
)->rate
);
2227 err
|= __put_user(f
->spec1
, &((struct floppy_struct32
*)arg
)->spec1
);
2228 err
|= __put_user(f
->fmt_gap
, &((struct floppy_struct32
*)arg
)->fmt_gap
);
2229 err
|= __put_user((u64
)f
->name
, (compat_caddr_t
*)&((struct floppy_struct32
*)arg
)->name
);
2234 struct floppy_drive_params32
*uf
;
2235 struct floppy_drive_params
*f
= karg
;
2237 uf
= compat_ptr(arg
);
2238 err
= __put_user(f
->cmos
, &uf
->cmos
);
2239 err
|= __put_user(f
->max_dtr
, &uf
->max_dtr
);
2240 err
|= __put_user(f
->hlt
, &uf
->hlt
);
2241 err
|= __put_user(f
->hut
, &uf
->hut
);
2242 err
|= __put_user(f
->srt
, &uf
->srt
);
2243 err
|= __put_user(f
->spinup
, &uf
->spinup
);
2244 err
|= __put_user(f
->spindown
, &uf
->spindown
);
2245 err
|= __put_user(f
->spindown_offset
, &uf
->spindown_offset
);
2246 err
|= __put_user(f
->select_delay
, &uf
->select_delay
);
2247 err
|= __put_user(f
->rps
, &uf
->rps
);
2248 err
|= __put_user(f
->tracks
, &uf
->tracks
);
2249 err
|= __put_user(f
->timeout
, &uf
->timeout
);
2250 err
|= __put_user(f
->interleave_sect
, &uf
->interleave_sect
);
2251 err
|= __copy_to_user(&uf
->max_errors
, &f
->max_errors
, sizeof(f
->max_errors
));
2252 err
|= __put_user(f
->flags
, &uf
->flags
);
2253 err
|= __put_user(f
->read_track
, &uf
->read_track
);
2254 err
|= __copy_to_user(uf
->autodetect
, f
->autodetect
, sizeof(f
->autodetect
));
2255 err
|= __put_user(f
->checkfreq
, &uf
->checkfreq
);
2256 err
|= __put_user(f
->native_format
, &uf
->native_format
);
2259 case FDGETDRVSTAT32
:
2260 case FDPOLLDRVSTAT32
:
2262 struct floppy_drive_struct32
*uf
;
2263 struct floppy_drive_struct
*f
= karg
;
2265 uf
= compat_ptr(arg
);
2266 err
= __put_user(f
->flags
, &uf
->flags
);
2267 err
|= __put_user(f
->spinup_date
, &uf
->spinup_date
);
2268 err
|= __put_user(f
->select_date
, &uf
->select_date
);
2269 err
|= __put_user(f
->first_read_date
, &uf
->first_read_date
);
2270 err
|= __put_user(f
->probed_format
, &uf
->probed_format
);
2271 err
|= __put_user(f
->track
, &uf
->track
);
2272 err
|= __put_user(f
->maxblock
, &uf
->maxblock
);
2273 err
|= __put_user(f
->maxtrack
, &uf
->maxtrack
);
2274 err
|= __put_user(f
->generation
, &uf
->generation
);
2275 err
|= __put_user(f
->keep_data
, &uf
->keep_data
);
2276 err
|= __put_user(f
->fd_ref
, &uf
->fd_ref
);
2277 err
|= __put_user(f
->fd_device
, &uf
->fd_device
);
2278 err
|= __put_user(f
->last_checked
, &uf
->last_checked
);
2279 err
|= __put_user((u64
)f
->dmabuf
, &uf
->dmabuf
);
2280 err
|= __put_user((u64
)f
->bufblocks
, &uf
->bufblocks
);
2283 case FDGETFDCSTAT32
:
2285 struct floppy_fdc_state32
*uf
;
2286 struct floppy_fdc_state
*f
= karg
;
2288 uf
= compat_ptr(arg
);
2289 err
= __put_user(f
->spec1
, &uf
->spec1
);
2290 err
|= __put_user(f
->spec2
, &uf
->spec2
);
2291 err
|= __put_user(f
->dtr
, &uf
->dtr
);
2292 err
|= __put_user(f
->version
, &uf
->version
);
2293 err
|= __put_user(f
->dor
, &uf
->dor
);
2294 err
|= __put_user(f
->address
, &uf
->address
);
2295 err
|= __copy_to_user((char *)&uf
->address
+ sizeof(uf
->address
),
2296 (char *)&f
->address
+ sizeof(f
->address
), sizeof(int));
2297 err
|= __put_user(f
->driver_version
, &uf
->driver_version
);
2298 err
|= __copy_to_user(uf
->track
, f
->track
, sizeof(f
->track
));
2303 struct floppy_write_errors32
*uf
;
2304 struct floppy_write_errors
*f
= karg
;
2306 uf
= compat_ptr(arg
);
2307 err
= __put_user(f
->write_errors
, &uf
->write_errors
);
2308 err
|= __put_user(f
->first_error_sector
, &uf
->first_error_sector
);
2309 err
|= __put_user(f
->first_error_generation
, &uf
->first_error_generation
);
2310 err
|= __put_user(f
->last_error_sector
, &uf
->last_error_sector
);
2311 err
|= __put_user(f
->last_error_generation
, &uf
->last_error_generation
);
2312 err
|= __put_user(f
->badness
, &uf
->badness
);
2321 out
: if (karg
) kfree(karg
);
2325 struct mtd_oob_buf32
{
2328 compat_caddr_t ptr
; /* unsigned char* */
2331 #define MEMWRITEOOB32 _IOWR('M',3,struct mtd_oob_buf32)
2332 #define MEMREADOOB32 _IOWR('M',4,struct mtd_oob_buf32)
2334 static int mtd_rw_oob(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2336 struct mtd_oob_buf
*buf
= compat_alloc_user_space(sizeof(*buf
));
2337 struct mtd_oob_buf32
*buf32
= compat_ptr(arg
);
2340 unsigned int real_cmd
;
2343 real_cmd
= (cmd
== MEMREADOOB32
) ?
2344 MEMREADOOB
: MEMWRITEOOB
;
2346 if (copy_in_user(&buf
->start
, &buf32
->start
,
2348 get_user(data
, &buf32
->ptr
))
2350 datap
= compat_ptr(data
);
2351 if (put_user(datap
, &buf
->ptr
))
2354 err
= sys_ioctl(fd
, real_cmd
, (unsigned long) buf
);
2357 if (copy_in_user(&buf32
->start
, &buf
->start
,
2365 #define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
2366 #define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
2369 put_dirent32 (struct dirent
*d
, struct compat_dirent
*d32
)
2373 if ((ret
= verify_area(VERIFY_WRITE
, d32
,
2374 sizeof(struct compat_dirent
))))
2377 __put_user(d
->d_ino
, &d32
->d_ino
);
2378 __put_user(d
->d_off
, &d32
->d_off
);
2379 __put_user(d
->d_reclen
, &d32
->d_reclen
);
2380 __copy_to_user(d32
->d_name
, d
->d_name
, d
->d_reclen
);
2384 static int vfat_ioctl32(unsigned fd
, unsigned cmd
, unsigned long arg
)
2387 mm_segment_t oldfs
= get_fs();
2392 case VFAT_IOCTL_READDIR_BOTH32
:
2393 cmd
= VFAT_IOCTL_READDIR_BOTH
;
2395 case VFAT_IOCTL_READDIR_SHORT32
:
2396 cmd
= VFAT_IOCTL_READDIR_SHORT
;
2401 ret
= sys_ioctl(fd
,cmd
,(unsigned long)&d
);
2404 ret
|= put_dirent32(&d
[0], (struct compat_dirent
*)compat_ptr(arg
));
2405 ret
|= put_dirent32(&d
[1], ((struct compat_dirent
*)compat_ptr(arg
)) + 1);
2410 #define REISERFS_IOC_UNPACK32 _IOW(0xCD,1,int)
2412 static int reiserfs_ioctl32(unsigned fd
, unsigned cmd
, unsigned long ptr
)
2414 if (cmd
== REISERFS_IOC_UNPACK32
)
2415 cmd
= REISERFS_IOC_UNPACK
;
2417 return sys_ioctl(fd
,cmd
,ptr
);
2420 struct raw32_config_request
2422 compat_int_t raw_minor
;
2425 } __attribute__((packed
));
2427 static int get_raw32_request(struct raw_config_request
*req
, struct raw32_config_request
*user_req
)
2429 __u32 lo_maj
, hi_maj
, lo_min
, hi_min
;
2432 if ((ret
= verify_area(VERIFY_READ
, user_req
,
2433 sizeof(struct raw32_config_request
))))
2436 __get_user(req
->raw_minor
, &user_req
->raw_minor
);
2437 __get_user(lo_maj
, (__u32
*)&user_req
->block_major
);
2438 __get_user(hi_maj
, ((__u32
*)(&user_req
->block_major
) + 1));
2439 __get_user(lo_min
, (__u32
*)&user_req
->block_minor
);
2440 __get_user(hi_min
, ((__u32
*)(&user_req
->block_minor
) + 1));
2442 req
->block_major
= lo_maj
| (((__u64
)hi_maj
) << 32);
2443 req
->block_minor
= lo_min
| (((__u64
)hi_min
) << 32);
2448 static int set_raw32_request(struct raw_config_request
*req
, struct raw32_config_request
*user_req
)
2452 if ((ret
= verify_area(VERIFY_WRITE
, user_req
,
2453 sizeof(struct raw32_config_request
))))
2456 __put_user(req
->raw_minor
, &user_req
->raw_minor
);
2457 __put_user((__u32
)(req
->block_major
), (__u32
*)&user_req
->block_major
);
2458 __put_user((__u32
)(req
->block_major
>> 32), ((__u32
*)(&user_req
->block_major
) + 1));
2459 __put_user((__u32
)(req
->block_minor
), (__u32
*)&user_req
->block_minor
);
2460 __put_user((__u32
)(req
->block_minor
>> 32), ((__u32
*)(&user_req
->block_minor
) + 1));
2465 static int raw_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
2472 struct raw_config_request req
;
2473 struct raw32_config_request
*user_req
= compat_ptr(arg
);
2474 mm_segment_t oldfs
= get_fs();
2476 if ((ret
= get_raw32_request(&req
, user_req
)))
2480 ret
= sys_ioctl(fd
,cmd
,(unsigned long)&req
);
2483 if ((!ret
) && (cmd
== RAW_GETBIND
)) {
2484 ret
= set_raw32_request(&req
, user_req
);
2489 ret
= sys_ioctl(fd
, cmd
, arg
);
2495 struct serial_struct32
{
2501 compat_int_t xmit_fifo_size
;
2502 compat_int_t custom_divisor
;
2503 compat_int_t baud_base
;
2504 unsigned short close_delay
;
2506 char reserved_char
[1];
2508 unsigned short closing_wait
; /* time to wait before closing */
2509 unsigned short closing_wait2
; /* no longer used... */
2510 compat_uint_t iomem_base
;
2511 unsigned short iomem_reg_shift
;
2512 unsigned int port_high
;
2513 /* compat_ulong_t iomap_base FIXME */
2514 compat_int_t reserved
[1];
2517 static int serial_struct_ioctl(unsigned fd
, unsigned cmd
, unsigned long arg
)
2519 typedef struct serial_struct SS
;
2520 typedef struct serial_struct32 SS32
;
2521 struct serial_struct32
*ss32
= compat_ptr(arg
);
2523 struct serial_struct ss
;
2524 mm_segment_t oldseg
= get_fs();
2527 if (cmd
== TIOCSSERIAL
) {
2528 if (verify_area(VERIFY_READ
, ss32
, sizeof(SS32
)))
2530 __copy_from_user(&ss
, ss32
, offsetof(SS32
, iomem_base
));
2531 __get_user(udata
, &ss32
->iomem_base
);
2532 ss
.iomem_base
= compat_ptr(udata
);
2533 __get_user(ss
.iomem_reg_shift
, &ss32
->iomem_reg_shift
);
2534 __get_user(ss
.port_high
, &ss32
->port_high
);
2535 ss
.iomap_base
= 0UL;
2538 err
= sys_ioctl(fd
,cmd
,(unsigned long)(&ss
));
2540 if (cmd
== TIOCGSERIAL
&& err
>= 0) {
2541 if (verify_area(VERIFY_WRITE
, ss32
, sizeof(SS32
)))
2543 __copy_to_user(ss32
,&ss
,offsetof(SS32
,iomem_base
));
2544 __put_user((unsigned long)ss
.iomem_base
>> 32 ?
2545 0xffffffff : (unsigned)(unsigned long)ss
.iomem_base
,
2547 __put_user(ss
.iomem_reg_shift
, &ss32
->iomem_reg_shift
);
2548 __put_user(ss
.port_high
, &ss32
->port_high
);
2554 struct usbdevfs_ctrltransfer32
{
2560 u32 timeout
; /* in milliseconds */
2561 compat_caddr_t data
;
2564 #define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
2566 static int do_usbdevfs_control(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2568 struct usbdevfs_ctrltransfer kctrl
;
2569 struct usbdevfs_ctrltransfer32
*uctrl
;
2570 mm_segment_t old_fs
;
2575 uctrl
= compat_ptr(arg
);
2577 if (copy_from_user(&kctrl
, uctrl
,
2578 (sizeof(struct usbdevfs_ctrltransfer32
) -
2579 sizeof(compat_caddr_t
))))
2582 if (get_user(udata
, &uctrl
->data
))
2584 uptr
= compat_ptr(udata
);
2585 /* In usbdevice_fs, it limits the control buffer to a page,
2586 * for simplicity so do we.
2588 if (!uptr
|| kctrl
.wLength
> PAGE_SIZE
)
2591 kptr
= (void *)__get_free_page(GFP_KERNEL
);
2593 if ((kctrl
.bRequestType
& USB_DIR_IN
) == 0) {
2595 if (copy_from_user(kptr
, uptr
, kctrl
.wLength
))
2603 err
= sys_ioctl(fd
, USBDEVFS_CONTROL
, (unsigned long)&kctrl
);
2607 ((kctrl
.bRequestType
& USB_DIR_IN
) != 0)) {
2608 if (copy_to_user(uptr
, kptr
, kctrl
.wLength
))
2613 free_page((unsigned long) kptr
);
2618 struct usbdevfs_bulktransfer32
{
2621 compat_uint_t timeout
; /* in milliseconds */
2622 compat_caddr_t data
;
2625 #define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
2627 static int do_usbdevfs_bulk(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2629 struct usbdevfs_bulktransfer kbulk
;
2630 struct usbdevfs_bulktransfer32
*ubulk
;
2631 mm_segment_t old_fs
;
2636 ubulk
= compat_ptr(arg
);
2638 if (get_user(kbulk
.ep
, &ubulk
->ep
) ||
2639 get_user(kbulk
.len
, &ubulk
->len
) ||
2640 get_user(kbulk
.timeout
, &ubulk
->timeout
) ||
2641 get_user(udata
, &ubulk
->data
))
2644 uptr
= compat_ptr(udata
);
2646 /* In usbdevice_fs, it limits the control buffer to a page,
2647 * for simplicity so do we.
2649 if (!uptr
|| kbulk
.len
> PAGE_SIZE
)
2652 kptr
= (void *) __get_free_page(GFP_KERNEL
);
2654 if ((kbulk
.ep
& 0x80) == 0) {
2656 if (copy_from_user(kptr
, uptr
, kbulk
.len
))
2664 err
= sys_ioctl(fd
, USBDEVFS_BULK
, (unsigned long) &kbulk
);
2668 ((kbulk
.ep
& 0x80) != 0)) {
2669 if (copy_to_user(uptr
, kptr
, kbulk
.len
))
2674 free_page((unsigned long) kptr
);
2678 /* This needs more work before we can enable it. Unfortunately
2679 * because of the fancy asynchronous way URB status/error is written
2680 * back to userspace, we'll need to fiddle with USB devio internals
2681 * and/or reimplement entirely the frontend of it ourselves. -DaveM
2685 * When an URB is submitted via usbdevicefs it is put onto an
2686 * asynchronous queue. When the URB completes, it may be reaped
2687 * via another ioctl. During this reaping the status is written
2688 * back to userspace along with the length of the transfer.
2690 * We must translate into 64-bit kernel types so we pass in a kernel
2691 * space copy of the usbdevfs_urb structure. This would mean that we
2692 * must do something to deal with the async entry reaping. First we
2693 * have to deal somehow with this transitory memory we've allocated.
2694 * This is problematic since there are many call sites from which the
2695 * async entries can be destroyed (and thus when we'd need to free up
2696 * this kernel memory). One of which is the close() op of usbdevicefs.
2697 * To handle that we'd need to make our own file_operations struct which
2698 * overrides usbdevicefs's release op with our own which runs usbdevicefs's
2699 * real release op then frees up the kernel memory.
2701 * But how to keep track of these kernel buffers? We'd need to either
2702 * keep track of them in some table _or_ know about usbdevicefs internals
2703 * (ie. the exact layout of its file private, which is actually defined
2704 * in linux/usbdevice_fs.h, the layout of the async queues are private to
2707 * There is one possible other solution I considered, also involving knowledge
2708 * of usbdevicefs internals:
2710 * After an URB is submitted, we "fix up" the address back to the user
2711 * space one. This would work if the status/length fields written back
2712 * by the async URB completion lines up perfectly in the 32-bit type with
2713 * the 64-bit kernel type. Unfortunately, it does not because the iso
2714 * frame descriptors, at the end of the struct, can be written back.
2716 * I think we'll just need to simply duplicate the devio URB engine here.
2719 struct usbdevfs_urb32
{
2721 unsigned char endpoint
;
2722 compat_int_t status
;
2723 compat_uint_t flags
;
2724 compat_caddr_t buffer
;
2725 compat_int_t buffer_length
;
2726 compat_int_t actual_length
;
2727 compat_int_t start_frame
;
2728 compat_int_t number_of_packets
;
2729 compat_int_t error_count
;
2730 compat_uint_t signr
;
2731 compat_caddr_t usercontext
; /* unused */
2732 struct usbdevfs_iso_packet_desc iso_frame_desc
[0];
2735 #define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
2737 static int get_urb32(struct usbdevfs_urb
*kurb
,
2738 struct usbdevfs_urb32
*uurb
)
2740 if (get_user(kurb
->type
, &uurb
->type
) ||
2741 __get_user(kurb
->endpoint
, &uurb
->endpoint
) ||
2742 __get_user(kurb
->status
, &uurb
->status
) ||
2743 __get_user(kurb
->flags
, &uurb
->flags
) ||
2744 __get_user(kurb
->buffer_length
, &uurb
->buffer_length
) ||
2745 __get_user(kurb
->actual_length
, &uurb
->actual_length
) ||
2746 __get_user(kurb
->start_frame
, &uurb
->start_frame
) ||
2747 __get_user(kurb
->number_of_packets
, &uurb
->number_of_packets
) ||
2748 __get_user(kurb
->error_count
, &uurb
->error_count
) ||
2749 __get_user(kurb
->signr
, &uurb
->signr
))
2752 kurb
->usercontext
= 0; /* unused currently */
2757 /* Just put back the values which usbdevfs actually changes. */
2758 static int put_urb32(struct usbdevfs_urb
*kurb
,
2759 struct usbdevfs_urb32
*uurb
)
2761 if (put_user(kurb
->status
, &uurb
->status
) ||
2762 __put_user(kurb
->actual_length
, &uurb
->actual_length
) ||
2763 __put_user(kurb
->error_count
, &uurb
->error_count
))
2766 if (kurb
->number_of_packets
!= 0) {
2769 for (i
= 0; i
< kurb
->number_of_packets
; i
++) {
2770 if (__put_user(kurb
->iso_frame_desc
[i
].actual_length
,
2771 &uurb
->iso_frame_desc
[i
].actual_length
) ||
2772 __put_user(kurb
->iso_frame_desc
[i
].status
,
2773 &uurb
->iso_frame_desc
[i
].status
))
2781 static int get_urb32_isoframes(struct usbdevfs_urb
*kurb
,
2782 struct usbdevfs_urb32
*uurb
)
2784 unsigned int totlen
;
2787 if (kurb
->type
!= USBDEVFS_URB_TYPE_ISO
) {
2788 kurb
->number_of_packets
= 0;
2792 if (kurb
->number_of_packets
< 1 ||
2793 kurb
->number_of_packets
> 128)
2796 if (copy_from_user(&kurb
->iso_frame_desc
[0],
2797 &uurb
->iso_frame_desc
[0],
2798 sizeof(struct usbdevfs_iso_packet_desc
) *
2799 kurb
->number_of_packets
))
2803 for (i
= 0; i
< kurb
->number_of_packets
; i
++) {
2804 unsigned int this_len
;
2806 this_len
= kurb
->iso_frame_desc
[i
].length
;
2807 if (this_len
> 1023)
2816 kurb
->buffer_length
= totlen
;
2821 static int do_usbdevfs_urb(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2823 struct usbdevfs_urb
*kurb
;
2824 struct usbdevfs_urb32
*uurb
;
2825 mm_segment_t old_fs
;
2828 unsigned int buflen
;
2831 uurb
= compat_ptr(arg
);
2834 kurb
= kmalloc(sizeof(struct usbdevfs_urb
) +
2835 (sizeof(struct usbdevfs_iso_packet_desc
) * 128),
2841 if (get_urb32(kurb
, uurb
))
2844 err
= get_urb32_isoframes(kurb
, uurb
);
2849 if (__get_user(udata
, &uurb
->buffer
))
2851 uptr
= compat_ptr(udata
);
2853 buflen
= kurb
->buffer_length
;
2854 err
= verify_area(VERIFY_WRITE
, uptr
, buflen
);
2861 err
= sys_ioctl(fd
, USBDEVFS_SUBMITURB
, (unsigned long) kurb
);
2865 /* RED-PEN Shit, this doesn't work for async URBs :-( XXX */
2866 if (put_urb32(kurb
, uurb
)) {
2877 #define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
2878 #define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
2880 static int do_usbdevfs_reapurb(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2882 mm_segment_t old_fs
;
2889 (cmd
== USBDEVFS_REAPURB32
?
2891 USBDEVFS_REAPURBNDELAY
),
2892 (unsigned long) &kptr
);
2896 put_user((u32
)(u64
)kptr
, (u32
*)compat_ptr(arg
)))
2902 struct usbdevfs_disconnectsignal32
{
2904 compat_caddr_t context
;
2907 #define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
2909 static int do_usbdevfs_discsignal(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2911 struct usbdevfs_disconnectsignal kdis
;
2912 struct usbdevfs_disconnectsignal32
*udis
;
2913 mm_segment_t old_fs
;
2917 udis
= compat_ptr(arg
);
2919 if (get_user(kdis
.signr
, &udis
->signr
) ||
2920 __get_user(uctx
, &udis
->context
))
2923 kdis
.context
= compat_ptr(uctx
);
2927 err
= sys_ioctl(fd
, USBDEVFS_DISCSIGNAL
, (unsigned long) &kdis
);
2944 struct i2c_rdwr_ioctl_data32
{
2945 compat_caddr_t msgs
; /* struct i2c_msg __user *msgs */
2949 struct i2c_smbus_ioctl_data32
{
2953 compat_caddr_t data
; /* union i2c_smbus_data *data */
2956 static int do_i2c_rdwr_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
2958 struct i2c_rdwr_ioctl_data
*tdata
;
2959 struct i2c_rdwr_ioctl_data32
*udata
;
2960 struct i2c_msg
*tmsgs
;
2961 struct i2c_msg32
*umsgs
;
2962 compat_caddr_t datap
;
2965 tdata
= compat_alloc_user_space(sizeof(*tdata
));
2968 if (verify_area(VERIFY_WRITE
, tdata
, sizeof(*tdata
)))
2971 udata
= (struct i2c_rdwr_ioctl_data32
*)compat_ptr(arg
);
2972 if (verify_area(VERIFY_READ
, udata
, sizeof(*udata
)))
2974 if (__get_user(nmsgs
, &udata
->nmsgs
) || __put_user(nmsgs
, &tdata
->nmsgs
))
2976 if (nmsgs
> I2C_RDRW_IOCTL_MAX_MSGS
)
2978 if (__get_user(datap
, &udata
->msgs
))
2980 umsgs
= (struct i2c_msg32
*)compat_ptr(datap
);
2981 if (verify_area(VERIFY_READ
, umsgs
, sizeof(struct i2c_msg
) * nmsgs
))
2984 tmsgs
= compat_alloc_user_space(sizeof(struct i2c_msg
) * nmsgs
);
2987 if (verify_area(VERIFY_WRITE
, tmsgs
, sizeof(struct i2c_msg
) * nmsgs
))
2989 if (__put_user(tmsgs
, &tdata
->msgs
))
2991 for (i
= 0; i
< nmsgs
; i
++) {
2992 if (__copy_in_user(&tmsgs
[i
].addr
,
2996 if (__get_user(datap
, &umsgs
[i
].buf
) ||
2997 __put_user(compat_ptr(datap
), &tmsgs
[i
].buf
))
3000 return sys_ioctl(fd
, cmd
, (unsigned long)tdata
);
3003 static int do_i2c_smbus_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
3005 struct i2c_smbus_ioctl_data
*tdata
;
3006 struct i2c_smbus_ioctl_data32
*udata
;
3007 compat_caddr_t datap
;
3009 tdata
= compat_alloc_user_space(sizeof(*tdata
));
3012 if (verify_area(VERIFY_WRITE
, tdata
, sizeof(*tdata
)))
3015 udata
= (struct i2c_smbus_ioctl_data32
*)compat_ptr(arg
);
3016 if (verify_area(VERIFY_READ
, udata
, sizeof(*udata
)))
3019 if (__copy_in_user(&tdata
->read_write
, &udata
->read_write
, 2 * sizeof(u8
)))
3021 if (__copy_in_user(&tdata
->size
, &udata
->size
, 2 * sizeof(u32
)))
3023 if (__get_user(datap
, &udata
->data
) ||
3024 __put_user(compat_ptr(datap
), &tdata
->data
))
3027 return sys_ioctl(fd
, cmd
, (unsigned long)tdata
);
3030 struct compat_iw_point
{
3031 compat_caddr_t pointer
;
3036 static int do_wireless_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
3038 struct iwreq
*iwr
, *iwr_u
;
3039 struct iw_point
*iwp
;
3040 struct compat_iw_point
*iwp_u
;
3041 compat_caddr_t pointer
;
3042 __u16 length
, flags
;
3044 iwr_u
= (struct iwreq
*) compat_ptr(arg
);
3045 iwp_u
= (struct compat_iw_point
*) &iwr_u
->u
.data
;
3046 iwr
= compat_alloc_user_space(sizeof(*iwr
));
3052 if (verify_area(VERIFY_WRITE
, iwr
, sizeof(*iwr
)))
3055 if (__copy_in_user(&iwr
->ifr_ifrn
.ifrn_name
[0],
3056 &iwr_u
->ifr_ifrn
.ifrn_name
[0],
3057 sizeof(iwr
->ifr_ifrn
.ifrn_name
)))
3060 if (__get_user(pointer
, &iwp_u
->pointer
) ||
3061 __get_user(length
, &iwp_u
->length
) ||
3062 __get_user(flags
, &iwp_u
->flags
))
3065 if (__put_user(compat_ptr(pointer
), &iwp
->pointer
) ||
3066 __put_user(length
, &iwp
->length
) ||
3067 __put_user(flags
, &iwp
->flags
))
3070 return sys_ioctl(fd
, cmd
, (unsigned long) iwr
);
3073 /* Emulate old style bridge ioctls */
3074 static int do_bridge_ioctl(unsigned int fd
, unsigned int cmd
, unsigned long arg
)
3077 unsigned long *argbuf
= compat_alloc_user_space(3 * sizeof(unsigned long));
3079 for (i
= 0; i
< 3; i
++) {
3080 if (get_user(tmp
, i
+ ((u32
*)arg
)) ||
3081 put_user(tmp
, i
+ argbuf
))
3084 return sys_ioctl(fd
, cmd
, (unsigned long)argbuf
);
3091 HANDLE_IOCTL(MEMREADOOB32
, mtd_rw_oob
)
3092 HANDLE_IOCTL(MEMWRITEOOB32
, mtd_rw_oob
)
3094 HANDLE_IOCTL(SIOCGIFNAME
, dev_ifname32
)
3096 HANDLE_IOCTL(SIOCGIFCONF
, dev_ifconf
)
3097 HANDLE_IOCTL(SIOCGIFFLAGS
, dev_ifsioc
)
3098 HANDLE_IOCTL(SIOCSIFFLAGS
, dev_ifsioc
)
3099 HANDLE_IOCTL(SIOCGIFMETRIC
, dev_ifsioc
)
3100 HANDLE_IOCTL(SIOCSIFMETRIC
, dev_ifsioc
)
3101 HANDLE_IOCTL(SIOCGIFMTU
, dev_ifsioc
)
3102 HANDLE_IOCTL(SIOCSIFMTU
, dev_ifsioc
)
3103 HANDLE_IOCTL(SIOCGIFMEM
, dev_ifsioc
)
3104 HANDLE_IOCTL(SIOCSIFMEM
, dev_ifsioc
)
3105 HANDLE_IOCTL(SIOCGIFHWADDR
, dev_ifsioc
)
3106 HANDLE_IOCTL(SIOCSIFHWADDR
, dev_ifsioc
)
3107 HANDLE_IOCTL(SIOCADDMULTI
, dev_ifsioc
)
3108 HANDLE_IOCTL(SIOCDELMULTI
, dev_ifsioc
)
3109 HANDLE_IOCTL(SIOCGIFINDEX
, dev_ifsioc
)
3110 HANDLE_IOCTL(SIOCGIFMAP
, dev_ifsioc
)
3111 HANDLE_IOCTL(SIOCSIFMAP
, dev_ifsioc
)
3112 HANDLE_IOCTL(SIOCGIFADDR
, dev_ifsioc
)
3113 HANDLE_IOCTL(SIOCSIFADDR
, dev_ifsioc
)
3114 HANDLE_IOCTL(SIOCGIFBRDADDR
, dev_ifsioc
)
3115 HANDLE_IOCTL(SIOCSIFBRDADDR
, dev_ifsioc
)
3116 HANDLE_IOCTL(SIOCGIFDSTADDR
, dev_ifsioc
)
3117 HANDLE_IOCTL(SIOCSIFDSTADDR
, dev_ifsioc
)
3118 HANDLE_IOCTL(SIOCGIFNETMASK
, dev_ifsioc
)
3119 HANDLE_IOCTL(SIOCSIFNETMASK
, dev_ifsioc
)
3120 HANDLE_IOCTL(SIOCSIFPFLAGS
, dev_ifsioc
)
3121 HANDLE_IOCTL(SIOCGIFPFLAGS
, dev_ifsioc
)
3122 HANDLE_IOCTL(SIOCGIFTXQLEN
, dev_ifsioc
)
3123 HANDLE_IOCTL(SIOCSIFTXQLEN
, dev_ifsioc
)
3124 HANDLE_IOCTL(TUNSETIFF
, dev_ifsioc
)
3125 HANDLE_IOCTL(SIOCETHTOOL
, ethtool_ioctl
)
3126 HANDLE_IOCTL(SIOCBONDENSLAVE
, bond_ioctl
)
3127 HANDLE_IOCTL(SIOCBONDRELEASE
, bond_ioctl
)
3128 HANDLE_IOCTL(SIOCBONDSETHWADDR
, bond_ioctl
)
3129 HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY
, bond_ioctl
)
3130 HANDLE_IOCTL(SIOCBONDINFOQUERY
, bond_ioctl
)
3131 HANDLE_IOCTL(SIOCBONDCHANGEACTIVE
, bond_ioctl
)
3132 HANDLE_IOCTL(SIOCADDRT
, routing_ioctl
)
3133 HANDLE_IOCTL(SIOCDELRT
, routing_ioctl
)
3134 /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
3135 HANDLE_IOCTL(SIOCRTMSG
, ret_einval
)
3136 HANDLE_IOCTL(SIOCGSTAMP
, do_siocgstamp
)
3137 HANDLE_IOCTL(HDIO_GETGEO
, hdio_getgeo
)
3138 HANDLE_IOCTL(BLKRAGET
, w_long
)
3139 HANDLE_IOCTL(BLKGETSIZE
, w_long
)
3140 HANDLE_IOCTL(0x1260, broken_blkgetsize
)
3141 HANDLE_IOCTL(BLKFRAGET
, w_long
)
3142 HANDLE_IOCTL(BLKSECTGET
, w_long
)
3143 HANDLE_IOCTL(FBIOGET_FSCREENINFO
, fb_ioctl_trans
)
3144 HANDLE_IOCTL(BLKPG
, blkpg_ioctl_trans
)
3145 HANDLE_IOCTL(FBIOGETCMAP
, fb_ioctl_trans
)
3146 HANDLE_IOCTL(FBIOPUTCMAP
, fb_ioctl_trans
)
3147 HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS
, hdio_ioctl_trans
)
3148 HANDLE_IOCTL(HDIO_GET_UNMASKINTR
, hdio_ioctl_trans
)
3149 HANDLE_IOCTL(HDIO_GET_DMA
, hdio_ioctl_trans
)
3150 HANDLE_IOCTL(HDIO_GET_32BIT
, hdio_ioctl_trans
)
3151 HANDLE_IOCTL(HDIO_GET_MULTCOUNT
, hdio_ioctl_trans
)
3152 HANDLE_IOCTL(HDIO_GET_NOWERR
, hdio_ioctl_trans
)
3153 HANDLE_IOCTL(HDIO_GET_NICE
, hdio_ioctl_trans
)
3154 HANDLE_IOCTL(FDSETPRM32
, fd_ioctl_trans
)
3155 HANDLE_IOCTL(FDDEFPRM32
, fd_ioctl_trans
)
3156 HANDLE_IOCTL(FDGETPRM32
, fd_ioctl_trans
)
3157 HANDLE_IOCTL(FDSETDRVPRM32
, fd_ioctl_trans
)
3158 HANDLE_IOCTL(FDGETDRVPRM32
, fd_ioctl_trans
)
3159 HANDLE_IOCTL(FDGETDRVSTAT32
, fd_ioctl_trans
)
3160 HANDLE_IOCTL(FDPOLLDRVSTAT32
, fd_ioctl_trans
)
3161 HANDLE_IOCTL(FDGETFDCSTAT32
, fd_ioctl_trans
)
3162 HANDLE_IOCTL(FDWERRORGET32
, fd_ioctl_trans
)
3163 HANDLE_IOCTL(SG_IO
,sg_ioctl_trans
)
3164 HANDLE_IOCTL(PPPIOCGIDLE32
, ppp_ioctl_trans
)
3165 HANDLE_IOCTL(PPPIOCSCOMPRESS32
, ppp_ioctl_trans
)
3166 HANDLE_IOCTL(PPPIOCSPASS32
, ppp_sock_fprog_ioctl_trans
)
3167 HANDLE_IOCTL(PPPIOCSACTIVE32
, ppp_sock_fprog_ioctl_trans
)
3168 HANDLE_IOCTL(MTIOCGET32
, mt_ioctl_trans
)
3169 HANDLE_IOCTL(MTIOCPOS32
, mt_ioctl_trans
)
3170 HANDLE_IOCTL(MTIOCGETCONFIG32
, mt_ioctl_trans
)
3171 HANDLE_IOCTL(MTIOCSETCONFIG32
, mt_ioctl_trans
)
3172 HANDLE_IOCTL(CDROMREADAUDIO
, cdrom_ioctl_trans
)
3173 HANDLE_IOCTL(CDROM_SEND_PACKET
, cdrom_ioctl_trans
)
3174 HANDLE_IOCTL(LOOP_SET_STATUS
, loop_status
)
3175 HANDLE_IOCTL(LOOP_GET_STATUS
, loop_status
)
3176 #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
3177 HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32
, ioc_settimeout
)
3179 HANDLE_IOCTL(PIO_FONTX
, do_fontx_ioctl
)
3180 HANDLE_IOCTL(GIO_FONTX
, do_fontx_ioctl
)
3181 HANDLE_IOCTL(PIO_UNIMAP
, do_unimap_ioctl
)
3182 HANDLE_IOCTL(GIO_UNIMAP
, do_unimap_ioctl
)
3183 HANDLE_IOCTL(KDFONTOP
, do_kdfontop_ioctl
)
3185 HANDLE_IOCTL(EXT2_IOC32_GETFLAGS
, do_ext2_ioctl
)
3186 HANDLE_IOCTL(EXT2_IOC32_SETFLAGS
, do_ext2_ioctl
)
3187 HANDLE_IOCTL(EXT2_IOC32_GETVERSION
, do_ext2_ioctl
)
3188 HANDLE_IOCTL(EXT2_IOC32_SETVERSION
, do_ext2_ioctl
)
3189 HANDLE_IOCTL(VIDIOCGTUNER32
, do_video_ioctl
)
3190 HANDLE_IOCTL(VIDIOCSTUNER32
, do_video_ioctl
)
3191 HANDLE_IOCTL(VIDIOCGWIN32
, do_video_ioctl
)
3192 HANDLE_IOCTL(VIDIOCSWIN32
, do_video_ioctl
)
3193 HANDLE_IOCTL(VIDIOCGFBUF32
, do_video_ioctl
)
3194 HANDLE_IOCTL(VIDIOCSFBUF32
, do_video_ioctl
)
3195 HANDLE_IOCTL(VIDIOCGFREQ32
, do_video_ioctl
)
3196 HANDLE_IOCTL(VIDIOCSFREQ32
, do_video_ioctl
)
3197 /* One SMB ioctl needs translations. */
3198 #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
3199 HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32
, do_smb_getmountuid
)
3200 HANDLE_IOCTL(ATM_GETLINKRATE32
, do_atm_ioctl
)
3201 HANDLE_IOCTL(ATM_GETNAMES32
, do_atm_ioctl
)
3202 HANDLE_IOCTL(ATM_GETTYPE32
, do_atm_ioctl
)
3203 HANDLE_IOCTL(ATM_GETESI32
, do_atm_ioctl
)
3204 HANDLE_IOCTL(ATM_GETADDR32
, do_atm_ioctl
)
3205 HANDLE_IOCTL(ATM_RSTADDR32
, do_atm_ioctl
)
3206 HANDLE_IOCTL(ATM_ADDADDR32
, do_atm_ioctl
)
3207 HANDLE_IOCTL(ATM_DELADDR32
, do_atm_ioctl
)
3208 HANDLE_IOCTL(ATM_GETCIRANGE32
, do_atm_ioctl
)
3209 HANDLE_IOCTL(ATM_SETCIRANGE32
, do_atm_ioctl
)
3210 HANDLE_IOCTL(ATM_SETESI32
, do_atm_ioctl
)
3211 HANDLE_IOCTL(ATM_SETESIF32
, do_atm_ioctl
)
3212 HANDLE_IOCTL(ATM_GETSTAT32
, do_atm_ioctl
)
3213 HANDLE_IOCTL(ATM_GETSTATZ32
, do_atm_ioctl
)
3214 HANDLE_IOCTL(ATM_GETLOOP32
, do_atm_ioctl
)
3215 HANDLE_IOCTL(ATM_SETLOOP32
, do_atm_ioctl
)
3216 HANDLE_IOCTL(ATM_QUERYLOOP32
, do_atm_ioctl
)
3217 HANDLE_IOCTL(SONET_GETSTAT
, do_atm_ioctl
)
3218 HANDLE_IOCTL(SONET_GETSTATZ
, do_atm_ioctl
)
3219 HANDLE_IOCTL(SONET_GETDIAG
, do_atm_ioctl
)
3220 HANDLE_IOCTL(SONET_SETDIAG
, do_atm_ioctl
)
3221 HANDLE_IOCTL(SONET_CLRDIAG
, do_atm_ioctl
)
3222 HANDLE_IOCTL(SONET_SETFRAMING
, do_atm_ioctl
)
3223 HANDLE_IOCTL(SONET_GETFRAMING
, do_atm_ioctl
)
3224 HANDLE_IOCTL(SONET_GETFRSENSE
, do_atm_ioctl
)
3226 HANDLE_IOCTL(BLKBSZGET_32
, do_blkbszget
)
3227 HANDLE_IOCTL(BLKBSZSET_32
, do_blkbszset
)
3228 HANDLE_IOCTL(BLKGETSIZE64_32
, do_blkgetsize64
)
3230 HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32
, vfat_ioctl32
)
3231 HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32
, vfat_ioctl32
)
3232 HANDLE_IOCTL(REISERFS_IOC_UNPACK32
, reiserfs_ioctl32
)
3234 HANDLE_IOCTL(RAW_SETBIND
, raw_ioctl
)
3235 HANDLE_IOCTL(RAW_GETBIND
, raw_ioctl
)
3237 HANDLE_IOCTL(TIOCGSERIAL
, serial_struct_ioctl
)
3238 HANDLE_IOCTL(TIOCSSERIAL
, serial_struct_ioctl
)
3240 HANDLE_IOCTL(USBDEVFS_CONTROL32
, do_usbdevfs_control
)
3241 HANDLE_IOCTL(USBDEVFS_BULK32
, do_usbdevfs_bulk
)
3242 /*HANDLE_IOCTL(USBDEVFS_SUBMITURB32, do_usbdevfs_urb)*/
3243 HANDLE_IOCTL(USBDEVFS_REAPURB32
, do_usbdevfs_reapurb
)
3244 HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32
, do_usbdevfs_reapurb
)
3245 HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32
, do_usbdevfs_discsignal
)
3247 HANDLE_IOCTL(I2C_FUNCS
, w_long
)
3248 HANDLE_IOCTL(I2C_RDWR
, do_i2c_rdwr_ioctl
)
3249 HANDLE_IOCTL(I2C_SMBUS
, do_i2c_smbus_ioctl
)
3251 HANDLE_IOCTL(SIOCGIWRANGE
, do_wireless_ioctl
)
3252 HANDLE_IOCTL(SIOCSIWSPY
, do_wireless_ioctl
)
3253 HANDLE_IOCTL(SIOCGIWSPY
, do_wireless_ioctl
)
3254 HANDLE_IOCTL(SIOCSIWTHRSPY
, do_wireless_ioctl
)
3255 HANDLE_IOCTL(SIOCGIWTHRSPY
, do_wireless_ioctl
)
3256 HANDLE_IOCTL(SIOCGIWAPLIST
, do_wireless_ioctl
)
3257 HANDLE_IOCTL(SIOCGIWSCAN
, do_wireless_ioctl
)
3258 HANDLE_IOCTL(SIOCSIWESSID
, do_wireless_ioctl
)
3259 HANDLE_IOCTL(SIOCGIWESSID
, do_wireless_ioctl
)
3260 HANDLE_IOCTL(SIOCSIWNICKN
, do_wireless_ioctl
)
3261 HANDLE_IOCTL(SIOCGIWNICKN
, do_wireless_ioctl
)
3262 HANDLE_IOCTL(SIOCSIWENCODE
, do_wireless_ioctl
)
3263 HANDLE_IOCTL(SIOCGIWENCODE
, do_wireless_ioctl
)
3264 HANDLE_IOCTL(SIOCSIFBR
, do_bridge_ioctl
)
3265 HANDLE_IOCTL(SIOCGIFBR
, do_bridge_ioctl
)