1
2
3
4
5
6
7
8
9
10
11
12
13#ifdef INCLUDES
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>
22#include <linux/if.h>
23#include <linux/slab.h>
24#include <linux/hdreg.h>
25#include <linux/raid/md.h>
26#include <linux/kd.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>
33#include <linux/vt.h>
34#include <linux/fs.h>
35#include <linux/file.h>
36#include <linux/fd.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>
48#include <linux/fb.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/ncp_fs.h>
66#include <linux/i2c.h>
67#include <linux/i2c-dev.h>
68
69#include <net/sock.h>
70#include <net/bluetooth/bluetooth.h>
71#include <net/bluetooth/rfcomm.h>
72#include <net/bluetooth/hci.h>
73
74#include <scsi/scsi.h>
75
76#undef __KERNEL__
77#include <scsi/scsi_ioctl.h>
78#define __KERNEL__
79#include <scsi/sg.h>
80
81#include <asm/types.h>
82#include <asm/uaccess.h>
83#include <linux/ethtool.h>
84#include <linux/mii.h>
85#include <linux/if_bonding.h>
86#include <linux/watchdog.h>
87#include <linux/dm-ioctl.h>
88
89#include <asm/module.h>
90#include <linux/soundcard.h>
91#include <linux/lp.h>
92
93#include <linux/atm.h>
94#include <linux/atmarp.h>
95#include <linux/atmclip.h>
96#include <linux/atmdev.h>
97#include <linux/atmioc.h>
98#include <linux/atmlec.h>
99#include <linux/atmmpc.h>
100#include <linux/atmsvc.h>
101#include <linux/atm_tcp.h>
102#include <linux/sonet.h>
103#include <linux/atm_suni.h>
104#include <linux/mtd/mtd.h>
105
106#include <linux/usb.h>
107#include <linux/usbdevice_fs.h>
108#include <linux/nbd.h>
109#include <linux/random.h>
110#include <linux/filter.h>
111#include <linux/msdos_fs.h>
112
113#undef INCLUDES
114#endif
115
116#ifdef CODE
117
118
119#define EXT2_IOC32_GETFLAGS _IOR('f', 1, int)
120#define EXT2_IOC32_SETFLAGS _IOW('f', 2, int)
121#define EXT2_IOC32_GETVERSION _IOR('v', 1, int)
122#define EXT2_IOC32_SETVERSION _IOW('v', 2, int)
123
124static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
125{
126 mm_segment_t old_fs = get_fs();
127 int err;
128 unsigned long val;
129
130 set_fs (KERNEL_DS);
131 err = sys_ioctl(fd, cmd, (unsigned long)&val);
132 set_fs (old_fs);
133 if (!err && put_user(val, (u32 *)compat_ptr(arg)))
134 return -EFAULT;
135 return err;
136}
137
138static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
139{
140 mm_segment_t old_fs = get_fs();
141 u32 *argptr = compat_ptr(arg);
142 int err;
143 unsigned long val;
144
145 if(get_user(val, argptr))
146 return -EFAULT;
147 set_fs (KERNEL_DS);
148 err = sys_ioctl(fd, cmd, (unsigned long)&val);
149 set_fs (old_fs);
150 if (!err && put_user(val, argptr))
151 return -EFAULT;
152 return err;
153}
154
155static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
156{
157
158 switch (cmd) {
159 case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
160 case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
161 case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
162 case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
163 }
164 return sys_ioctl(fd, cmd, arg);
165}
166
167struct video_tuner32 {
168 compat_int_t tuner;
169 char name[32];
170 compat_ulong_t rangelow, rangehigh;
171 u32 flags;
172 u16 mode, signal;
173};
174
175static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
176{
177 int i;
178
179 if(get_user(kp->tuner, &up->tuner))
180 return -EFAULT;
181 for(i = 0; i < 32; i++)
182 __get_user(kp->name[i], &up->name[i]);
183 __get_user(kp->rangelow, &up->rangelow);
184 __get_user(kp->rangehigh, &up->rangehigh);
185 __get_user(kp->flags, &up->flags);
186 __get_user(kp->mode, &up->mode);
187 __get_user(kp->signal, &up->signal);
188 return 0;
189}
190
191static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
192{
193 int i;
194
195 if(put_user(kp->tuner, &up->tuner))
196 return -EFAULT;
197 for(i = 0; i < 32; i++)
198 __put_user(kp->name[i], &up->name[i]);
199 __put_user(kp->rangelow, &up->rangelow);
200 __put_user(kp->rangehigh, &up->rangehigh);
201 __put_user(kp->flags, &up->flags);
202 __put_user(kp->mode, &up->mode);
203 __put_user(kp->signal, &up->signal);
204 return 0;
205}
206
207struct video_buffer32 {
208 compat_caddr_t base;
209 compat_int_t height, width, depth, bytesperline;
210};
211
212static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
213{
214 u32 tmp;
215
216 if(get_user(tmp, &up->base))
217 return -EFAULT;
218 kp->base = (void *) ((unsigned long)tmp);
219 __get_user(kp->height, &up->height);
220 __get_user(kp->width, &up->width);
221 __get_user(kp->depth, &up->depth);
222 __get_user(kp->bytesperline, &up->bytesperline);
223 return 0;
224}
225
226static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
227{
228 u32 tmp = (u32)((unsigned long)kp->base);
229
230 if(put_user(tmp, &up->base))
231 return -EFAULT;
232 __put_user(kp->height, &up->height);
233 __put_user(kp->width, &up->width);
234 __put_user(kp->depth, &up->depth);
235 __put_user(kp->bytesperline, &up->bytesperline);
236 return 0;
237}
238
239struct video_clip32 {
240 s32 x, y, width, height;
241 compat_caddr_t next;
242};
243
244struct video_window32 {
245 u32 x, y, width, height, chromakey, flags;
246 compat_caddr_t clips;
247 compat_int_t clipcount;
248};
249
250static void free_kvideo_clips(struct video_window *kp)
251{
252 struct video_clip *cp;
253
254 cp = kp->clips;
255 if(cp != NULL)
256 kfree(cp);
257}
258
259static int get_video_window32(struct video_window *kp, struct video_window32 *up)
260{
261 struct video_clip32 *ucp;
262 struct video_clip *kcp;
263 int nclips, err, i;
264 u32 tmp;
265
266 if(get_user(kp->x, &up->x))
267 return -EFAULT;
268 __get_user(kp->y, &up->y);
269 __get_user(kp->width, &up->width);
270 __get_user(kp->height, &up->height);
271 __get_user(kp->chromakey, &up->chromakey);
272 __get_user(kp->flags, &up->flags);
273 __get_user(kp->clipcount, &up->clipcount);
274 __get_user(tmp, &up->clips);
275 ucp = compat_ptr(tmp);
276 kp->clips = NULL;
277
278 nclips = kp->clipcount;
279 if(nclips == 0)
280 return 0;
281
282 if(ucp == 0)
283 return -EINVAL;
284
285
286 if(nclips < 0)
287 nclips = VIDEO_CLIPMAP_SIZE;
288
289 kcp = kmalloc(nclips * sizeof(struct video_clip), GFP_KERNEL);
290 err = -ENOMEM;
291 if(kcp == NULL)
292 goto cleanup_and_err;
293
294 kp->clips = kcp;
295 for(i = 0; i < nclips; i++) {
296 __get_user(kcp[i].x, &ucp[i].x);
297 __get_user(kcp[i].y, &ucp[i].y);
298 __get_user(kcp[i].width, &ucp[i].width);
299 __get_user(kcp[i].height, &ucp[i].height);
300 kcp[nclips].next = NULL;
301 }
302
303 return 0;
304
305cleanup_and_err:
306 free_kvideo_clips(kp);
307 return err;
308}
309
310
311static int put_video_window32(struct video_window *kp, struct video_window32 *up)
312{
313 if(put_user(kp->x, &up->x))
314 return -EFAULT;
315 __put_user(kp->y, &up->y);
316 __put_user(kp->width, &up->width);
317 __put_user(kp->height, &up->height);
318 __put_user(kp->chromakey, &up->chromakey);
319 __put_user(kp->flags, &up->flags);
320 __put_user(kp->clipcount, &up->clipcount);
321 return 0;
322}
323
324#define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
325#define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
326#define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
327#define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
328#define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
329#define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
330#define VIDIOCGFREQ32 _IOR('v',14, u32)
331#define VIDIOCSFREQ32 _IOW('v',15, u32)
332
333static int do_video_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
334{
335 union {
336 struct video_tuner vt;
337 struct video_buffer vb;
338 struct video_window vw;
339 unsigned long vx;
340 } karg;
341 mm_segment_t old_fs = get_fs();
342 void *up = (void *)arg;
343 int err = 0;
344
345
346 switch(cmd) {
347 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
348 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
349 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
350 case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
351 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
352 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
353 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
354 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
355 };
356
357 switch(cmd) {
358 case VIDIOCSTUNER:
359 case VIDIOCGTUNER:
360 err = get_video_tuner32(&karg.vt, up);
361 break;
362
363 case VIDIOCSWIN:
364 err = get_video_window32(&karg.vw, up);
365 break;
366
367 case VIDIOCSFBUF:
368 err = get_video_buffer32(&karg.vb, up);
369 break;
370
371 case VIDIOCSFREQ:
372 err = get_user(karg.vx, (u32 *)up);
373 break;
374 };
375 if(err)
376 goto out;
377
378 set_fs(KERNEL_DS);
379 err = sys_ioctl(fd, cmd, (unsigned long)&karg);
380 set_fs(old_fs);
381
382 if(cmd == VIDIOCSWIN)
383 free_kvideo_clips(&karg.vw);
384
385 if(err == 0) {
386 switch(cmd) {
387 case VIDIOCGTUNER:
388 err = put_video_tuner32(&karg.vt, up);
389 break;
390
391 case VIDIOCGWIN:
392 err = put_video_window32(&karg.vw, up);
393 break;
394
395 case VIDIOCGFBUF:
396 err = put_video_buffer32(&karg.vb, up);
397 break;
398
399 case VIDIOCGFREQ:
400 err = put_user(((u32)karg.vx), (u32 *)up);
401 break;
402 };
403 }
404out:
405 return err;
406}
407
408static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
409{
410 struct compat_timeval *up = (struct compat_timeval *)arg;
411 struct timeval ktv;
412 mm_segment_t old_fs = get_fs();
413 int err;
414
415 set_fs(KERNEL_DS);
416 err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
417 set_fs(old_fs);
418 if(!err) {
419 err = put_user(ktv.tv_sec, &up->tv_sec);
420 err |= __put_user(ktv.tv_usec, &up->tv_usec);
421 }
422 return err;
423}
424
425struct ifmap32 {
426 compat_ulong_t mem_start;
427 compat_ulong_t mem_end;
428 unsigned short base_addr;
429 unsigned char irq;
430 unsigned char dma;
431 unsigned char port;
432};
433
434struct ifreq32 {
435#define IFHWADDRLEN 6
436#define IFNAMSIZ 16
437 union {
438 char ifrn_name[IFNAMSIZ];
439 } ifr_ifrn;
440 union {
441 struct sockaddr ifru_addr;
442 struct sockaddr ifru_dstaddr;
443 struct sockaddr ifru_broadaddr;
444 struct sockaddr ifru_netmask;
445 struct sockaddr ifru_hwaddr;
446 short ifru_flags;
447 compat_int_t ifru_ivalue;
448 compat_int_t ifru_mtu;
449 struct ifmap32 ifru_map;
450 char ifru_slave[IFNAMSIZ];
451 char ifru_newname[IFNAMSIZ];
452 compat_caddr_t ifru_data;
453
454 } ifr_ifru;
455};
456
457struct ifconf32 {
458 compat_int_t ifc_len;
459 compat_caddr_t ifcbuf;
460};
461
462#ifdef CONFIG_NET
463static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
464{
465 struct net_device *dev;
466 struct ifreq32 ifr32;
467 int err;
468
469 if (copy_from_user(&ifr32, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
470 return -EFAULT;
471
472 dev = dev_get_by_index(ifr32.ifr_ifindex);
473 if (!dev)
474 return -ENODEV;
475
476 strlcpy(ifr32.ifr_name, dev->name, sizeof(ifr32.ifr_name));
477 dev_put(dev);
478
479 err = copy_to_user((struct ifreq32 *)arg, &ifr32, sizeof(struct ifreq32));
480 return (err ? -EFAULT : 0);
481}
482#endif
483
484static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
485{
486 struct ifconf32 ifc32;
487 struct ifconf ifc;
488 struct ifreq32 *ifr32;
489 struct ifreq *ifr;
490 mm_segment_t old_fs;
491 unsigned int i, j;
492 int err;
493
494 if (copy_from_user(&ifc32, (struct ifconf32 *)arg, sizeof(struct ifconf32)))
495 return -EFAULT;
496
497 if(ifc32.ifcbuf == 0) {
498 ifc32.ifc_len = 0;
499 ifc.ifc_len = 0;
500 ifc.ifc_buf = NULL;
501 } else {
502 ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) *
503 sizeof (struct ifreq);
504 ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
505 if (!ifc.ifc_buf)
506 return -ENOMEM;
507 }
508 ifr = ifc.ifc_req;
509 ifr32 = compat_ptr(ifc32.ifcbuf);
510 for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
511 if (copy_from_user(ifr, ifr32, sizeof (struct ifreq32))) {
512 kfree (ifc.ifc_buf);
513 return -EFAULT;
514 }
515 ifr++;
516 ifr32++;
517 }
518 old_fs = get_fs(); set_fs (KERNEL_DS);
519 err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
520 set_fs (old_fs);
521 if (!err) {
522 ifr = ifc.ifc_req;
523 ifr32 = compat_ptr(ifc32.ifcbuf);
524 for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
525 i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
526 int k = copy_to_user(ifr32, ifr, sizeof (struct ifreq32));
527 ifr32++;
528 ifr++;
529 if (k) {
530 err = -EFAULT;
531 break;
532 }
533
534 }
535 if (!err) {
536 if (ifc32.ifcbuf == 0) {
537
538
539
540 i = ifc.ifc_len;
541 i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
542 ifc32.ifc_len = i;
543 } else {
544 if (i <= ifc32.ifc_len)
545 ifc32.ifc_len = i;
546 else
547 ifc32.ifc_len = i - sizeof (struct ifreq32);
548 }
549 if (copy_to_user((struct ifconf32 *)arg, &ifc32, sizeof(struct ifconf32)))
550 err = -EFAULT;
551 }
552 }
553 if(ifc.ifc_buf != NULL)
554 kfree (ifc.ifc_buf);
555 return err;
556}
557
558static int ethtool_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
559{
560 struct ifreq *ifr;
561 struct ifreq32 *ifr32;
562 u32 data;
563 void *datap;
564
565 ifr = compat_alloc_user_space(sizeof(*ifr));
566 ifr32 = (struct ifreq32 *) arg;
567
568 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
569 return -EFAULT;
570
571 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
572 return -EFAULT;
573
574 datap = (void *) (unsigned long) data;
575 if (put_user(datap, &ifr->ifr_ifru.ifru_data))
576 return -EFAULT;
577
578 return sys_ioctl(fd, cmd, (unsigned long) ifr);
579}
580
581static int bond_ioctl(unsigned long fd, unsigned int cmd, unsigned long arg)
582{
583 struct ifreq kifr;
584 struct ifreq *uifr;
585 struct ifreq32 *ifr32 = (struct ifreq32 *) arg;
586 mm_segment_t old_fs;
587 int err;
588 u32 data;
589 void *datap;
590
591 switch (cmd) {
592 case SIOCBONDENSLAVE:
593 case SIOCBONDRELEASE:
594 case SIOCBONDSETHWADDR:
595 case SIOCBONDCHANGEACTIVE:
596 if (copy_from_user(&kifr, ifr32, sizeof(struct ifreq32)))
597 return -EFAULT;
598
599 old_fs = get_fs();
600 set_fs (KERNEL_DS);
601 err = sys_ioctl (fd, cmd, (unsigned long)&kifr);
602 set_fs (old_fs);
603
604 return err;
605 case SIOCBONDSLAVEINFOQUERY:
606 case SIOCBONDINFOQUERY:
607 uifr = compat_alloc_user_space(sizeof(*uifr));
608 if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
609 return -EFAULT;
610
611 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
612 return -EFAULT;
613
614 datap = compat_ptr(data);
615 if (put_user(datap, &uifr->ifr_ifru.ifru_data))
616 return -EFAULT;
617
618 return sys_ioctl (fd, cmd, (unsigned long)uifr);
619 default:
620 return -EINVAL;
621 };
622}
623
624int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
625{
626 struct ifreq *u_ifreq64;
627 struct ifreq32 *u_ifreq32 = (struct ifreq32 *) arg;
628 char tmp_buf[IFNAMSIZ];
629 void *data64;
630 u32 data32;
631
632 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
633 IFNAMSIZ))
634 return -EFAULT;
635 if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
636 return -EFAULT;
637 data64 = compat_ptr(data32);
638
639 u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
640
641
642
643
644 copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], IFNAMSIZ);
645 __put_user(data64, &u_ifreq64->ifr_ifru.ifru_data);
646
647 return sys_ioctl(fd, cmd, (unsigned long) u_ifreq64);
648}
649
650static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
651{
652 struct ifreq ifr;
653 mm_segment_t old_fs;
654 int err;
655
656 switch (cmd) {
657 case SIOCSIFMAP:
658 err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
659 err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
660 err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
661 err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
662 err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
663 err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
664 err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
665 if (err)
666 return -EFAULT;
667 break;
668 default:
669 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
670 return -EFAULT;
671 break;
672 }
673 old_fs = get_fs();
674 set_fs (KERNEL_DS);
675 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
676 set_fs (old_fs);
677 if (!err) {
678 switch (cmd) {
679 case SIOCGIFFLAGS:
680 case SIOCGIFMETRIC:
681 case SIOCGIFMTU:
682 case SIOCGIFMEM:
683 case SIOCGIFHWADDR:
684 case SIOCGIFINDEX:
685 case SIOCGIFADDR:
686 case SIOCGIFBRDADDR:
687 case SIOCGIFDSTADDR:
688 case SIOCGIFNETMASK:
689 case SIOCGIFTXQLEN:
690 if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
691 return -EFAULT;
692 break;
693 case SIOCGIFMAP:
694 err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
695 err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
696 err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
697 err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
698 err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
699 err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
700 err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
701 if (err)
702 err = -EFAULT;
703 break;
704 }
705 }
706 return err;
707}
708
709struct rtentry32 {
710 u32 rt_pad1;
711 struct sockaddr rt_dst;
712 struct sockaddr rt_gateway;
713 struct sockaddr rt_genmask;
714 unsigned short rt_flags;
715 short rt_pad2;
716 u32 rt_pad3;
717 unsigned char rt_tos;
718 unsigned char rt_class;
719 short rt_pad4;
720 short rt_metric;
721 u32 rt_dev;
722 u32 rt_mtu;
723 u32 rt_window;
724 unsigned short rt_irtt;
725
726};
727
728struct in6_rtmsg32 {
729 struct in6_addr rtmsg_dst;
730 struct in6_addr rtmsg_src;
731 struct in6_addr rtmsg_gateway;
732 u32 rtmsg_type;
733 u16 rtmsg_dst_len;
734 u16 rtmsg_src_len;
735 u32 rtmsg_metric;
736 u32 rtmsg_info;
737 u32 rtmsg_flags;
738 s32 rtmsg_ifindex;
739};
740
741static int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
742{
743 int ret;
744 void *r = NULL;
745 struct in6_rtmsg r6;
746 struct rtentry r4;
747 char devname[16];
748 u32 rtdev;
749 mm_segment_t old_fs = get_fs();
750
751 struct socket *mysock = sockfd_lookup(fd, &ret);
752
753 if (mysock && mysock->sk && mysock->sk->sk_family == AF_INET6) {
754 ret = copy_from_user (&r6.rtmsg_dst, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst),
755 3 * sizeof(struct in6_addr));
756 ret |= __get_user (r6.rtmsg_type, &(((struct in6_rtmsg32 *)arg)->rtmsg_type));
757 ret |= __get_user (r6.rtmsg_dst_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst_len));
758 ret |= __get_user (r6.rtmsg_src_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_src_len));
759 ret |= __get_user (r6.rtmsg_metric, &(((struct in6_rtmsg32 *)arg)->rtmsg_metric));
760 ret |= __get_user (r6.rtmsg_info, &(((struct in6_rtmsg32 *)arg)->rtmsg_info));
761 ret |= __get_user (r6.rtmsg_flags, &(((struct in6_rtmsg32 *)arg)->rtmsg_flags));
762 ret |= __get_user (r6.rtmsg_ifindex, &(((struct in6_rtmsg32 *)arg)->rtmsg_ifindex));
763
764 r = (void *) &r6;
765 } else {
766 ret = copy_from_user (&r4.rt_dst, &(((struct rtentry32 *)arg)->rt_dst), 3 * sizeof(struct sockaddr));
767 ret |= __get_user (r4.rt_flags, &(((struct rtentry32 *)arg)->rt_flags));
768 ret |= __get_user (r4.rt_metric, &(((struct rtentry32 *)arg)->rt_metric));
769 ret |= __get_user (r4.rt_mtu, &(((struct rtentry32 *)arg)->rt_mtu));
770 ret |= __get_user (r4.rt_window, &(((struct rtentry32 *)arg)->rt_window));
771 ret |= __get_user (r4.rt_irtt, &(((struct rtentry32 *)arg)->rt_irtt));
772 ret |= __get_user (rtdev, &(((struct rtentry32 *)arg)->rt_dev));
773 if (rtdev) {
774 ret |= copy_from_user (devname, compat_ptr(rtdev), 15);
775 r4.rt_dev = devname; devname[15] = 0;
776 } else
777 r4.rt_dev = 0;
778
779 r = (void *) &r4;
780 }
781
782 if (ret)
783 return -EFAULT;
784
785 set_fs (KERNEL_DS);
786 ret = sys_ioctl (fd, cmd, (long) r);
787 set_fs (old_fs);
788
789 if (mysock)
790 sockfd_put(mysock);
791
792 return ret;
793}
794
795struct hd_geometry32 {
796 unsigned char heads;
797 unsigned char sectors;
798 unsigned short cylinders;
799 u32 start;
800};
801
802static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
803{
804 mm_segment_t old_fs = get_fs();
805 struct hd_geometry geo;
806 int err;
807
808 set_fs (KERNEL_DS);
809 err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
810 set_fs (old_fs);
811 if (!err) {
812 err = copy_to_user ((struct hd_geometry32 *)arg, &geo, 4);
813 err |= __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start));
814 }
815 return err ? -EFAULT : 0;
816}
817
818struct fb_fix_screeninfo32 {
819 char id[16];
820 compat_caddr_t smem_start;
821 u32 smem_len;
822 u32 type;
823 u32 type_aux;
824 u32 visual;
825 u16 xpanstep;
826 u16 ypanstep;
827 u16 ywrapstep;
828 u32 line_length;
829 compat_caddr_t mmio_start;
830 u32 mmio_len;
831 u32 accel;
832 u16 reserved[3];
833};
834
835struct fb_cmap32 {
836 u32 start;
837 u32 len;
838 compat_caddr_t red;
839 compat_caddr_t green;
840 compat_caddr_t blue;
841 compat_caddr_t transp;
842};
843
844static int do_cmap_ptr(__u16 **ptr64, __u32 *ptr32)
845{
846 __u32 data;
847 void *datap;
848
849 if (get_user(data, ptr32))
850 return -EFAULT;
851 datap = (void *) (unsigned long) data;
852 if (put_user(datap, ptr64))
853 return -EFAULT;
854 return 0;
855}
856
857static int fb_getput_cmap(unsigned int fd, unsigned int cmd, unsigned long arg)
858{
859 struct fb_cmap *cmap;
860 struct fb_cmap32 *cmap32;
861 int err;
862
863 cmap = compat_alloc_user_space(sizeof(*cmap));
864 cmap32 = (struct fb_cmap32 *) arg;
865
866 if (copy_in_user(&cmap->start, &cmap32->start, 2 * sizeof(__u32)))
867 return -EFAULT;
868
869 if (do_cmap_ptr(&cmap->red, &cmap32->red) ||
870 do_cmap_ptr(&cmap->green, &cmap32->green) ||
871 do_cmap_ptr(&cmap->blue, &cmap32->blue) ||
872 do_cmap_ptr(&cmap->transp, &cmap32->transp))
873 return -EFAULT;
874
875 err = sys_ioctl(fd, cmd, (unsigned long) cmap);
876
877 if (!err) {
878 if (copy_in_user(&cmap32->start,
879 &cmap->start,
880 2 * sizeof(__u32)))
881 err = -EFAULT;
882 }
883 return err;
884}
885
886static int do_fscreeninfo_to_user(struct fb_fix_screeninfo *fix,
887 struct fb_fix_screeninfo32 *fix32)
888{
889 __u32 data;
890 int err;
891
892 err = copy_to_user(&fix32->id, &fix->id, sizeof(fix32->id));
893
894 data = (__u32) (unsigned long) fix->smem_start;
895 err |= put_user(data, &fix32->smem_start);
896
897 err |= put_user(fix->smem_len, &fix32->smem_len);
898 err |= put_user(fix->type, &fix32->type);
899 err |= put_user(fix->type_aux, &fix32->type_aux);
900 err |= put_user(fix->visual, &fix32->visual);
901 err |= put_user(fix->xpanstep, &fix32->xpanstep);
902 err |= put_user(fix->ypanstep, &fix32->ypanstep);
903 err |= put_user(fix->ywrapstep, &fix32->ywrapstep);
904 err |= put_user(fix->line_length, &fix32->line_length);
905
906 data = (__u32) (unsigned long) fix->mmio_start;
907 err |= put_user(data, &fix32->mmio_start);
908
909 err |= put_user(fix->mmio_len, &fix32->mmio_len);
910 err |= put_user(fix->accel, &fix32->accel);
911 err |= copy_to_user(fix32->reserved, fix->reserved,
912 sizeof(fix->reserved));
913
914 return err;
915}
916
917static int fb_get_fscreeninfo(unsigned int fd, unsigned int cmd, unsigned long arg)
918{
919 mm_segment_t old_fs;
920 struct fb_fix_screeninfo fix;
921 struct fb_fix_screeninfo32 *fix32;
922 int err;
923
924 fix32 = (struct fb_fix_screeninfo32 *) arg;
925
926 old_fs = get_fs();
927 set_fs(KERNEL_DS);
928 err = sys_ioctl(fd, cmd, (unsigned long) &fix);
929 set_fs(old_fs);
930
931 if (!err)
932 err = do_fscreeninfo_to_user(&fix, fix32);
933
934 return err;
935}
936
937static int fb_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
938{
939 int err;
940
941 switch (cmd) {
942 case FBIOGET_FSCREENINFO:
943 err = fb_get_fscreeninfo(fd,cmd, arg);
944 break;
945
946 case FBIOGETCMAP:
947 case FBIOPUTCMAP:
948 err = fb_getput_cmap(fd, cmd, arg);
949 break;
950
951 default:
952 do {
953 static int count;
954 if (++count <= 20)
955 printk("%s: Unknown fb ioctl cmd fd(%d) "
956 "cmd(%08x) arg(%08lx)\n",
957 __FUNCTION__, fd, cmd, arg);
958 } while(0);
959 err = -ENOSYS;
960 break;
961 };
962
963 return err;
964}
965
966static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
967{
968 mm_segment_t old_fs = get_fs();
969 unsigned long kval;
970 unsigned int *uvp;
971 int error;
972
973 set_fs(KERNEL_DS);
974 error = sys_ioctl(fd, cmd, (long)&kval);
975 set_fs(old_fs);
976
977 if(error == 0) {
978 uvp = (unsigned int *)arg;
979 if(put_user(kval, uvp))
980 error = -EFAULT;
981 }
982 return error;
983}
984
985
986typedef struct sg_io_hdr32 {
987 compat_int_t interface_id;
988 compat_int_t dxfer_direction;
989 unsigned char cmd_len;
990 unsigned char mx_sb_len;
991 unsigned short iovec_count;
992 compat_uint_t dxfer_len;
993 compat_uint_t dxferp;
994
995 compat_uptr_t cmdp;
996 compat_uptr_t sbp;
997 compat_uint_t timeout;
998 compat_uint_t flags;
999 compat_int_t pack_id;
1000 compat_uptr_t usr_ptr;
1001 unsigned char status;
1002 unsigned char masked_status;
1003 unsigned char msg_status;
1004 unsigned char sb_len_wr;
1005 unsigned short host_status;
1006 unsigned short driver_status;
1007 compat_int_t resid;
1008 compat_uint_t duration;
1009 compat_uint_t info;
1010} sg_io_hdr32_t;
1011
1012typedef struct sg_iovec32 {
1013 compat_uint_t iov_base;
1014 compat_uint_t iov_len;
1015} sg_iovec32_t;
1016
1017static int sg_build_iovec(sg_io_hdr_t *sgio, void *dxferp, u16 iovec_count)
1018{
1019 sg_iovec_t *iov = (sg_iovec_t *) (sgio + 1);
1020 sg_iovec32_t *iov32 = dxferp;
1021 int i;
1022
1023 for (i = 0; i < iovec_count; i++) {
1024 u32 base, len;
1025
1026 if (get_user(base, &iov32[i].iov_base) ||
1027 get_user(len, &iov32[i].iov_len) ||
1028 put_user((void *)(unsigned long)base, &iov[i].iov_base) ||
1029 put_user(len, &iov[i].iov_len))
1030 return -EFAULT;
1031 }
1032
1033 sgio->dxferp = iov;
1034 return 0;
1035}
1036
1037static int sg_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1038{
1039 sg_io_hdr_t *sgio;
1040 sg_io_hdr32_t *sgio32;
1041 u16 iovec_count;
1042 u32 data;
1043 void *dxferp;
1044 int err;
1045
1046 sgio32 = (sg_io_hdr32_t *) arg;
1047 if (get_user(iovec_count, &sgio32->iovec_count))
1048 return -EFAULT;
1049
1050 {
1051 void *new, *top;
1052
1053 top = compat_alloc_user_space(0);
1054 new = compat_alloc_user_space(sizeof(sg_io_hdr_t) +
1055 (iovec_count *
1056 sizeof(sg_iovec_t)));
1057 if (new > top)
1058 return -EINVAL;
1059
1060 sgio = new;
1061 }
1062
1063
1064 if (copy_in_user(&sgio->interface_id, &sgio32->interface_id,
1065 (2 * sizeof(int)) +
1066 (2 * sizeof(unsigned char)) +
1067 (1 * sizeof(unsigned short)) +
1068 (1 * sizeof(unsigned int))))
1069 return -EFAULT;
1070
1071 if (get_user(data, &sgio32->dxferp))
1072 return -EFAULT;
1073 dxferp = (void *) (unsigned long) data;
1074 if (iovec_count) {
1075 if (sg_build_iovec(sgio, dxferp, iovec_count))
1076 return -EFAULT;
1077 } else {
1078 if (put_user(dxferp, &sgio->dxferp))
1079 return -EFAULT;
1080 }
1081
1082 {
1083 unsigned char *cmdp, *sbp;
1084
1085 if (get_user(data, &sgio32->cmdp))
1086 return -EFAULT;
1087 cmdp = (unsigned char *) (unsigned long) data;
1088
1089 if (get_user(data, &sgio32->sbp))
1090 return -EFAULT;
1091 sbp = (unsigned char *) (unsigned long) data;
1092
1093 if (put_user(cmdp, &sgio->cmdp) ||
1094 put_user(sbp, &sgio->sbp))
1095 return -EFAULT;
1096 }
1097
1098 if (copy_in_user(&sgio->timeout, &sgio32->timeout,
1099 3 * sizeof(int)))
1100 return -EFAULT;
1101
1102 if (get_user(data, &sgio32->usr_ptr))
1103 return -EFAULT;
1104 if (put_user((void *)(unsigned long)data, &sgio->usr_ptr))
1105 return -EFAULT;
1106
1107 if (copy_in_user(&sgio->status, &sgio32->status,
1108 (4 * sizeof(unsigned char)) +
1109 (2 * sizeof(unsigned (short))) +
1110 (3 * sizeof(int))))
1111 return -EFAULT;
1112
1113 err = sys_ioctl(fd, cmd, (unsigned long) sgio);
1114
1115 if (err >= 0) {
1116 void *datap;
1117
1118 if (copy_in_user(&sgio32->pack_id, &sgio->pack_id,
1119 sizeof(int)) ||
1120 get_user(datap, &sgio->usr_ptr) ||
1121 put_user((u32)(unsigned long)datap,
1122 &sgio32->usr_ptr) ||
1123 copy_in_user(&sgio32->status, &sgio->status,
1124 (4 * sizeof(unsigned char)) +
1125 (2 * sizeof(unsigned short)) +
1126 (3 * sizeof(int))))
1127 err = -EFAULT;
1128 }
1129
1130 return err;
1131}
1132
1133struct sock_fprog32 {
1134 unsigned short len;
1135 compat_caddr_t filter;
1136};
1137
1138#define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
1139#define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
1140
1141static int ppp_sock_fprog_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1142{
1143 struct sock_fprog32 *u_fprog32 = (struct sock_fprog32 *) arg;
1144 struct sock_fprog *u_fprog64 = compat_alloc_user_space(sizeof(struct sock_fprog));
1145 void *fptr64;
1146 u32 fptr32;
1147 u16 flen;
1148
1149 if (get_user(flen, &u_fprog32->len) ||
1150 get_user(fptr32, &u_fprog32->filter))
1151 return -EFAULT;
1152
1153 fptr64 = compat_ptr(fptr32);
1154
1155 if (put_user(flen, &u_fprog64->len) ||
1156 put_user(fptr64, &u_fprog64->filter))
1157 return -EFAULT;
1158
1159 if (cmd == PPPIOCSPASS32)
1160 cmd = PPPIOCSPASS;
1161 else
1162 cmd = PPPIOCSACTIVE;
1163
1164 return sys_ioctl(fd, cmd, (unsigned long) u_fprog64);
1165}
1166
1167struct ppp_option_data32 {
1168 compat_caddr_t ptr;
1169 u32 length;
1170 compat_int_t transmit;
1171};
1172#define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
1173
1174struct ppp_idle32 {
1175 compat_time_t xmit_idle;
1176 compat_time_t recv_idle;
1177};
1178#define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
1179
1180static int ppp_gidle(unsigned int fd, unsigned int cmd, unsigned long arg)
1181{
1182 struct ppp_idle *idle;
1183 struct ppp_idle32 *idle32;
1184 __kernel_time_t xmit, recv;
1185 int err;
1186
1187 idle = compat_alloc_user_space(sizeof(*idle));
1188 idle32 = (struct ppp_idle32 *) arg;
1189
1190 err = sys_ioctl(fd, PPPIOCGIDLE, (unsigned long) idle);
1191
1192 if (!err) {
1193 if (get_user(xmit, &idle->xmit_idle) ||
1194 get_user(recv, &idle->recv_idle) ||
1195 put_user(xmit, &idle32->xmit_idle) ||
1196 put_user(recv, &idle32->recv_idle))
1197 err = -EFAULT;
1198 }
1199 return err;
1200}
1201
1202static int ppp_scompress(unsigned int fd, unsigned int cmd, unsigned long arg)
1203{
1204 struct ppp_option_data *odata;
1205 struct ppp_option_data32 *odata32;
1206 __u32 data;
1207 void *datap;
1208
1209 odata = compat_alloc_user_space(sizeof(*odata));
1210 odata32 = (struct ppp_option_data32 *) arg;
1211
1212 if (get_user(data, &odata32->ptr))
1213 return -EFAULT;
1214
1215 datap = (void *) (unsigned long) data;
1216 if (put_user(datap, &odata->ptr))
1217 return -EFAULT;
1218
1219 if (copy_in_user(&odata->length, &odata32->length,
1220 sizeof(__u32) + sizeof(int)))
1221 return -EFAULT;
1222
1223 return sys_ioctl(fd, PPPIOCSCOMPRESS, (unsigned long) odata);
1224}
1225
1226static int ppp_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1227{
1228 int err;
1229
1230 switch (cmd) {
1231 case PPPIOCGIDLE32:
1232 err = ppp_gidle(fd, cmd, arg);
1233 break;
1234
1235 case PPPIOCSCOMPRESS32:
1236 err = ppp_scompress(fd, cmd, arg);
1237 break;
1238
1239 default:
1240 do {
1241 static int count;
1242 if (++count <= 20)
1243 printk("ppp_ioctl: Unknown cmd fd(%d) "
1244 "cmd(%08x) arg(%08x)\n",
1245 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1246 } while(0);
1247 err = -EINVAL;
1248 break;
1249 };
1250
1251 return err;
1252}
1253
1254
1255struct mtget32 {
1256 compat_long_t mt_type;
1257 compat_long_t mt_resid;
1258 compat_long_t mt_dsreg;
1259 compat_long_t mt_gstat;
1260 compat_long_t mt_erreg;
1261 compat_daddr_t mt_fileno;
1262 compat_daddr_t mt_blkno;
1263};
1264#define MTIOCGET32 _IOR('m', 2, struct mtget32)
1265
1266struct mtpos32 {
1267 compat_long_t mt_blkno;
1268};
1269#define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
1270
1271struct mtconfiginfo32 {
1272 compat_long_t mt_type;
1273 compat_long_t ifc_type;
1274 unsigned short irqnr;
1275 unsigned short dmanr;
1276 unsigned short port;
1277 compat_ulong_t debug;
1278 compat_uint_t have_dens:1;
1279 compat_uint_t have_bsf:1;
1280 compat_uint_t have_fsr:1;
1281 compat_uint_t have_bsr:1;
1282 compat_uint_t have_eod:1;
1283 compat_uint_t have_seek:1;
1284 compat_uint_t have_tell:1;
1285 compat_uint_t have_ras1:1;
1286 compat_uint_t have_ras2:1;
1287 compat_uint_t have_ras3:1;
1288 compat_uint_t have_qfa:1;
1289 compat_uint_t pad1:5;
1290 char reserved[10];
1291};
1292#define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
1293#define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
1294
1295static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1296{
1297 mm_segment_t old_fs = get_fs();
1298 struct mtconfiginfo info;
1299 struct mtget get;
1300 struct mtpos pos;
1301 unsigned long kcmd;
1302 void *karg;
1303 int err = 0;
1304
1305 switch(cmd) {
1306 case MTIOCPOS32:
1307 kcmd = MTIOCPOS;
1308 karg = &pos;
1309 break;
1310 case MTIOCGET32:
1311 kcmd = MTIOCGET;
1312 karg = &get;
1313 break;
1314 case MTIOCGETCONFIG32:
1315 kcmd = MTIOCGETCONFIG;
1316 karg = &info;
1317 break;
1318 case MTIOCSETCONFIG32:
1319 kcmd = MTIOCSETCONFIG;
1320 karg = &info;
1321 err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1322 err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1323 err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1324 err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1325 err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1326 err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1327 err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
1328 (char *)&((struct mtconfiginfo32 *)arg)->debug
1329 + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
1330 if (err)
1331 return -EFAULT;
1332 break;
1333 default:
1334 do {
1335 static int count;
1336 if (++count <= 20)
1337 printk("mt_ioctl: Unknown cmd fd(%d) "
1338 "cmd(%08x) arg(%08x)\n",
1339 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1340 } while(0);
1341 return -EINVAL;
1342 }
1343 set_fs (KERNEL_DS);
1344 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1345 set_fs (old_fs);
1346 if (err)
1347 return err;
1348 switch (cmd) {
1349 case MTIOCPOS32:
1350 err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
1351 break;
1352 case MTIOCGET32:
1353 err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
1354 err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
1355 err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
1356 err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
1357 err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
1358 err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
1359 err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
1360 break;
1361 case MTIOCGETCONFIG32:
1362 err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1363 err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1364 err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1365 err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1366 err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1367 err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1368 err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
1369 + sizeof(((struct mtconfiginfo32 *)arg)->debug),
1370 (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
1371 break;
1372 case MTIOCSETCONFIG32:
1373 break;
1374 }
1375 return err ? -EFAULT: 0;
1376}
1377
1378struct cdrom_read_audio32 {
1379 union cdrom_addr addr;
1380 u8 addr_format;
1381 compat_int_t nframes;
1382 compat_caddr_t buf;
1383};
1384
1385struct cdrom_generic_command32 {
1386 unsigned char cmd[CDROM_PACKET_SIZE];
1387 compat_caddr_t buffer;
1388 compat_uint_t buflen;
1389 compat_int_t stat;
1390 compat_caddr_t sense;
1391 unsigned char data_direction;
1392 compat_int_t quiet;
1393 compat_int_t timeout;
1394 compat_caddr_t reserved[1];
1395};
1396
1397static int cdrom_do_read_audio(unsigned int fd, unsigned int cmd, unsigned long arg)
1398{
1399 struct cdrom_read_audio *cdread_audio;
1400 struct cdrom_read_audio32 *cdread_audio32;
1401 __u32 data;
1402 void *datap;
1403
1404 cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio));
1405 cdread_audio32 = (struct cdrom_read_audio32 *) arg;
1406
1407 if (copy_in_user(&cdread_audio->addr,
1408 &cdread_audio32->addr,
1409 (sizeof(*cdread_audio32) -
1410 sizeof(compat_caddr_t))))
1411 return -EFAULT;
1412
1413 if (get_user(data, &cdread_audio32->buf))
1414 return -EFAULT;
1415 datap = (void *) (unsigned long) data;
1416 if (put_user(datap, &cdread_audio->buf))
1417 return -EFAULT;
1418
1419 return sys_ioctl(fd, cmd, (unsigned long) cdread_audio);
1420}
1421
1422static int __cgc_do_ptr(void **ptr64, __u32 *ptr32)
1423{
1424 u32 data;
1425 void *datap;
1426
1427 if (get_user(data, ptr32))
1428 return -EFAULT;
1429 datap = (void *) (unsigned long) data;
1430 if (put_user(datap, ptr64))
1431 return -EFAULT;
1432
1433 return 0;
1434}
1435
1436static int cdrom_do_generic_command(unsigned int fd, unsigned int cmd, unsigned long arg)
1437{
1438 struct cdrom_generic_command *cgc;
1439 struct cdrom_generic_command32 *cgc32;
1440 unsigned char dir;
1441
1442 cgc = compat_alloc_user_space(sizeof(*cgc));
1443 cgc32 = (struct cdrom_generic_command32 *) arg;
1444
1445 if (copy_in_user(&cgc->cmd, &cgc32->cmd, sizeof(cgc->cmd)) ||
1446 __cgc_do_ptr((void **) &cgc->buffer, &cgc32->buffer) ||
1447 copy_in_user(&cgc->buflen, &cgc32->buflen,
1448 (sizeof(unsigned int) + sizeof(int))) ||
1449 __cgc_do_ptr((void **) &cgc->sense, &cgc32->sense))
1450 return -EFAULT;
1451
1452 if (get_user(dir, &cgc->data_direction) ||
1453 put_user(dir, &cgc32->data_direction))
1454 return -EFAULT;
1455
1456 if (copy_in_user(&cgc->quiet, &cgc32->quiet,
1457 2 * sizeof(int)))
1458 return -EFAULT;
1459
1460 if (__cgc_do_ptr(&cgc->reserved[0], &cgc32->reserved[0]))
1461 return -EFAULT;
1462
1463 return sys_ioctl(fd, cmd, (unsigned long) cgc);
1464}
1465
1466static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1467{
1468 int err;
1469
1470 switch(cmd) {
1471 case CDROMREADAUDIO:
1472 err = cdrom_do_read_audio(fd, cmd, arg);
1473 break;
1474
1475 case CDROM_SEND_PACKET:
1476 err = cdrom_do_generic_command(fd, cmd, arg);
1477 break;
1478
1479 default:
1480 do {
1481 static int count;
1482 if (++count <= 20)
1483 printk("cdrom_ioctl: Unknown cmd fd(%d) "
1484 "cmd(%08x) arg(%08x)\n",
1485 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1486 } while(0);
1487 err = -EINVAL;
1488 break;
1489 };
1490
1491 return err;
1492}
1493
1494struct loop_info32 {
1495 compat_int_t lo_number;
1496 compat_dev_t lo_device;
1497 compat_ulong_t lo_inode;
1498 compat_dev_t lo_rdevice;
1499 compat_int_t lo_offset;
1500 compat_int_t lo_encrypt_type;
1501 compat_int_t lo_encrypt_key_size;
1502 compat_int_t lo_flags;
1503 char lo_name[LO_NAME_SIZE];
1504 unsigned char lo_encrypt_key[LO_KEY_SIZE];
1505 compat_ulong_t lo_init[2];
1506 char reserved[4];
1507};
1508
1509static int loop_status(unsigned int fd, unsigned int cmd, unsigned long arg)
1510{
1511 mm_segment_t old_fs = get_fs();
1512 struct loop_info l;
1513 int err = -EINVAL;
1514
1515 switch(cmd) {
1516 case LOOP_SET_STATUS:
1517 err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1518 err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1519 err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1520 err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1521 err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,
1522 8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1523 if (err) {
1524 err = -EFAULT;
1525 } else {
1526 set_fs (KERNEL_DS);
1527 err = sys_ioctl (fd, cmd, (unsigned long)&l);
1528 set_fs (old_fs);
1529 }
1530 break;
1531 case LOOP_GET_STATUS:
1532 set_fs (KERNEL_DS);
1533 err = sys_ioctl (fd, cmd, (unsigned long)&l);
1534 set_fs (old_fs);
1535 if (!err) {
1536 err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1537 err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1538 err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1539 err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1540 err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,
1541 (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1542 if (err)
1543 err = -EFAULT;
1544 }
1545 break;
1546 default: {
1547 static int count;
1548 if (++count <= 20)
1549 printk("%s: Unknown loop ioctl cmd, fd(%d) "
1550 "cmd(%08x) arg(%08lx)\n",
1551 __FUNCTION__, fd, cmd, arg);
1552 }
1553 }
1554 return err;
1555}
1556
1557extern int tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg);
1558
1559#ifdef CONFIG_VT
1560
1561static int vt_check(struct file *file)
1562{
1563 struct tty_struct *tty;
1564 struct inode *inode = file->f_dentry->d_inode;
1565
1566 if (file->f_op->ioctl != tty_ioctl)
1567 return -EINVAL;
1568
1569 tty = (struct tty_struct *)file->private_data;
1570 if (tty_paranoia_check(tty, inode, "tty_ioctl"))
1571 return -EINVAL;
1572
1573 if (tty->driver->ioctl != vt_ioctl)
1574 return -EINVAL;
1575
1576
1577
1578
1579
1580 if (current->tty == tty || capable(CAP_SYS_ADMIN))
1581 return 1;
1582 return 0;
1583}
1584
1585struct consolefontdesc32 {
1586 unsigned short charcount;
1587 unsigned short charheight;
1588 compat_caddr_t chardata;
1589};
1590
1591static int do_fontx_ioctl(unsigned int fd, int cmd, struct consolefontdesc32 *user_cfd, struct file *file)
1592{
1593 struct consolefontdesc cfdarg;
1594 struct console_font_op op;
1595 int i, perm;
1596
1597 perm = vt_check(file);
1598 if (perm < 0) return perm;
1599
1600 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc32)))
1601 return -EFAULT;
1602
1603 cfdarg.chardata = compat_ptr(((struct consolefontdesc32 *)&cfdarg)->chardata);
1604
1605 switch (cmd) {
1606 case PIO_FONTX:
1607 if (!perm)
1608 return -EPERM;
1609 op.op = KD_FONT_OP_SET;
1610 op.flags = 0;
1611 op.width = 8;
1612 op.height = cfdarg.charheight;
1613 op.charcount = cfdarg.charcount;
1614 op.data = cfdarg.chardata;
1615 return con_font_op(fg_console, &op);
1616 case GIO_FONTX:
1617 if (!cfdarg.chardata)
1618 return 0;
1619 op.op = KD_FONT_OP_GET;
1620 op.flags = 0;
1621 op.width = 8;
1622 op.height = cfdarg.charheight;
1623 op.charcount = cfdarg.charcount;
1624 op.data = cfdarg.chardata;
1625 i = con_font_op(fg_console, &op);
1626 if (i)
1627 return i;
1628 cfdarg.charheight = op.height;
1629 cfdarg.charcount = op.charcount;
1630 ((struct consolefontdesc32 *)&cfdarg)->chardata = (unsigned long)cfdarg.chardata;
1631 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc32)))
1632 return -EFAULT;
1633 return 0;
1634 }
1635 return -EINVAL;
1636}
1637
1638struct console_font_op32 {
1639 compat_uint_t op;
1640 compat_uint_t flags;
1641 compat_uint_t width, height;
1642 compat_uint_t charcount;
1643 compat_caddr_t data;
1644};
1645
1646static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, struct console_font_op32 *fontop, struct file *file)
1647{
1648 struct console_font_op op;
1649 int perm = vt_check(file), i;
1650 struct vt_struct *vt;
1651
1652 if (perm < 0) return perm;
1653
1654 if (copy_from_user(&op, (void *) fontop, sizeof(struct console_font_op32)))
1655 return -EFAULT;
1656 if (!perm && op.op != KD_FONT_OP_GET)
1657 return -EPERM;
1658 op.data = compat_ptr(((struct console_font_op32 *)&op)->data);
1659 op.flags |= KD_FONT_FLAG_OLD;
1660 vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data;
1661 i = con_font_op(vt->vc_num, &op);
1662 if (i) return i;
1663 ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
1664 if (copy_to_user((void *) fontop, &op, sizeof(struct console_font_op32)))
1665 return -EFAULT;
1666 return 0;
1667}
1668
1669struct unimapdesc32 {
1670 unsigned short entry_ct;
1671 compat_caddr_t entries;
1672};
1673
1674static int do_unimap_ioctl(unsigned int fd, unsigned int cmd, struct unimapdesc32 *user_ud, struct file *file)
1675{
1676 struct unimapdesc32 tmp;
1677 int perm = vt_check(file);
1678
1679 if (perm < 0) return perm;
1680 if (copy_from_user(&tmp, user_ud, sizeof tmp))
1681 return -EFAULT;
1682 switch (cmd) {
1683 case PIO_UNIMAP:
1684 if (!perm) return -EPERM;
1685 return con_set_unimap(fg_console, tmp.entry_ct, compat_ptr(tmp.entries));
1686 case GIO_UNIMAP:
1687 return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), compat_ptr(tmp.entries));
1688 }
1689 return 0;
1690}
1691
1692#endif
1693
1694static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long arg)
1695{
1696 mm_segment_t old_fs = get_fs();
1697 __kernel_uid_t kuid;
1698 int err;
1699
1700 cmd = SMB_IOC_GETMOUNTUID;
1701
1702 set_fs(KERNEL_DS);
1703 err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
1704 set_fs(old_fs);
1705
1706 if (err >= 0)
1707 err = put_user(kuid, (compat_uid_t *)arg);
1708
1709 return err;
1710}
1711
1712struct atmif_sioc32 {
1713 compat_int_t number;
1714 compat_int_t length;
1715 compat_caddr_t arg;
1716};
1717
1718struct atm_iobuf32 {
1719 compat_int_t length;
1720 compat_caddr_t buffer;
1721};
1722
1723#define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
1724#define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
1725#define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
1726#define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
1727#define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
1728#define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
1729#define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
1730#define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
1731#define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
1732#define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
1733#define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
1734#define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
1735#define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
1736#define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
1737#define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
1738#define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
1739#define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
1740
1741static struct {
1742 unsigned int cmd32;
1743 unsigned int cmd;
1744} atm_ioctl_map[] = {
1745 { ATM_GETLINKRATE32, ATM_GETLINKRATE },
1746 { ATM_GETNAMES32, ATM_GETNAMES },
1747 { ATM_GETTYPE32, ATM_GETTYPE },
1748 { ATM_GETESI32, ATM_GETESI },
1749 { ATM_GETADDR32, ATM_GETADDR },
1750 { ATM_RSTADDR32, ATM_RSTADDR },
1751 { ATM_ADDADDR32, ATM_ADDADDR },
1752 { ATM_DELADDR32, ATM_DELADDR },
1753 { ATM_GETCIRANGE32, ATM_GETCIRANGE },
1754 { ATM_SETCIRANGE32, ATM_SETCIRANGE },
1755 { ATM_SETESI32, ATM_SETESI },
1756 { ATM_SETESIF32, ATM_SETESIF },
1757 { ATM_GETSTAT32, ATM_GETSTAT },
1758 { ATM_GETSTATZ32, ATM_GETSTATZ },
1759 { ATM_GETLOOP32, ATM_GETLOOP },
1760 { ATM_SETLOOP32, ATM_SETLOOP },
1761 { ATM_QUERYLOOP32, ATM_QUERYLOOP }
1762};
1763
1764#define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
1765
1766
1767static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
1768{
1769 struct atm_iobuf *iobuf;
1770 struct atm_iobuf32 *iobuf32;
1771 u32 data;
1772 void *datap;
1773 int len, err;
1774
1775 iobuf = compat_alloc_user_space(sizeof(*iobuf));
1776 iobuf32 = (struct atm_iobuf32 *) arg;
1777
1778 if (get_user(len, &iobuf32->length) ||
1779 get_user(data, &iobuf32->buffer))
1780 return -EFAULT;
1781 datap = (void *) (unsigned long) data;
1782 if (put_user(len, &iobuf->length) ||
1783 put_user(datap, &iobuf->buffer))
1784 return -EFAULT;
1785
1786 err = sys_ioctl(fd, cmd, (unsigned long)iobuf);
1787
1788 if (!err) {
1789 if (copy_in_user(&iobuf32->length, &iobuf->length,
1790 sizeof(int)))
1791 err = -EFAULT;
1792 }
1793
1794 return err;
1795}
1796
1797static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg)
1798{
1799 struct atmif_sioc *sioc;
1800 struct atmif_sioc32 *sioc32;
1801 u32 data;
1802 void *datap;
1803 int err;
1804
1805 sioc = compat_alloc_user_space(sizeof(*sioc));
1806 sioc32 = (struct atmif_sioc32 *) arg;
1807
1808 if (copy_in_user(&sioc->number, &sioc32->number, 2 * sizeof(int)) ||
1809 get_user(data, &sioc32->arg))
1810 return -EFAULT;
1811 datap = (void *) (unsigned long) data;
1812 if (put_user(datap, &sioc->arg))
1813 return -EFAULT;
1814
1815 err = sys_ioctl(fd, cmd, (unsigned long) sioc);
1816
1817 if (!err) {
1818 if (copy_in_user(&sioc32->length, &sioc->length,
1819 sizeof(int)))
1820 err = -EFAULT;
1821 }
1822 return err;
1823}
1824
1825static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg)
1826{
1827 int i;
1828 unsigned int cmd = 0;
1829
1830 switch (cmd32) {
1831 case SONET_GETSTAT:
1832 case SONET_GETSTATZ:
1833 case SONET_GETDIAG:
1834 case SONET_SETDIAG:
1835 case SONET_CLRDIAG:
1836 case SONET_SETFRAMING:
1837 case SONET_GETFRAMING:
1838 case SONET_GETFRSENSE:
1839 return do_atmif_sioc(fd, cmd32, arg);
1840 }
1841
1842 for (i = 0; i < NR_ATM_IOCTL; i++) {
1843 if (cmd32 == atm_ioctl_map[i].cmd32) {
1844 cmd = atm_ioctl_map[i].cmd;
1845 break;
1846 }
1847 }
1848 if (i == NR_ATM_IOCTL)
1849 return -EINVAL;
1850
1851 switch (cmd) {
1852 case ATM_GETNAMES:
1853 return do_atm_iobuf(fd, cmd, arg);
1854
1855 case ATM_GETLINKRATE:
1856 case ATM_GETTYPE:
1857 case ATM_GETESI:
1858 case ATM_GETADDR:
1859 case ATM_RSTADDR:
1860 case ATM_ADDADDR:
1861 case ATM_DELADDR:
1862 case ATM_GETCIRANGE:
1863 case ATM_SETCIRANGE:
1864 case ATM_SETESI:
1865 case ATM_SETESIF:
1866 case ATM_GETSTAT:
1867 case ATM_GETSTATZ:
1868 case ATM_GETLOOP:
1869 case ATM_SETLOOP:
1870 case ATM_QUERYLOOP:
1871 return do_atmif_sioc(fd, cmd, arg);
1872 }
1873
1874 return -EINVAL;
1875}
1876
1877static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
1878{
1879 return -EINVAL;
1880}
1881
1882static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
1883{
1884
1885 return w_long(fd, BLKGETSIZE, arg);
1886}
1887
1888struct blkpg_ioctl_arg32 {
1889 compat_int_t op;
1890 compat_int_t flags;
1891 compat_int_t datalen;
1892 compat_caddr_t data;
1893};
1894
1895static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd, struct blkpg_ioctl_arg32 *arg)
1896{
1897 struct blkpg_ioctl_arg a;
1898 struct blkpg_partition p;
1899 int err;
1900 mm_segment_t old_fs = get_fs();
1901
1902 err = get_user(a.op, &arg->op);
1903 err |= __get_user(a.flags, &arg->flags);
1904 err |= __get_user(a.datalen, &arg->datalen);
1905 err |= __get_user((long)a.data, &arg->data);
1906 if (err) return err;
1907 switch (a.op) {
1908 case BLKPG_ADD_PARTITION:
1909 case BLKPG_DEL_PARTITION:
1910 if (a.datalen < sizeof(struct blkpg_partition))
1911 return -EINVAL;
1912 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
1913 return -EFAULT;
1914 a.data = &p;
1915 set_fs (KERNEL_DS);
1916 err = sys_ioctl(fd, cmd, (unsigned long)&a);
1917 set_fs (old_fs);
1918 default:
1919 return -EINVAL;
1920 }
1921 return err;
1922}
1923
1924static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
1925{
1926 return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
1927}
1928
1929
1930#define BLKBSZGET_32 _IOR(0x12,112,int)
1931#define BLKBSZSET_32 _IOW(0x12,113,int)
1932#define BLKGETSIZE64_32 _IOR(0x12,114,int)
1933
1934static int do_blkbszget(unsigned int fd, unsigned int cmd, unsigned long arg)
1935{
1936 return sys_ioctl(fd, BLKBSZGET, arg);
1937}
1938
1939static int do_blkbszset(unsigned int fd, unsigned int cmd, unsigned long arg)
1940{
1941 return sys_ioctl(fd, BLKBSZSET, arg);
1942}
1943
1944static int do_blkgetsize64(unsigned int fd, unsigned int cmd,
1945 unsigned long arg)
1946{
1947 return sys_ioctl(fd, BLKGETSIZE64, arg);
1948}
1949
1950
1951#define HCIUARTSETPROTO _IOW('U', 200, int)
1952#define HCIUARTGETPROTO _IOR('U', 201, int)
1953
1954#define BNEPCONNADD _IOW('B', 200, int)
1955#define BNEPCONNDEL _IOW('B', 201, int)
1956#define BNEPGETCONNLIST _IOR('B', 210, int)
1957#define BNEPGETCONNINFO _IOR('B', 211, int)
1958
1959struct floppy_struct32 {
1960 compat_uint_t size;
1961 compat_uint_t sect;
1962 compat_uint_t head;
1963 compat_uint_t track;
1964 compat_uint_t stretch;
1965 unsigned char gap;
1966 unsigned char rate;
1967 unsigned char spec1;
1968 unsigned char fmt_gap;
1969 const compat_caddr_t name;
1970};
1971
1972struct floppy_drive_params32 {
1973 char cmos;
1974 compat_ulong_t max_dtr;
1975 compat_ulong_t hlt;
1976 compat_ulong_t hut;
1977 compat_ulong_t srt;
1978 compat_ulong_t spinup;
1979 compat_ulong_t spindown;
1980 unsigned char spindown_offset;
1981 unsigned char select_delay;
1982 unsigned char rps;
1983 unsigned char tracks;
1984 compat_ulong_t timeout;
1985 unsigned char interleave_sect;
1986 struct floppy_max_errors max_errors;
1987 char flags;
1988 char read_track;
1989 short autodetect[8];
1990 compat_int_t checkfreq;
1991 compat_int_t native_format;
1992};
1993
1994struct floppy_drive_struct32 {
1995 signed char flags;
1996 compat_ulong_t spinup_date;
1997 compat_ulong_t select_date;
1998 compat_ulong_t first_read_date;
1999 short probed_format;
2000 short track;
2001 short maxblock;
2002 short maxtrack;
2003 compat_int_t generation;
2004 compat_int_t keep_data;
2005 compat_int_t fd_ref;
2006 compat_int_t fd_device;
2007 compat_int_t last_checked;
2008 compat_caddr_t dmabuf;
2009 compat_int_t bufblocks;
2010};
2011
2012struct floppy_fdc_state32 {
2013 compat_int_t spec1;
2014 compat_int_t spec2;
2015 compat_int_t dtr;
2016 unsigned char version;
2017 unsigned char dor;
2018 compat_ulong_t address;
2019 unsigned int rawcmd:2;
2020 unsigned int reset:1;
2021 unsigned int need_configure:1;
2022 unsigned int perp_mode:2;
2023 unsigned int has_fifo:1;
2024 unsigned int driver_version;
2025 unsigned char track[4];
2026};
2027
2028struct floppy_write_errors32 {
2029 unsigned int write_errors;
2030 compat_ulong_t first_error_sector;
2031 compat_int_t first_error_generation;
2032 compat_ulong_t last_error_sector;
2033 compat_int_t last_error_generation;
2034 compat_uint_t badness;
2035};
2036
2037#define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
2038#define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
2039#define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
2040#define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
2041#define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
2042#define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
2043#define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
2044#define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
2045#define FDWERRORGET32 _IOR(2, 0x17, struct floppy_write_errors32)
2046
2047static struct {
2048 unsigned int cmd32;
2049 unsigned int cmd;
2050} fd_ioctl_trans_table[] = {
2051 { FDSETPRM32, FDSETPRM },
2052 { FDDEFPRM32, FDDEFPRM },
2053 { FDGETPRM32, FDGETPRM },
2054 { FDSETDRVPRM32, FDSETDRVPRM },
2055 { FDGETDRVPRM32, FDGETDRVPRM },
2056 { FDGETDRVSTAT32, FDGETDRVSTAT },
2057 { FDPOLLDRVSTAT32, FDPOLLDRVSTAT },
2058 { FDGETFDCSTAT32, FDGETFDCSTAT },
2059 { FDWERRORGET32, FDWERRORGET }
2060};
2061
2062#define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
2063
2064static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
2065{
2066 mm_segment_t old_fs = get_fs();
2067 void *karg = NULL;
2068 unsigned int kcmd = 0;
2069 int i, err;
2070
2071 for (i = 0; i < NR_FD_IOCTL_TRANS; i++)
2072 if (cmd == fd_ioctl_trans_table[i].cmd32) {
2073 kcmd = fd_ioctl_trans_table[i].cmd;
2074 break;
2075 }
2076 if (!kcmd)
2077 return -EINVAL;
2078
2079 switch (cmd) {
2080 case FDSETPRM32:
2081 case FDDEFPRM32:
2082 case FDGETPRM32:
2083 {
2084 struct floppy_struct *f;
2085
2086 f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
2087 if (!karg)
2088 return -ENOMEM;
2089 if (cmd == FDGETPRM32)
2090 break;
2091 err = __get_user(f->size, &((struct floppy_struct32 *)arg)->size);
2092 err |= __get_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
2093 err |= __get_user(f->head, &((struct floppy_struct32 *)arg)->head);
2094 err |= __get_user(f->track, &((struct floppy_struct32 *)arg)->track);
2095 err |= __get_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
2096 err |= __get_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
2097 err |= __get_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
2098 err |= __get_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
2099 err |= __get_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
2100 err |= __get_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
2101 if (err) {
2102 err = -EFAULT;
2103 goto out;
2104 }
2105 break;
2106 }
2107 case FDSETDRVPRM32:
2108 case FDGETDRVPRM32:
2109 {
2110 struct floppy_drive_params *f;
2111
2112 f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
2113 if (!karg)
2114 return -ENOMEM;
2115 if (cmd == FDGETDRVPRM32)
2116 break;
2117 err = __get_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
2118 err |= __get_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
2119 err |= __get_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
2120 err |= __get_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
2121 err |= __get_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
2122 err |= __get_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
2123 err |= __get_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
2124 err |= __get_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
2125 err |= __get_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
2126 err |= __get_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
2127 err |= __get_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
2128 err |= __get_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
2129 err |= __get_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
2130 err |= __copy_from_user(&f->max_errors, &((struct floppy_drive_params32 *)arg)->max_errors, sizeof(f->max_errors));
2131 err |= __get_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
2132 err |= __get_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
2133 err |= __copy_from_user(f->autodetect, ((struct floppy_drive_params32 *)arg)->autodetect, sizeof(f->autodetect));
2134 err |= __get_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
2135 err |= __get_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
2136 if (err) {
2137 err = -EFAULT;
2138 goto out;
2139 }
2140 break;
2141 }
2142 case FDGETDRVSTAT32:
2143 case FDPOLLDRVSTAT32:
2144 karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
2145 if (!karg)
2146 return -ENOMEM;
2147 break;
2148 case FDGETFDCSTAT32:
2149 karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
2150 if (!karg)
2151 return -ENOMEM;
2152 break;
2153 case FDWERRORGET32:
2154 karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
2155 if (!karg)
2156 return -ENOMEM;
2157 break;
2158 default:
2159 return -EINVAL;
2160 }
2161 set_fs (KERNEL_DS);
2162 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
2163 set_fs (old_fs);
2164 if (err)
2165 goto out;
2166 switch (cmd) {
2167 case FDGETPRM32:
2168 {
2169 struct floppy_struct *f = karg;
2170
2171 err = __put_user(f->size, &((struct floppy_struct32 *)arg)->size);
2172 err |= __put_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
2173 err |= __put_user(f->head, &((struct floppy_struct32 *)arg)->head);
2174 err |= __put_user(f->track, &((struct floppy_struct32 *)arg)->track);
2175 err |= __put_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
2176 err |= __put_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
2177 err |= __put_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
2178 err |= __put_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
2179 err |= __put_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
2180 err |= __put_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
2181 break;
2182 }
2183 case FDGETDRVPRM32:
2184 {
2185 struct floppy_drive_params *f = karg;
2186
2187 err = __put_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
2188 err |= __put_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
2189 err |= __put_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
2190 err |= __put_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
2191 err |= __put_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
2192 err |= __put_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
2193 err |= __put_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
2194 err |= __put_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
2195 err |= __put_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
2196 err |= __put_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
2197 err |= __put_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
2198 err |= __put_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
2199 err |= __put_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
2200 err |= __copy_to_user(&((struct floppy_drive_params32 *)arg)->max_errors, &f->max_errors, sizeof(f->max_errors));
2201 err |= __put_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
2202 err |= __put_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
2203 err |= __copy_to_user(((struct floppy_drive_params32 *)arg)->autodetect, f->autodetect, sizeof(f->autodetect));
2204 err |= __put_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
2205 err |= __put_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
2206 break;
2207 }
2208 case FDGETDRVSTAT32:
2209 case FDPOLLDRVSTAT32:
2210 {
2211 struct floppy_drive_struct *f = karg;
2212
2213 err = __put_user(f->flags, &((struct floppy_drive_struct32 *)arg)->flags);
2214 err |= __put_user(f->spinup_date, &((struct floppy_drive_struct32 *)arg)->spinup_date);
2215 err |= __put_user(f->select_date, &((struct floppy_drive_struct32 *)arg)->select_date);
2216 err |= __put_user(f->first_read_date, &((struct floppy_drive_struct32 *)arg)->first_read_date);
2217 err |= __put_user(f->probed_format, &((struct floppy_drive_struct32 *)arg)->probed_format);
2218 err |= __put_user(f->track, &((struct floppy_drive_struct32 *)arg)->track);
2219 err |= __put_user(f->maxblock, &((struct floppy_drive_struct32 *)arg)->maxblock);
2220 err |= __put_user(f->maxtrack, &((struct floppy_drive_struct32 *)arg)->maxtrack);
2221 err |= __put_user(f->generation, &((struct floppy_drive_struct32 *)arg)->generation);
2222 err |= __put_user(f->keep_data, &((struct floppy_drive_struct32 *)arg)->keep_data);
2223 err |= __put_user(f->fd_ref, &((struct floppy_drive_struct32 *)arg)->fd_ref);
2224 err |= __put_user(f->fd_device, &((struct floppy_drive_struct32 *)arg)->fd_device);
2225 err |= __put_user(f->last_checked, &((struct floppy_drive_struct32 *)arg)->last_checked);
2226 err |= __put_user((u64)f->dmabuf, &((struct floppy_drive_struct32 *)arg)->dmabuf);
2227 err |= __put_user((u64)f->bufblocks, &((struct floppy_drive_struct32 *)arg)->bufblocks);
2228 break;
2229 }
2230 case FDGETFDCSTAT32:
2231 {
2232 struct floppy_fdc_state *f = karg;
2233
2234 err = __put_user(f->spec1, &((struct floppy_fdc_state32 *)arg)->spec1);
2235 err |= __put_user(f->spec2, &((struct floppy_fdc_state32 *)arg)->spec2);
2236 err |= __put_user(f->dtr, &((struct floppy_fdc_state32 *)arg)->dtr);
2237 err |= __put_user(f->version, &((struct floppy_fdc_state32 *)arg)->version);
2238 err |= __put_user(f->dor, &((struct floppy_fdc_state32 *)arg)->dor);
2239 err |= __put_user(f->address, &((struct floppy_fdc_state32 *)arg)->address);
2240 err |= __copy_to_user((char *)&((struct floppy_fdc_state32 *)arg)->address
2241 + sizeof(((struct floppy_fdc_state32 *)arg)->address),
2242 (char *)&f->address + sizeof(f->address), sizeof(int));
2243 err |= __put_user(f->driver_version, &((struct floppy_fdc_state32 *)arg)->driver_version);
2244 err |= __copy_to_user(((struct floppy_fdc_state32 *)arg)->track, f->track, sizeof(f->track));
2245 break;
2246 }
2247 case FDWERRORGET32:
2248 {
2249 struct floppy_write_errors *f = karg;
2250
2251 err = __put_user(f->write_errors, &((struct floppy_write_errors32 *)arg)->write_errors);
2252 err |= __put_user(f->first_error_sector, &((struct floppy_write_errors32 *)arg)->first_error_sector);
2253 err |= __put_user(f->first_error_generation, &((struct floppy_write_errors32 *)arg)->first_error_generation);
2254 err |= __put_user(f->last_error_sector, &((struct floppy_write_errors32 *)arg)->last_error_sector);
2255 err |= __put_user(f->last_error_generation, &((struct floppy_write_errors32 *)arg)->last_error_generation);
2256 err |= __put_user(f->badness, &((struct floppy_write_errors32 *)arg)->badness);
2257 break;
2258 }
2259 default:
2260 break;
2261 }
2262 if (err)
2263 err = -EFAULT;
2264
2265out: if (karg) kfree(karg);
2266 return err;
2267}
2268
2269struct mtd_oob_buf32 {
2270 u_int32_t start;
2271 u_int32_t length;
2272 compat_caddr_t ptr;
2273};
2274
2275#define MEMWRITEOOB32 _IOWR('M',3,struct mtd_oob_buf32)
2276#define MEMREADOOB32 _IOWR('M',4,struct mtd_oob_buf32)
2277
2278static int mtd_rw_oob(unsigned int fd, unsigned int cmd, unsigned long arg)
2279{
2280 struct mtd_oob_buf *buf = compat_alloc_user_space(sizeof(*buf));
2281 struct mtd_oob_buf32 *buf32 = (struct mtd_oob_buf32 *) arg;
2282 u32 data;
2283 char *datap;
2284 unsigned int real_cmd;
2285 int err;
2286
2287 real_cmd = (cmd == MEMREADOOB32) ?
2288 MEMREADOOB : MEMWRITEOOB;
2289
2290 if (copy_in_user(&buf->start, &buf32->start,
2291 2 * sizeof(u32)) ||
2292 get_user(data, &buf32->ptr))
2293 return -EFAULT;
2294 datap = (void *) (unsigned long) data;
2295 if (put_user(datap, &buf->ptr))
2296 return -EFAULT;
2297
2298 err = sys_ioctl(fd, real_cmd, (unsigned long) buf);
2299
2300 if (!err) {
2301 if (copy_in_user(&buf32->start, &buf->start,
2302 2 * sizeof(u32)))
2303 err = -EFAULT;
2304 }
2305
2306 return err;
2307}
2308
2309#define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
2310#define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
2311
2312static long
2313put_dirent32 (struct dirent *d, struct compat_dirent *d32)
2314{
2315 int ret;
2316
2317 if ((ret = verify_area(VERIFY_WRITE, d32,
2318 sizeof(struct compat_dirent))))
2319 return ret;
2320
2321 __put_user(d->d_ino, &d32->d_ino);
2322 __put_user(d->d_off, &d32->d_off);
2323 __put_user(d->d_reclen, &d32->d_reclen);
2324 __copy_to_user(d32->d_name, d->d_name, d->d_reclen);
2325 return ret;
2326}
2327
2328static int vfat_ioctl32(unsigned fd, unsigned cmd, void *ptr)
2329{
2330 int ret;
2331 mm_segment_t oldfs = get_fs();
2332 struct dirent d[2];
2333
2334 switch(cmd)
2335 {
2336 case VFAT_IOCTL_READDIR_BOTH32:
2337 cmd = VFAT_IOCTL_READDIR_BOTH;
2338 break;
2339 case VFAT_IOCTL_READDIR_SHORT32:
2340 cmd = VFAT_IOCTL_READDIR_SHORT;
2341 break;
2342 }
2343
2344 set_fs(KERNEL_DS);
2345 ret = sys_ioctl(fd,cmd,(unsigned long)&d);
2346 set_fs(oldfs);
2347 if (ret >= 0) {
2348 ret |= put_dirent32(&d[0], (struct compat_dirent *)ptr);
2349 ret |= put_dirent32(&d[1], ((struct compat_dirent *)ptr) + 1);
2350 }
2351 return ret;
2352}
2353
2354#define REISERFS_IOC_UNPACK32 _IOW(0xCD,1,int)
2355
2356static int reiserfs_ioctl32(unsigned fd, unsigned cmd, unsigned long ptr)
2357{
2358 if (cmd == REISERFS_IOC_UNPACK32)
2359 cmd = REISERFS_IOC_UNPACK;
2360
2361 return sys_ioctl(fd,cmd,ptr);
2362}
2363
2364struct raw32_config_request
2365{
2366 compat_int_t raw_minor;
2367 __u64 block_major;
2368 __u64 block_minor;
2369} __attribute__((packed));
2370
2371static int get_raw32_request(struct raw_config_request *req, struct raw32_config_request *user_req)
2372{
2373 __u32 lo_maj, hi_maj, lo_min, hi_min;
2374 int ret;
2375
2376 if ((ret = verify_area(VERIFY_READ, user_req,
2377 sizeof(struct raw32_config_request))))
2378 return ret;
2379
2380 __get_user(req->raw_minor, &user_req->raw_minor);
2381 __get_user(lo_maj, (__u32*)&user_req->block_major);
2382 __get_user(hi_maj, ((__u32*)(&user_req->block_major) + 1));
2383 __get_user(lo_min, (__u32*)&user_req->block_minor);
2384 __get_user(hi_min, ((__u32*)(&user_req->block_minor) + 1));
2385
2386 req->block_major = lo_maj | (((__u64)hi_maj) << 32);
2387 req->block_minor = lo_min | (((__u64)lo_min) << 32);
2388
2389 return ret;
2390}
2391
2392static int set_raw32_request(struct raw_config_request *req, struct raw32_config_request *user_req)
2393{
2394 int ret;
2395
2396 if ((ret = verify_area(VERIFY_WRITE, user_req,
2397 sizeof(struct raw32_config_request))))
2398 return ret;
2399
2400 __put_user(req->raw_minor, &user_req->raw_minor);
2401 __put_user((__u32)(req->block_major), (__u32*)&user_req->block_major);
2402 __put_user((__u32)(req->block_major >> 32), ((__u32*)(&user_req->block_major) + 1));
2403 __put_user((__u32)(req->block_minor), (__u32*)&user_req->block_minor);
2404 __put_user((__u32)(req->block_minor >> 32), ((__u32*)(&user_req->block_minor) + 1));
2405
2406 return ret;
2407}
2408
2409static int raw_ioctl(unsigned fd, unsigned cmd, void *ptr)
2410{
2411 int ret;
2412
2413 switch (cmd) {
2414 case RAW_SETBIND:
2415 case RAW_GETBIND: {
2416 struct raw_config_request req;
2417 struct raw32_config_request *user_req = ptr;
2418 mm_segment_t oldfs = get_fs();
2419
2420 if ((ret = get_raw32_request(&req, user_req)))
2421 return ret;
2422
2423 set_fs(KERNEL_DS);
2424 ret = sys_ioctl(fd,cmd,(unsigned long)&req);
2425 set_fs(oldfs);
2426
2427 if ((!ret) && (cmd == RAW_GETBIND)) {
2428 ret = set_raw32_request(&req, user_req);
2429 }
2430 break;
2431 }
2432 default:
2433 ret = sys_ioctl(fd,cmd,(unsigned long)ptr);
2434 break;
2435 }
2436 return ret;
2437}
2438
2439struct serial_struct32 {
2440 compat_int_t type;
2441 compat_int_t line;
2442 compat_uint_t port;
2443 compat_int_t irq;
2444 compat_int_t flags;
2445 compat_int_t xmit_fifo_size;
2446 compat_int_t custom_divisor;
2447 compat_int_t baud_base;
2448 unsigned short close_delay;
2449 char io_type;
2450 char reserved_char[1];
2451 compat_int_t hub6;
2452 unsigned short closing_wait;
2453 unsigned short closing_wait2;
2454 compat_uint_t iomem_base;
2455 unsigned short iomem_reg_shift;
2456 unsigned int port_high;
2457 compat_int_t reserved[1];
2458};
2459
2460static int serial_struct_ioctl(unsigned fd, unsigned cmd, void *ptr)
2461{
2462 typedef struct serial_struct SS;
2463 typedef struct serial_struct32 SS32;
2464 struct serial_struct32 *ss32 = ptr;
2465 int err;
2466 struct serial_struct ss;
2467 mm_segment_t oldseg = get_fs();
2468 __u32 udata;
2469
2470 if (cmd == TIOCSSERIAL) {
2471 if (verify_area(VERIFY_READ, ss32, sizeof(SS32)))
2472 return -EFAULT;
2473 __copy_from_user(&ss, ss32, offsetof(SS32, iomem_base));
2474 __get_user(udata, &ss32->iomem_base);
2475 ss.iomem_base = compat_ptr(udata);
2476 __get_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift);
2477 __get_user(ss.port_high, &ss32->port_high);
2478 ss.iomap_base = 0UL;
2479 }
2480 set_fs(KERNEL_DS);
2481 err = sys_ioctl(fd,cmd,(unsigned long)(&ss));
2482 set_fs(oldseg);
2483 if (cmd == TIOCGSERIAL && err >= 0) {
2484 if (verify_area(VERIFY_WRITE, ss32, sizeof(SS32)))
2485 return -EFAULT;
2486 __copy_to_user(ss32,&ss,offsetof(SS32,iomem_base));
2487 __put_user((unsigned long)ss.iomem_base >> 32 ?
2488 0xffffffff : (unsigned)(unsigned long)ss.iomem_base,
2489 &ss32->iomem_base);
2490 __put_user(ss.iomem_reg_shift, &ss32->iomem_reg_shift);
2491 __put_user(ss.port_high, &ss32->port_high);
2492
2493 }
2494 return err;
2495}
2496
2497struct usbdevfs_ctrltransfer32 {
2498 u8 bRequestType;
2499 u8 bRequest;
2500 u16 wValue;
2501 u16 wIndex;
2502 u16 wLength;
2503 u32 timeout;
2504 compat_caddr_t data;
2505};
2506
2507#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
2508
2509static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
2510{
2511 struct usbdevfs_ctrltransfer kctrl;
2512 struct usbdevfs_ctrltransfer32 *uctrl;
2513 mm_segment_t old_fs;
2514 __u32 udata;
2515 void *uptr, *kptr;
2516 int err;
2517
2518 uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
2519
2520 if (copy_from_user(&kctrl, uctrl,
2521 (sizeof(struct usbdevfs_ctrltransfer32) -
2522 sizeof(compat_caddr_t))))
2523 return -EFAULT;
2524
2525 if (get_user(udata, &uctrl->data))
2526 return -EFAULT;
2527 uptr = compat_ptr(udata);
2528
2529
2530
2531 if (!uptr || kctrl.wLength > PAGE_SIZE)
2532 return -EINVAL;
2533
2534 kptr = (void *)__get_free_page(GFP_KERNEL);
2535
2536 if ((kctrl.bRequestType & USB_DIR_IN) == 0) {
2537 err = -EFAULT;
2538 if (copy_from_user(kptr, uptr, kctrl.wLength))
2539 goto out;
2540 }
2541
2542 kctrl.data = kptr;
2543
2544 old_fs = get_fs();
2545 set_fs(KERNEL_DS);
2546 err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
2547 set_fs(old_fs);
2548
2549 if (err >= 0 &&
2550 ((kctrl.bRequestType & USB_DIR_IN) != 0)) {
2551 if (copy_to_user(uptr, kptr, kctrl.wLength))
2552 err = -EFAULT;
2553 }
2554
2555out:
2556 free_page((unsigned long) kptr);
2557 return err;
2558}
2559
2560
2561struct usbdevfs_bulktransfer32 {
2562 compat_uint_t ep;
2563 compat_uint_t len;
2564 compat_uint_t timeout;
2565 compat_caddr_t data;
2566};
2567
2568#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
2569
2570static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
2571{
2572 struct usbdevfs_bulktransfer kbulk;
2573 struct usbdevfs_bulktransfer32 *ubulk;
2574 mm_segment_t old_fs;
2575 __u32 udata;
2576 void *uptr, *kptr;
2577 int err;
2578
2579 ubulk = (struct usbdevfs_bulktransfer32 *) arg;
2580
2581 if (get_user(kbulk.ep, &ubulk->ep) ||
2582 get_user(kbulk.len, &ubulk->len) ||
2583 get_user(kbulk.timeout, &ubulk->timeout) ||
2584 get_user(udata, &ubulk->data))
2585 return -EFAULT;
2586
2587 uptr = compat_ptr(udata);
2588
2589
2590
2591
2592 if (!uptr || kbulk.len > PAGE_SIZE)
2593 return -EINVAL;
2594
2595 kptr = (void *) __get_free_page(GFP_KERNEL);
2596
2597 if ((kbulk.ep & 0x80) == 0) {
2598 err = -EFAULT;
2599 if (copy_from_user(kptr, uptr, kbulk.len))
2600 goto out;
2601 }
2602
2603 kbulk.data = kptr;
2604
2605 old_fs = get_fs();
2606 set_fs(KERNEL_DS);
2607 err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
2608 set_fs(old_fs);
2609
2610 if (err >= 0 &&
2611 ((kbulk.ep & 0x80) != 0)) {
2612 if (copy_to_user(uptr, kptr, kbulk.len))
2613 err = -EFAULT;
2614 }
2615
2616out:
2617 free_page((unsigned long) kptr);
2618 return err;
2619}
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661#if 0
2662struct usbdevfs_urb32 {
2663 unsigned char type;
2664 unsigned char endpoint;
2665 compat_int_t status;
2666 compat_uint_t flags;
2667 compat_caddr_t buffer;
2668 compat_int_t buffer_length;
2669 compat_int_t actual_length;
2670 compat_int_t start_frame;
2671 compat_int_t number_of_packets;
2672 compat_int_t error_count;
2673 compat_uint_t signr;
2674 compat_caddr_t usercontext;
2675 struct usbdevfs_iso_packet_desc iso_frame_desc[0];
2676};
2677
2678#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
2679
2680static int get_urb32(struct usbdevfs_urb *kurb,
2681 struct usbdevfs_urb32 *uurb)
2682{
2683 if (get_user(kurb->type, &uurb->type) ||
2684 __get_user(kurb->endpoint, &uurb->endpoint) ||
2685 __get_user(kurb->status, &uurb->status) ||
2686 __get_user(kurb->flags, &uurb->flags) ||
2687 __get_user(kurb->buffer_length, &uurb->buffer_length) ||
2688 __get_user(kurb->actual_length, &uurb->actual_length) ||
2689 __get_user(kurb->start_frame, &uurb->start_frame) ||
2690 __get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
2691 __get_user(kurb->error_count, &uurb->error_count) ||
2692 __get_user(kurb->signr, &uurb->signr))
2693 return -EFAULT;
2694
2695 kurb->usercontext = 0;
2696
2697 return 0;
2698}
2699
2700
2701static int put_urb32(struct usbdevfs_urb *kurb,
2702 struct usbdevfs_urb32 *uurb)
2703{
2704 if (put_user(kurb->status, &uurb->status) ||
2705 __put_user(kurb->actual_length, &uurb->actual_length) ||
2706 __put_user(kurb->error_count, &uurb->error_count))
2707 return -EFAULT;
2708
2709 if (kurb->number_of_packets != 0) {
2710 int i;
2711
2712 for (i = 0; i < kurb->number_of_packets; i++) {
2713 if (__put_user(kurb->iso_frame_desc[i].actual_length,
2714 &uurb->iso_frame_desc[i].actual_length) ||
2715 __put_user(kurb->iso_frame_desc[i].status,
2716 &uurb->iso_frame_desc[i].status))
2717 return -EFAULT;
2718 }
2719 }
2720
2721 return 0;
2722}
2723
2724static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
2725 struct usbdevfs_urb32 *uurb)
2726{
2727 unsigned int totlen;
2728 int i;
2729
2730 if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
2731 kurb->number_of_packets = 0;
2732 return 0;
2733 }
2734
2735 if (kurb->number_of_packets < 1 ||
2736 kurb->number_of_packets > 128)
2737 return -EINVAL;
2738
2739 if (copy_from_user(&kurb->iso_frame_desc[0],
2740 &uurb->iso_frame_desc[0],
2741 sizeof(struct usbdevfs_iso_packet_desc) *
2742 kurb->number_of_packets))
2743 return -EFAULT;
2744
2745 totlen = 0;
2746 for (i = 0; i < kurb->number_of_packets; i++) {
2747 unsigned int this_len;
2748
2749 this_len = kurb->iso_frame_desc[i].length;
2750 if (this_len > 1023)
2751 return -EINVAL;
2752
2753 totlen += this_len;
2754 }
2755
2756 if (totlen > 32768)
2757 return -EINVAL;
2758
2759 kurb->buffer_length = totlen;
2760
2761 return 0;
2762}
2763
2764static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
2765{
2766 struct usbdevfs_urb *kurb;
2767 struct usbdevfs_urb32 *uurb;
2768 mm_segment_t old_fs;
2769 __u32 udata;
2770 void *uptr, *kptr;
2771 unsigned int buflen;
2772 int err;
2773
2774 uurb = (struct usbdevfs_urb32 *) arg;
2775
2776 err = -ENOMEM;
2777 kurb = kmalloc(sizeof(struct usbdevfs_urb) +
2778 (sizeof(struct usbdevfs_iso_packet_desc) * 128),
2779 GFP_KERNEL);
2780 if (!kurb)
2781 goto out;
2782
2783 err = -EFAULT;
2784 if (get_urb32(kurb, uurb))
2785 goto out;
2786
2787 err = get_urb32_isoframes(kurb, uurb);
2788 if (err)
2789 goto out;
2790
2791 err = -EFAULT;
2792 if (__get_user(udata, &uurb->buffer))
2793 goto out;
2794 uptr = compat_ptr(udata);
2795
2796 buflen = kurb->buffer_length;
2797 err = verify_area(VERIFY_WRITE, uptr, buflen);
2798 if (err)
2799 goto out;
2800
2801
2802 old_fs = get_fs();
2803 set_fs(KERNEL_DS);
2804 err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
2805 set_fs(old_fs);
2806
2807 if (err >= 0) {
2808
2809 if (put_urb32(kurb, uurb)) {
2810 err = -EFAULT;
2811 }
2812 }
2813
2814out:
2815 kfree(kurb);
2816 return err;
2817}
2818#endif
2819
2820#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
2821#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
2822
2823static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
2824{
2825 mm_segment_t old_fs;
2826 void *kptr;
2827 int err;
2828
2829 old_fs = get_fs();
2830 set_fs(KERNEL_DS);
2831 err = sys_ioctl(fd,
2832 (cmd == USBDEVFS_REAPURB32 ?
2833 USBDEVFS_REAPURB :
2834 USBDEVFS_REAPURBNDELAY),
2835 (unsigned long) &kptr);
2836 set_fs(old_fs);
2837
2838 if (err >= 0 &&
2839 put_user((u32)(u64)kptr, (u32 *)arg))
2840 err = -EFAULT;
2841
2842 return err;
2843}
2844
2845struct usbdevfs_disconnectsignal32 {
2846 compat_int_t signr;
2847 compat_caddr_t context;
2848};
2849
2850#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
2851
2852static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
2853{
2854 struct usbdevfs_disconnectsignal kdis;
2855 struct usbdevfs_disconnectsignal32 *udis;
2856 mm_segment_t old_fs;
2857 u32 uctx;
2858 int err;
2859
2860 udis = (struct usbdevfs_disconnectsignal32 *) arg;
2861
2862 if (get_user(kdis.signr, &udis->signr) ||
2863 __get_user(uctx, &udis->context))
2864 return -EFAULT;
2865
2866 kdis.context = (void *) (long)uctx;
2867
2868 old_fs = get_fs();
2869 set_fs(KERNEL_DS);
2870 err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
2871 set_fs(old_fs);
2872
2873 return err;
2874}
2875
2876
2877
2878
2879
2880struct i2c_msg32 {
2881 u16 addr;
2882 u16 flags;
2883 u16 len;
2884 compat_caddr_t buf;
2885};
2886
2887struct i2c_rdwr_ioctl_data32 {
2888 compat_caddr_t msgs;
2889 u32 nmsgs;
2890};
2891
2892struct i2c_smbus_ioctl_data32 {
2893 u8 read_write;
2894 u8 command;
2895 u32 size;
2896 compat_caddr_t data;
2897};
2898
2899static int do_i2c_rdwr_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
2900{
2901 struct i2c_rdwr_ioctl_data *tdata;
2902 struct i2c_rdwr_ioctl_data32 *udata;
2903 struct i2c_msg *tmsgs;
2904 struct i2c_msg32 *umsgs;
2905 compat_caddr_t datap;
2906 int nmsgs, i;
2907
2908 tdata = compat_alloc_user_space(sizeof(*tdata));
2909 if (tdata == NULL)
2910 return -ENOMEM;
2911 if (verify_area(VERIFY_WRITE, tdata, sizeof(*tdata)))
2912 return -EFAULT;
2913
2914 udata = (struct i2c_rdwr_ioctl_data32 *)compat_ptr(arg);
2915 if (verify_area(VERIFY_READ, udata, sizeof(*udata)))
2916 return -EFAULT;
2917 if (__get_user(nmsgs, &udata->nmsgs) || __put_user(nmsgs, &tdata->nmsgs))
2918 return -EFAULT;
2919 if (nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
2920 return -EINVAL;
2921 if (__get_user(datap, &udata->msgs))
2922 return -EFAULT;
2923 umsgs = (struct i2c_msg32 *)compat_ptr(datap);
2924 if (verify_area(VERIFY_READ, umsgs, sizeof(struct i2c_msg) * nmsgs))
2925 return -EFAULT;
2926
2927 tmsgs = compat_alloc_user_space(sizeof(struct i2c_msg) * nmsgs);
2928 if (tmsgs == NULL)
2929 return -ENOMEM;
2930 if (verify_area(VERIFY_WRITE, tmsgs, sizeof(struct i2c_msg) * nmsgs))
2931 return -EFAULT;
2932 if (__put_user(tmsgs, &tdata->msgs))
2933 return -ENOMEM;
2934 for (i = 0; i < nmsgs; i++) {
2935 if (__copy_in_user(&tmsgs[i].addr,
2936 &umsgs[i].addr,
2937 3 * sizeof(u16)))
2938 return -EFAULT;
2939 if (__get_user(datap, &umsgs[i].buf) ||
2940 __put_user(compat_ptr(datap), &tmsgs[i].buf))
2941 return -EFAULT;
2942 }
2943 return sys_ioctl(fd, cmd, (unsigned long)tdata);
2944}
2945
2946static int do_i2c_smbus_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
2947{
2948 struct i2c_smbus_ioctl_data *tdata;
2949 struct i2c_smbus_ioctl_data32 *udata;
2950 compat_caddr_t datap;
2951
2952 tdata = compat_alloc_user_space(sizeof(*tdata));
2953 if (tdata == NULL)
2954 return -ENOMEM;
2955 if (verify_area(VERIFY_WRITE, tdata, sizeof(*tdata)))
2956 return -EFAULT;
2957
2958 udata = (struct i2c_smbus_ioctl_data32 *)compat_ptr(arg);
2959 if (verify_area(VERIFY_READ, udata, sizeof(*udata)))
2960 return -EFAULT;
2961
2962 if (__copy_in_user(&tdata->read_write, &udata->read_write, 2 * sizeof(u8)))
2963 return -EFAULT;
2964 if (__copy_in_user(&tdata->size, &udata->size, 2 * sizeof(u32)))
2965 return -EFAULT;
2966 if (__get_user(datap, &udata->data) ||
2967 __put_user(compat_ptr(datap), &tdata->data))
2968 return -EFAULT;
2969
2970 return sys_ioctl(fd, cmd, (unsigned long)tdata);
2971}
2972
2973
2974#undef CODE
2975#endif
2976
2977#ifdef DECLARES
2978HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob)
2979HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob)
2980#ifdef CONFIG_NET
2981HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32)
2982#endif
2983HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf)
2984HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc)
2985HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc)
2986HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc)
2987HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc)
2988HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc)
2989HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc)
2990HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc)
2991HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc)
2992HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc)
2993HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc)
2994HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc)
2995HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc)
2996HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc)
2997HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc)
2998HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc)
2999HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc)
3000HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc)
3001HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc)
3002HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc)
3003HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc)
3004HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc)
3005HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc)
3006HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc)
3007HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc)
3008HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc)
3009HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc)
3010HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc)
3011HANDLE_IOCTL(SIOCETHTOOL, ethtool_ioctl)
3012HANDLE_IOCTL(SIOCBONDENSLAVE, bond_ioctl)
3013HANDLE_IOCTL(SIOCBONDRELEASE, bond_ioctl)
3014HANDLE_IOCTL(SIOCBONDSETHWADDR, bond_ioctl)
3015HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY, bond_ioctl)
3016HANDLE_IOCTL(SIOCBONDINFOQUERY, bond_ioctl)
3017HANDLE_IOCTL(SIOCBONDCHANGEACTIVE, bond_ioctl)
3018HANDLE_IOCTL(SIOCADDRT, routing_ioctl)
3019HANDLE_IOCTL(SIOCDELRT, routing_ioctl)
3020
3021HANDLE_IOCTL(SIOCRTMSG, ret_einval)
3022HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp)
3023HANDLE_IOCTL(HDIO_GETGEO, hdio_getgeo)
3024HANDLE_IOCTL(BLKRAGET, w_long)
3025HANDLE_IOCTL(BLKGETSIZE, w_long)
3026HANDLE_IOCTL(0x1260, broken_blkgetsize)
3027HANDLE_IOCTL(BLKFRAGET, w_long)
3028HANDLE_IOCTL(BLKSECTGET, w_long)
3029HANDLE_IOCTL(FBIOGET_FSCREENINFO, fb_ioctl_trans)
3030HANDLE_IOCTL(BLKPG, blkpg_ioctl_trans)
3031HANDLE_IOCTL(FBIOGETCMAP, fb_ioctl_trans)
3032HANDLE_IOCTL(FBIOPUTCMAP, fb_ioctl_trans)
3033HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans)
3034HANDLE_IOCTL(HDIO_GET_UNMASKINTR, hdio_ioctl_trans)
3035HANDLE_IOCTL(HDIO_GET_DMA, hdio_ioctl_trans)
3036HANDLE_IOCTL(HDIO_GET_32BIT, hdio_ioctl_trans)
3037HANDLE_IOCTL(HDIO_GET_MULTCOUNT, hdio_ioctl_trans)
3038HANDLE_IOCTL(HDIO_GET_NOWERR, hdio_ioctl_trans)
3039HANDLE_IOCTL(HDIO_GET_NICE, hdio_ioctl_trans)
3040HANDLE_IOCTL(FDSETPRM32, fd_ioctl_trans)
3041HANDLE_IOCTL(FDDEFPRM32, fd_ioctl_trans)
3042HANDLE_IOCTL(FDGETPRM32, fd_ioctl_trans)
3043HANDLE_IOCTL(FDSETDRVPRM32, fd_ioctl_trans)
3044HANDLE_IOCTL(FDGETDRVPRM32, fd_ioctl_trans)
3045HANDLE_IOCTL(FDGETDRVSTAT32, fd_ioctl_trans)
3046HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans)
3047HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans)
3048HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans)
3049HANDLE_IOCTL(SG_IO,sg_ioctl_trans)
3050HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans)
3051HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans)
3052HANDLE_IOCTL(PPPIOCSPASS32, ppp_sock_fprog_ioctl_trans)
3053HANDLE_IOCTL(PPPIOCSACTIVE32, ppp_sock_fprog_ioctl_trans)
3054HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans)
3055HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans)
3056HANDLE_IOCTL(MTIOCGETCONFIG32, mt_ioctl_trans)
3057HANDLE_IOCTL(MTIOCSETCONFIG32, mt_ioctl_trans)
3058HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans)
3059HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans)
3060HANDLE_IOCTL(LOOP_SET_STATUS, loop_status)
3061HANDLE_IOCTL(LOOP_GET_STATUS, loop_status)
3062#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
3063HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout)
3064#ifdef CONFIG_VT
3065HANDLE_IOCTL(PIO_FONTX, do_fontx_ioctl)
3066HANDLE_IOCTL(GIO_FONTX, do_fontx_ioctl)
3067HANDLE_IOCTL(PIO_UNIMAP, do_unimap_ioctl)
3068HANDLE_IOCTL(GIO_UNIMAP, do_unimap_ioctl)
3069HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl)
3070#endif
3071HANDLE_IOCTL(EXT2_IOC32_GETFLAGS, do_ext2_ioctl)
3072HANDLE_IOCTL(EXT2_IOC32_SETFLAGS, do_ext2_ioctl)
3073HANDLE_IOCTL(EXT2_IOC32_GETVERSION, do_ext2_ioctl)
3074HANDLE_IOCTL(EXT2_IOC32_SETVERSION, do_ext2_ioctl)
3075HANDLE_IOCTL(VIDIOCGTUNER32, do_video_ioctl)
3076HANDLE_IOCTL(VIDIOCSTUNER32, do_video_ioctl)
3077HANDLE_IOCTL(VIDIOCGWIN32, do_video_ioctl)
3078HANDLE_IOCTL(VIDIOCSWIN32, do_video_ioctl)
3079HANDLE_IOCTL(VIDIOCGFBUF32, do_video_ioctl)
3080HANDLE_IOCTL(VIDIOCSFBUF32, do_video_ioctl)
3081HANDLE_IOCTL(VIDIOCGFREQ32, do_video_ioctl)
3082HANDLE_IOCTL(VIDIOCSFREQ32, do_video_ioctl)
3083
3084#define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
3085HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid)
3086HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl)
3087HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl)
3088HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl)
3089HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl)
3090HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl)
3091HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl)
3092HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl)
3093HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl)
3094HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl)
3095HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl)
3096HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl)
3097HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl)
3098HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl)
3099HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl)
3100HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl)
3101HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl)
3102HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl)
3103HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl)
3104HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl)
3105HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl)
3106HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl)
3107HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl)
3108HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl)
3109HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl)
3110HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl)
3111
3112HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget)
3113HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset)
3114HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64)
3115
3116HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32, vfat_ioctl32)
3117HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32, vfat_ioctl32)
3118HANDLE_IOCTL(REISERFS_IOC_UNPACK32, reiserfs_ioctl32)
3119
3120HANDLE_IOCTL(RAW_SETBIND, raw_ioctl)
3121HANDLE_IOCTL(RAW_GETBIND, raw_ioctl)
3122
3123HANDLE_IOCTL(TIOCGSERIAL, serial_struct_ioctl)
3124HANDLE_IOCTL(TIOCSSERIAL, serial_struct_ioctl)
3125
3126HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
3127HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
3128
3129HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb)
3130HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb)
3131HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
3132
3133HANDLE_IOCTL(I2C_FUNCS, w_long)
3134HANDLE_IOCTL(I2C_RDWR, do_i2c_rdwr_ioctl)
3135HANDLE_IOCTL(I2C_SMBUS, do_i2c_smbus_ioctl)
3136
3137#undef DECLARES
3138#endif
3139
