1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/config.h>
24#include <linux/types.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <linux/smp.h>
28#include <linux/smp_lock.h>
29#include <linux/ioctl.h>
30#include <linux/if.h>
31#include <linux/slab.h>
32#include <linux/hdreg.h>
33#include <linux/raid/md.h>
34#include <linux/kd.h>
35#include <linux/route.h>
36#include <linux/in6.h>
37#include <linux/ipv6_route.h>
38#include <linux/skbuff.h>
39#include <linux/netlink.h>
40#include <linux/vt.h>
41#include <linux/fs.h>
42#include <linux/file.h>
43#include <linux/fd.h>
44#include <linux/ppp_defs.h>
45#include <linux/if_ppp.h>
46#include <linux/if_pppox.h>
47#include <linux/if_tun.h>
48#include <linux/mtio.h>
49#include <linux/cdrom.h>
50#include <linux/loop.h>
51#include <linux/auto_fs.h>
52#include <linux/devfs_fs.h>
53#include <linux/tty.h>
54#include <linux/vt_kern.h>
55#include <linux/fb.h>
56#include <linux/ext2_fs.h>
57#include <linux/videodev.h>
58#include <linux/netdevice.h>
59#include <linux/raw.h>
60#include <linux/smb_fs.h>
61#include <linux/blkpg.h>
62#include <linux/blk.h>
63#include <linux/elevator.h>
64#include <linux/rtc.h>
65#include <linux/pci.h>
66#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
67#include <linux/lvm.h>
68#endif
69
70#include <scsi/scsi.h>
71
72#undef __KERNEL__
73#include <scsi/scsi_ioctl.h>
74#define __KERNEL__
75#include <scsi/sg.h>
76
77#include <asm/types.h>
78#include <asm/uaccess.h>
79#include <linux/ethtool.h>
80#include <linux/mii.h>
81#include <linux/if_bonding.h>
82#include <asm/module.h>
83#include <linux/soundcard.h>
84#include <linux/watchdog.h>
85#include <linux/lp.h>
86
87#include <linux/atm.h>
88#include <linux/atmarp.h>
89#include <linux/atmclip.h>
90#include <linux/atmdev.h>
91#include <linux/atmioc.h>
92#include <linux/atmlec.h>
93#include <linux/atmmpc.h>
94#include <linux/atmsvc.h>
95#include <linux/atm_tcp.h>
96#include <linux/sonet.h>
97#include <linux/atm_suni.h>
98#include <linux/mtd/mtd.h>
99
100#include <net/bluetooth/bluetooth.h>
101#include <net/bluetooth/hci.h>
102
103#include <linux/usb.h>
104#include <linux/usbdevice_fs.h>
105#include <linux/nbd.h>
106#include <linux/random.h>
107#include <asm/ppc32.h>
108#include <asm/ppcdebug.h>
109
110
111#define EXT2_IOC32_GETFLAGS _IOR('f', 1, int)
112#define EXT2_IOC32_SETFLAGS _IOW('f', 2, int)
113#define EXT2_IOC32_GETVERSION _IOR('v', 1, int)
114#define EXT2_IOC32_SETVERSION _IOW('v', 2, int)
115
116extern asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
117
118static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
119{
120 mm_segment_t old_fs = get_fs();
121 int err;
122 unsigned long val;
123
124 set_fs (KERNEL_DS);
125 err = sys_ioctl(fd, cmd, (unsigned long)&val);
126 set_fs (old_fs);
127 if (!err && put_user(val, (u32 *)arg))
128 return -EFAULT;
129 return err;
130}
131
132static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
133{
134 mm_segment_t old_fs = get_fs();
135 int err;
136 unsigned long val;
137
138 if (get_user(val, (u32 *)arg))
139 return -EFAULT;
140 set_fs (KERNEL_DS);
141 err = sys_ioctl(fd, cmd, (unsigned long)&val);
142 set_fs (old_fs);
143 if (!err && put_user(val, (u32 *)arg))
144 return -EFAULT;
145 return err;
146}
147
148static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
149{
150
151 switch (cmd) {
152 case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
153 case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
154 case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
155 case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
156 }
157 return sys_ioctl(fd, cmd, arg);
158}
159
160struct video_tuner32 {
161 s32 tuner;
162 u8 name[32];
163 u32 rangelow, rangehigh;
164 u32 flags;
165 u16 mode, signal;
166};
167
168static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
169{
170 int i;
171
172 if (get_user(kp->tuner, &up->tuner))
173 return -EFAULT;
174 for(i = 0; i < 32; i++)
175 __get_user(kp->name[i], &up->name[i]);
176 __get_user(kp->rangelow, &up->rangelow);
177 __get_user(kp->rangehigh, &up->rangehigh);
178 __get_user(kp->flags, &up->flags);
179 __get_user(kp->mode, &up->mode);
180 __get_user(kp->signal, &up->signal);
181 return 0;
182}
183
184static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
185{
186 int i;
187
188 if (put_user(kp->tuner, &up->tuner))
189 return -EFAULT;
190 for(i = 0; i < 32; i++)
191 __put_user(kp->name[i], &up->name[i]);
192 __put_user(kp->rangelow, &up->rangelow);
193 __put_user(kp->rangehigh, &up->rangehigh);
194 __put_user(kp->flags, &up->flags);
195 __put_user(kp->mode, &up->mode);
196 __put_user(kp->signal, &up->signal);
197 return 0;
198}
199
200struct video_buffer32 {
201 u32 base;
202 s32 height, width, depth, bytesperline;
203};
204
205static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
206{
207 u32 tmp;
208
209 if (get_user(tmp, &up->base))
210 return -EFAULT;
211 kp->base = (void *) ((unsigned long)tmp);
212 __get_user(kp->height, &up->height);
213 __get_user(kp->width, &up->width);
214 __get_user(kp->depth, &up->depth);
215 __get_user(kp->bytesperline, &up->bytesperline);
216 return 0;
217}
218
219static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
220{
221 u32 tmp = (u32)((unsigned long)kp->base);
222
223 if (put_user(tmp, &up->base))
224 return -EFAULT;
225 __put_user(kp->height, &up->height);
226 __put_user(kp->width, &up->width);
227 __put_user(kp->depth, &up->depth);
228 __put_user(kp->bytesperline, &up->bytesperline);
229 return 0;
230}
231
232struct video_clip32 {
233 s32 x, y, width, height;
234 u32 next;
235};
236
237struct video_window32 {
238 u32 x, y, width, height, chromakey, flags;
239 u32 clips;
240 s32 clipcount;
241};
242
243static void free_kvideo_clips(struct video_window *kp)
244{
245 struct video_clip *cp;
246
247 cp = kp->clips;
248 if (cp != NULL)
249 kfree(cp);
250}
251
252static int get_video_window32(struct video_window *kp, struct video_window32 *up)
253{
254 struct video_clip32 *ucp;
255 struct video_clip *kcp;
256 int nclips, err, i;
257 u32 tmp;
258
259 if (get_user(kp->x, &up->x))
260 return -EFAULT;
261 __get_user(kp->y, &up->y);
262 __get_user(kp->width, &up->width);
263 __get_user(kp->height, &up->height);
264 __get_user(kp->chromakey, &up->chromakey);
265 __get_user(kp->flags, &up->flags);
266 __get_user(kp->clipcount, &up->clipcount);
267 __get_user(tmp, &up->clips);
268 ucp = (struct video_clip32 *)A(tmp);
269 kp->clips = NULL;
270
271 nclips = kp->clipcount;
272 if (nclips == 0)
273 return 0;
274
275 if (ucp == 0)
276 return -EINVAL;
277
278
279 if (nclips < 0)
280 nclips = VIDEO_CLIPMAP_SIZE;
281
282 kcp = kmalloc(nclips * sizeof(struct video_clip), GFP_KERNEL);
283 err = -ENOMEM;
284 if (kcp == NULL)
285 goto cleanup_and_err;
286
287 kp->clips = kcp;
288 for(i = 0; i < nclips; i++) {
289 __get_user(kcp[i].x, &ucp[i].x);
290 __get_user(kcp[i].y, &ucp[i].y);
291 __get_user(kcp[i].width, &ucp[i].width);
292 __get_user(kcp[i].height, &ucp[i].height);
293 kcp[nclips].next = NULL;
294 }
295
296 return 0;
297
298cleanup_and_err:
299 free_kvideo_clips(kp);
300 return err;
301}
302
303
304static int put_video_window32(struct video_window *kp, struct video_window32 *up)
305{
306 if (put_user(kp->x, &up->x))
307 return -EFAULT;
308 __put_user(kp->y, &up->y);
309 __put_user(kp->width, &up->width);
310 __put_user(kp->height, &up->height);
311 __put_user(kp->chromakey, &up->chromakey);
312 __put_user(kp->flags, &up->flags);
313 __put_user(kp->clipcount, &up->clipcount);
314 return 0;
315}
316
317#define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
318#define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
319#define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
320#define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
321#define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
322#define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
323#define VIDIOCGFREQ32 _IOR('v',14, u32)
324#define VIDIOCSFREQ32 _IOW('v',15, u32)
325
326static int do_video_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
327{
328 union {
329 struct video_tuner vt;
330 struct video_buffer vb;
331 struct video_window vw;
332 unsigned long vx;
333 } karg;
334 mm_segment_t old_fs = get_fs();
335 void *up = (void *)arg;
336 int err = 0;
337
338
339 switch(cmd) {
340 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
341 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
342 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
343 case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
344 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
345 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
346 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
347 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
348 };
349
350 switch(cmd) {
351 case VIDIOCSTUNER:
352 case VIDIOCGTUNER:
353 err = get_video_tuner32(&karg.vt, up);
354 break;
355
356 case VIDIOCSWIN:
357 err = get_video_window32(&karg.vw, up);
358 break;
359
360 case VIDIOCSFBUF:
361 err = get_video_buffer32(&karg.vb, up);
362 break;
363
364 case VIDIOCSFREQ:
365 err = get_user(karg.vx, (u32 *)up);
366 break;
367 };
368 if (err)
369 goto out;
370
371 set_fs(KERNEL_DS);
372 err = sys_ioctl(fd, cmd, (unsigned long)&karg);
373 set_fs(old_fs);
374
375 if (cmd == VIDIOCSWIN)
376 free_kvideo_clips(&karg.vw);
377
378 if (err == 0) {
379 switch(cmd) {
380 case VIDIOCGTUNER:
381 err = put_video_tuner32(&karg.vt, up);
382 break;
383
384 case VIDIOCGWIN:
385 err = put_video_window32(&karg.vw, up);
386 break;
387
388 case VIDIOCGFBUF:
389 err = put_video_buffer32(&karg.vb, up);
390 break;
391
392 case VIDIOCGFREQ:
393 err = put_user(((u32)karg.vx), (u32 *)up);
394 break;
395 };
396 }
397out:
398 return err;
399}
400
401struct timeval32 {
402 int tv_sec;
403 int tv_usec;
404};
405
406static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
407{
408 struct timeval32 *up = (struct timeval32 *)arg;
409 struct timeval ktv;
410 mm_segment_t old_fs = get_fs();
411 int err;
412
413 set_fs(KERNEL_DS);
414 err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
415 set_fs(old_fs);
416 if (!err) {
417 err = put_user(ktv.tv_sec, &up->tv_sec);
418 err |= __put_user(ktv.tv_usec, &up->tv_usec);
419 }
420 return err;
421}
422
423struct ifmap32 {
424 u32 mem_start;
425 u32 mem_end;
426 unsigned short base_addr;
427 unsigned char irq;
428 unsigned char dma;
429 unsigned char port;
430};
431
432struct ifreq32 {
433#define IFHWADDRLEN 6
434#define IFNAMSIZ 16
435 union {
436 char ifrn_name[IFNAMSIZ];
437 } ifr_ifrn;
438 union {
439 struct sockaddr ifru_addr;
440 struct sockaddr ifru_dstaddr;
441 struct sockaddr ifru_broadaddr;
442 struct sockaddr ifru_netmask;
443 struct sockaddr ifru_hwaddr;
444 short ifru_flags;
445 int ifru_ivalue;
446 int ifru_mtu;
447 struct ifmap32 ifru_map;
448 char ifru_slave[IFNAMSIZ];
449 char ifru_newname[IFNAMSIZ];
450 __kernel_caddr_t32 ifru_data;
451 } ifr_ifru;
452};
453
454struct ifconf32 {
455 int ifc_len;
456 __kernel_caddr_t32 ifcbuf;
457};
458
459#ifdef CONFIG_NET
460static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
461{
462 struct net_device *dev;
463 struct ifreq32 ifr32;
464 int err;
465
466 if (copy_from_user(&ifr32, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
467 return -EFAULT;
468
469 dev = dev_get_by_index(ifr32.ifr_ifindex);
470 if (!dev)
471 return -ENODEV;
472
473 strcpy(ifr32.ifr_name, dev->name);
474 dev_put(dev);
475
476 err = copy_to_user((struct ifreq32 *)arg, &ifr32, sizeof(struct ifreq32));
477 return (err ? -EFAULT : 0);
478}
479#endif
480
481static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
482{
483 struct ifconf32 ifc32;
484 struct ifconf ifc;
485 struct ifreq32 *ifr32;
486 struct ifreq *ifr;
487 mm_segment_t old_fs;
488 unsigned int i, j;
489 int err;
490
491 if (copy_from_user(&ifc32, (struct ifconf32 *)arg, sizeof(struct ifconf32)))
492 return -EFAULT;
493
494 if (ifc32.ifcbuf == 0) {
495 ifc32.ifc_len = 0;
496 ifc.ifc_len = 0;
497 ifc.ifc_buf = NULL;
498 } else {
499 ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) *
500 sizeof (struct ifreq);
501 ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
502 if (!ifc.ifc_buf)
503 return -ENOMEM;
504 }
505 ifr = ifc.ifc_req;
506 ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
507 for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
508 if (copy_from_user(ifr++, ifr32++, sizeof (struct ifreq32))) {
509 kfree (ifc.ifc_buf);
510 return -EFAULT;
511 }
512 }
513 old_fs = get_fs(); set_fs (KERNEL_DS);
514 err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
515 set_fs (old_fs);
516 if (!err) {
517 ifr = ifc.ifc_req;
518 ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
519 for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
520 i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
521 if (copy_to_user(ifr32++, ifr++, sizeof (struct ifreq32))) {
522 err = -EFAULT;
523 break;
524 }
525 }
526 if (!err) {
527 if (ifc32.ifcbuf == 0) {
528
529
530
531 i = ifc.ifc_len;
532 i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
533 ifc32.ifc_len = i;
534 } else {
535 if (i <= ifc32.ifc_len)
536 ifc32.ifc_len = i;
537 else
538 ifc32.ifc_len = i - sizeof (struct ifreq32);
539 }
540 if (copy_to_user((struct ifconf32 *)arg, &ifc32, sizeof(struct ifconf32)))
541 err = -EFAULT;
542 }
543 }
544 if (ifc.ifc_buf != NULL)
545 kfree (ifc.ifc_buf);
546 return err;
547}
548
549static int ethtool_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
550{
551 struct ifreq ifr;
552 mm_segment_t old_fs;
553 int err, len;
554 u32 data, ethcmd;
555
556 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
557 return -EFAULT;
558 ifr.ifr_data = (__kernel_caddr_t)get_free_page(GFP_KERNEL);
559 if (!ifr.ifr_data)
560 return -EAGAIN;
561
562 __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
563
564 if (get_user(ethcmd, (u32 *)A(data))) {
565 err = -EFAULT;
566 goto out;
567 }
568 switch (ethcmd) {
569 case ETHTOOL_GSTRINGS: {
570 struct ethtool_gstrings *stringsaddr = (struct ethtool_gstrings *)A(data);
571 if (get_user(len, (u32 *)&stringsaddr->len)) {
572 err = -EFAULT;
573 goto out;
574 }
575 if (len > (PAGE_SIZE - sizeof(struct ethtool_gstrings))/ETH_GSTRING_LEN ) {
576 err = -EINVAL;
577 goto out;
578 }
579 len = (len*ETH_GSTRING_LEN) + sizeof(struct ethtool_gstrings);
580 break;
581 }
582 case ETHTOOL_GSTATS: {
583 struct ethtool_stats *statsaddr = (struct ethtool_stats *)A(data);
584 if (get_user(len, (u32 *)&statsaddr->n_stats)) {
585 err = -EFAULT;
586 goto out;
587 }
588 if (len > (PAGE_SIZE - sizeof(struct ethtool_stats))/sizeof(u64) ) {
589 err = -EINVAL;
590 goto out;
591 }
592 len = (len*sizeof(u64)) + sizeof(struct ethtool_stats);
593 break;
594 }
595 case ETHTOOL_SWOL:
596 case ETHTOOL_GWOL:
597 len = sizeof(struct ethtool_wolinfo);
598 break;
599 case ETHTOOL_GDRVINFO:
600 len = sizeof(struct ethtool_drvinfo);
601 break;
602 case ETHTOOL_GMSGLVL:
603 case ETHTOOL_SMSGLVL:
604 case ETHTOOL_GLINK:
605 case ETHTOOL_NWAY_RST:
606 case ETHTOOL_SSG:
607 case ETHTOOL_GSG:
608 case ETHTOOL_GTXCSUM:
609 case ETHTOOL_STXCSUM:
610 case ETHTOOL_GRXCSUM:
611 case ETHTOOL_SRXCSUM:
612 case ETHTOOL_PHYS_ID:
613 len = sizeof(struct ethtool_value);
614 break;
615 case ETHTOOL_GREGS: {
616 struct ethtool_regs *regaddr = (struct ethtool_regs *)A(data);
617
618 if (get_user(len, (u32 *)®addr->len)) {
619 err = -EFAULT;
620 goto out;
621 }
622 if (len > PAGE_SIZE - sizeof(struct ethtool_regs)) {
623 err = -EINVAL;
624 goto out;
625 }
626 len += sizeof(struct ethtool_regs);
627 break;
628 }
629 case ETHTOOL_GEEPROM:
630 case ETHTOOL_SEEPROM: {
631 struct ethtool_eeprom *promaddr = (struct ethtool_eeprom *)A(data);
632
633 if (get_user(len, (u32 *)&promaddr->len)) {
634 err = -EFAULT;
635 goto out;
636 }
637 if (len > PAGE_SIZE - sizeof(struct ethtool_eeprom)) {
638 err = -EINVAL;
639 goto out;
640 }
641 len += sizeof(struct ethtool_eeprom);
642 break;
643 }
644 case ETHTOOL_GRINGPARAM:
645 case ETHTOOL_SRINGPARAM:
646 len = sizeof(struct ethtool_ringparam);
647 break;
648 case ETHTOOL_GPAUSEPARAM:
649 case ETHTOOL_SPAUSEPARAM:
650 len = sizeof(struct ethtool_pauseparam);
651 break;
652 case ETHTOOL_GCOALESCE:
653 case ETHTOOL_SCOALESCE:
654 len = sizeof(struct ethtool_coalesce);
655 break;
656 case ETHTOOL_GSET:
657 case ETHTOOL_SSET:
658 len = sizeof(struct ethtool_cmd);
659 break;
660 default:
661 err = -EOPNOTSUPP;
662 goto out;
663 }
664
665 if (copy_from_user(ifr.ifr_data, (char *)A(data), len)) {
666 err = -EFAULT;
667 goto out;
668 }
669
670 old_fs = get_fs();
671 set_fs (KERNEL_DS);
672 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
673 set_fs (old_fs);
674 if (!err) {
675 u32 data;
676
677 __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
678 len = copy_to_user((char *)A(data), ifr.ifr_data, len);
679 if (len)
680 err = -EFAULT;
681 }
682
683out:
684 free_page((unsigned long)ifr.ifr_data);
685 return err;
686}
687
688static int bond_ioctl(unsigned long fd, unsigned int cmd, unsigned long arg)
689{
690 struct ifreq ifr;
691 mm_segment_t old_fs;
692 int err, len;
693 u32 data;
694
695 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
696 return -EFAULT;
697 ifr.ifr_data = (__kernel_caddr_t)get_free_page(GFP_KERNEL);
698 if (!ifr.ifr_data)
699 return -EAGAIN;
700
701 switch (cmd) {
702 case SIOCBONDENSLAVE:
703 case SIOCBONDRELEASE:
704 case SIOCBONDSETHWADDR:
705 case SIOCBONDCHANGEACTIVE:
706 len = IFNAMSIZ * sizeof(char);
707 break;
708 case SIOCBONDSLAVEINFOQUERY:
709 len = sizeof(struct ifslave);
710 break;
711 case SIOCBONDINFOQUERY:
712 len = sizeof(struct ifbond);
713 break;
714 default:
715 err = -EINVAL;
716 goto out;
717 };
718
719 __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
720 if (copy_from_user(ifr.ifr_data, (char *)A(data), len)) {
721 err = -EFAULT;
722 goto out;
723 }
724
725 old_fs = get_fs();
726 set_fs (KERNEL_DS);
727 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
728 set_fs (old_fs);
729 if (!err) {
730 len = copy_to_user((char *)A(data), ifr.ifr_data, len);
731 if (len)
732 err = -EFAULT;
733 }
734
735out:
736 free_page((unsigned long)ifr.ifr_data);
737 return err;
738}
739
740static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
741{
742 struct ifreq ifr;
743 mm_segment_t old_fs;
744 int err;
745
746 switch (cmd) {
747 case SIOCSIFMAP:
748 err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
749 err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
750 err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
751 err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
752 err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
753 err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
754 err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
755 if (err)
756 return -EFAULT;
757 break;
758 default:
759 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
760 return -EFAULT;
761 break;
762 }
763 old_fs = get_fs();
764 set_fs (KERNEL_DS);
765 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
766 set_fs (old_fs);
767 if (!err) {
768 switch (cmd) {
769 case SIOCGIFFLAGS:
770 case SIOCGIFMETRIC:
771 case SIOCGIFMTU:
772 case SIOCGIFMEM:
773 case SIOCGIFHWADDR:
774 case SIOCGIFINDEX:
775 case SIOCGIFADDR:
776 case SIOCGIFBRDADDR:
777 case SIOCGIFDSTADDR:
778 case SIOCGIFNETMASK:
779 case SIOCGIFTXQLEN:
780 if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
781 return -EFAULT;
782 break;
783 case SIOCGIFMAP:
784 err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
785 err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
786 err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
787 err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
788 err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
789 err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
790 err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
791 if (err)
792 err = -EFAULT;
793 break;
794 }
795 }
796 return err;
797}
798
799struct rtentry32 {
800 u32 rt_pad1;
801 struct sockaddr rt_dst;
802 struct sockaddr rt_gateway;
803 struct sockaddr rt_genmask;
804 unsigned short rt_flags;
805 short rt_pad2;
806 u32 rt_pad3;
807 unsigned char rt_tos;
808 unsigned char rt_class;
809 short rt_pad4;
810 short rt_metric;
811 u32 rt_dev;
812 u32 rt_mtu;
813 u32 rt_window;
814 unsigned short rt_irtt;
815
816};
817
818struct in6_rtmsg32 {
819 struct in6_addr rtmsg_dst;
820 struct in6_addr rtmsg_src;
821 struct in6_addr rtmsg_gateway;
822 u32 rtmsg_type;
823 u16 rtmsg_dst_len;
824 u16 rtmsg_src_len;
825 u32 rtmsg_metric;
826 u32 rtmsg_info;
827 u32 rtmsg_flags;
828 s32 rtmsg_ifindex;
829};
830
831extern struct socket *sockfd_lookup(int fd, int *err);
832
833extern __inline__ void sockfd_put(struct socket *sock)
834{
835 fput(sock->file);
836}
837
838static int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
839{
840 int ret;
841 void *r = NULL;
842 struct in6_rtmsg r6;
843 struct rtentry r4;
844 char devname[16];
845 u32 rtdev;
846 mm_segment_t old_fs = get_fs();
847
848 struct socket *mysock = sockfd_lookup(fd, &ret);
849
850 if (mysock && mysock->sk && mysock->sk->family == AF_INET6) {
851 ret = copy_from_user (&r6.rtmsg_dst, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst),
852 3 * sizeof(struct in6_addr));
853 ret |= __get_user (r6.rtmsg_type, &(((struct in6_rtmsg32 *)arg)->rtmsg_type));
854 ret |= __get_user (r6.rtmsg_dst_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst_len));
855 ret |= __get_user (r6.rtmsg_src_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_src_len));
856 ret |= __get_user (r6.rtmsg_metric, &(((struct in6_rtmsg32 *)arg)->rtmsg_metric));
857 ret |= __get_user (r6.rtmsg_info, &(((struct in6_rtmsg32 *)arg)->rtmsg_info));
858 ret |= __get_user (r6.rtmsg_flags, &(((struct in6_rtmsg32 *)arg)->rtmsg_flags));
859 ret |= __get_user (r6.rtmsg_ifindex, &(((struct in6_rtmsg32 *)arg)->rtmsg_ifindex));
860
861 r = (void *) &r6;
862 } else {
863 ret = copy_from_user (&r4.rt_dst, &(((struct rtentry32 *)arg)->rt_dst), 3 * sizeof(struct sockaddr));
864 ret |= __get_user (r4.rt_flags, &(((struct rtentry32 *)arg)->rt_flags));
865 ret |= __get_user (r4.rt_metric, &(((struct rtentry32 *)arg)->rt_metric));
866 ret |= __get_user (r4.rt_mtu, &(((struct rtentry32 *)arg)->rt_mtu));
867 ret |= __get_user (r4.rt_window, &(((struct rtentry32 *)arg)->rt_window));
868 ret |= __get_user (r4.rt_irtt, &(((struct rtentry32 *)arg)->rt_irtt));
869 ret |= __get_user (rtdev, &(((struct rtentry32 *)arg)->rt_dev));
870 if (rtdev) {
871 ret |= copy_from_user (devname, (char *)A(rtdev), 15);
872 r4.rt_dev = devname; devname[15] = 0;
873 } else
874 r4.rt_dev = 0;
875
876 r = (void *) &r4;
877 }
878
879 if (ret)
880 return -EFAULT;
881
882 set_fs (KERNEL_DS);
883 ret = sys_ioctl (fd, cmd, (long) r);
884 set_fs (old_fs);
885
886 if (mysock)
887 sockfd_put(mysock);
888
889 return ret;
890}
891
892struct hd_geometry32 {
893 unsigned char heads;
894 unsigned char sectors;
895 unsigned short cylinders;
896 u32 start;
897};
898
899static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
900{
901 mm_segment_t old_fs = get_fs();
902 struct hd_geometry geo;
903 int err;
904
905 set_fs (KERNEL_DS);
906 err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
907 set_fs (old_fs);
908 if (!err) {
909 err = copy_to_user ((struct hd_geometry32 *)arg, &geo, 4);
910 err |= __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start));
911 }
912 return err ? -EFAULT : 0;
913}
914
915struct hd_big_geometry32 {
916 u8 heads;
917 u8 sectors;
918 u32 cylinders;
919 u32 start;
920};
921
922static int hdio_getgeo_big(unsigned int fd, unsigned int cmd, unsigned long arg)
923{
924 mm_segment_t old_fs = get_fs();
925 struct hd_big_geometry geo;
926 int err;
927
928 set_fs (KERNEL_DS);
929 err = sys_ioctl(fd, HDIO_GETGEO_BIG, (unsigned long)&geo);
930 set_fs (old_fs);
931 if (err)
932 return err;
933 else {
934 struct hd_big_geometry32 *user_geo = (struct hd_big_geometry32 *)arg;
935 err = __put_user (geo.heads, &(user_geo->heads));
936 err |= __put_user (geo.sectors, &(user_geo->sectors));
937 err |= __put_user (geo.cylinders, &(user_geo->cylinders));
938 err |= __put_user (geo.start, &(user_geo->start));
939 }
940 return err ? -EFAULT : 0;
941}
942
943
944static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
945{
946 mm_segment_t old_fs = get_fs();
947 unsigned long kval;
948 unsigned int *uvp;
949 int error;
950
951 set_fs(KERNEL_DS);
952 error = sys_ioctl(fd, cmd, (long)&kval);
953 set_fs(old_fs);
954
955 if (error == 0) {
956 uvp = (unsigned int *)arg;
957 if (put_user(kval, uvp))
958 error = -EFAULT;
959 }
960 return error;
961}
962
963struct floppy_struct32 {
964 unsigned int size;
965 unsigned int sect;
966 unsigned int head;
967 unsigned int track;
968 unsigned int stretch;
969 unsigned char gap;
970 unsigned char rate;
971 unsigned char spec1;
972 unsigned char fmt_gap;
973 const __kernel_caddr_t32 name;
974};
975
976struct floppy_drive_params32 {
977 char cmos;
978 u32 max_dtr;
979 u32 hlt;
980 u32 hut;
981 u32 srt;
982 u32 spinup;
983 u32 spindown;
984 unsigned char spindown_offset;
985 unsigned char select_delay;
986 unsigned char rps;
987 unsigned char tracks;
988 u32 timeout;
989 unsigned char interleave_sect;
990 struct floppy_max_errors max_errors;
991 char flags;
992 char read_track;
993 short autodetect[8];
994 int checkfreq;
995 int native_format;
996};
997
998struct floppy_drive_struct32 {
999 signed char flags;
1000 u32 spinup_date;
1001 u32 select_date;
1002 u32 first_read_date;
1003 short probed_format;
1004 short track;
1005 short maxblock;
1006 short maxtrack;
1007 int generation;
1008 int keep_data;
1009 int fd_ref;
1010 int fd_device;
1011 int last_checked;
1012 __kernel_caddr_t32 dmabuf;
1013 int bufblocks;
1014};
1015
1016struct floppy_fdc_state32 {
1017 int spec1;
1018 int spec2;
1019 int dtr;
1020 unsigned char version;
1021 unsigned char dor;
1022 u32 address;
1023 unsigned int rawcmd:2;
1024 unsigned int reset:1;
1025 unsigned int need_configure:1;
1026 unsigned int perp_mode:2;
1027 unsigned int has_fifo:1;
1028 unsigned int driver_version;
1029 unsigned char track[4];
1030};
1031
1032struct floppy_write_errors32 {
1033 unsigned int write_errors;
1034 u32 first_error_sector;
1035 int first_error_generation;
1036 u32 last_error_sector;
1037 int last_error_generation;
1038 unsigned int badness;
1039};
1040
1041#define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
1042#define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
1043#define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
1044#define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
1045#define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
1046#define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
1047#define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
1048#define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
1049#define FDWERRORGET32 _IOR(2, 0x17, struct floppy_write_errors32)
1050
1051static struct {
1052 unsigned int cmd32;
1053 unsigned int cmd;
1054} fd_ioctl_trans_table[] = {
1055 { FDSETPRM32, FDSETPRM },
1056 { FDDEFPRM32, FDDEFPRM },
1057 { FDGETPRM32, FDGETPRM },
1058 { FDSETDRVPRM32, FDSETDRVPRM },
1059 { FDGETDRVPRM32, FDGETDRVPRM },
1060 { FDGETDRVSTAT32, FDGETDRVSTAT },
1061 { FDPOLLDRVSTAT32, FDPOLLDRVSTAT },
1062 { FDGETFDCSTAT32, FDGETFDCSTAT },
1063 { FDWERRORGET32, FDWERRORGET }
1064};
1065
1066#define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
1067
1068static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1069{
1070 mm_segment_t old_fs = get_fs();
1071 void *karg = NULL;
1072 unsigned int kcmd = 0;
1073 int i, err;
1074
1075 for (i = 0; i < NR_FD_IOCTL_TRANS; i++)
1076 if (cmd == fd_ioctl_trans_table[i].cmd32) {
1077 kcmd = fd_ioctl_trans_table[i].cmd;
1078 break;
1079 }
1080 if (!kcmd)
1081 return -EINVAL;
1082
1083 switch (cmd) {
1084 case FDSETPRM32:
1085 case FDDEFPRM32:
1086 case FDGETPRM32:
1087 {
1088 struct floppy_struct *f;
1089
1090 f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
1091 if (!karg)
1092 return -ENOMEM;
1093 if (cmd == FDGETPRM32)
1094 break;
1095 err = __get_user(f->size, &((struct floppy_struct32 *)arg)->size);
1096 err |= __get_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
1097 err |= __get_user(f->head, &((struct floppy_struct32 *)arg)->head);
1098 err |= __get_user(f->track, &((struct floppy_struct32 *)arg)->track);
1099 err |= __get_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
1100 err |= __get_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
1101 err |= __get_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
1102 err |= __get_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
1103 err |= __get_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
1104 err |= __get_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
1105 if (err) {
1106 err = -EFAULT;
1107 goto out;
1108 }
1109 break;
1110 }
1111 case FDSETDRVPRM32:
1112 case FDGETDRVPRM32:
1113 {
1114 struct floppy_drive_params *f;
1115
1116 f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
1117 if (!karg)
1118 return -ENOMEM;
1119 if (cmd == FDGETDRVPRM32)
1120 break;
1121 err = __get_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
1122 err |= __get_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
1123 err |= __get_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
1124 err |= __get_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
1125 err |= __get_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
1126 err |= __get_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
1127 err |= __get_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
1128 err |= __get_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
1129 err |= __get_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
1130 err |= __get_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
1131 err |= __get_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
1132 err |= __get_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
1133 err |= __get_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
1134 err |= __copy_from_user(&f->max_errors, &((struct floppy_drive_params32 *)arg)->max_errors, sizeof(f->max_errors));
1135 err |= __get_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
1136 err |= __get_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
1137 err |= __copy_from_user(f->autodetect, ((struct floppy_drive_params32 *)arg)->autodetect, sizeof(f->autodetect));
1138 err |= __get_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
1139 err |= __get_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
1140 if (err) {
1141 err = -EFAULT;
1142 goto out;
1143 }
1144 break;
1145 }
1146 case FDGETDRVSTAT32:
1147 case FDPOLLDRVSTAT32:
1148 karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
1149 if (!karg)
1150 return -ENOMEM;
1151 break;
1152 case FDGETFDCSTAT32:
1153 karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
1154 if (!karg)
1155 return -ENOMEM;
1156 break;
1157 case FDWERRORGET32:
1158 karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
1159 if (!karg)
1160 return -ENOMEM;
1161 break;
1162 default:
1163 return -EINVAL;
1164 }
1165 set_fs (KERNEL_DS);
1166 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1167 set_fs (old_fs);
1168 if (err)
1169 goto out;
1170 switch (cmd) {
1171 case FDGETPRM32:
1172 {
1173 struct floppy_struct *f = karg;
1174
1175 err = __put_user(f->size, &((struct floppy_struct32 *)arg)->size);
1176 err |= __put_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
1177 err |= __put_user(f->head, &((struct floppy_struct32 *)arg)->head);
1178 err |= __put_user(f->track, &((struct floppy_struct32 *)arg)->track);
1179 err |= __put_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
1180 err |= __put_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
1181 err |= __put_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
1182 err |= __put_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
1183 err |= __put_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
1184 err |= __put_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
1185 break;
1186 }
1187 case FDGETDRVPRM32:
1188 {
1189 struct floppy_drive_params *f = karg;
1190
1191 err = __put_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
1192 err |= __put_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
1193 err |= __put_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
1194 err |= __put_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
1195 err |= __put_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
1196 err |= __put_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
1197 err |= __put_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
1198 err |= __put_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
1199 err |= __put_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
1200 err |= __put_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
1201 err |= __put_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
1202 err |= __put_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
1203 err |= __put_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
1204 err |= __copy_to_user(&((struct floppy_drive_params32 *)arg)->max_errors, &f->max_errors, sizeof(f->max_errors));
1205 err |= __put_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
1206 err |= __put_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
1207 err |= __copy_to_user(((struct floppy_drive_params32 *)arg)->autodetect, f->autodetect, sizeof(f->autodetect));
1208 err |= __put_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
1209 err |= __put_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
1210 break;
1211 }
1212 case FDGETDRVSTAT32:
1213 case FDPOLLDRVSTAT32:
1214 {
1215 struct floppy_drive_struct *f = karg;
1216
1217 err = __put_user(f->flags, &((struct floppy_drive_struct32 *)arg)->flags);
1218 err |= __put_user(f->spinup_date, &((struct floppy_drive_struct32 *)arg)->spinup_date);
1219 err |= __put_user(f->select_date, &((struct floppy_drive_struct32 *)arg)->select_date);
1220 err |= __put_user(f->first_read_date, &((struct floppy_drive_struct32 *)arg)->first_read_date);
1221 err |= __put_user(f->probed_format, &((struct floppy_drive_struct32 *)arg)->probed_format);
1222 err |= __put_user(f->track, &((struct floppy_drive_struct32 *)arg)->track);
1223 err |= __put_user(f->maxblock, &((struct floppy_drive_struct32 *)arg)->maxblock);
1224 err |= __put_user(f->maxtrack, &((struct floppy_drive_struct32 *)arg)->maxtrack);
1225 err |= __put_user(f->generation, &((struct floppy_drive_struct32 *)arg)->generation);
1226 err |= __put_user(f->keep_data, &((struct floppy_drive_struct32 *)arg)->keep_data);
1227 err |= __put_user(f->fd_ref, &((struct floppy_drive_struct32 *)arg)->fd_ref);
1228 err |= __put_user(f->fd_device, &((struct floppy_drive_struct32 *)arg)->fd_device);
1229 err |= __put_user(f->last_checked, &((struct floppy_drive_struct32 *)arg)->last_checked);
1230 err |= __put_user((u64)f->dmabuf, &((struct floppy_drive_struct32 *)arg)->dmabuf);
1231 err |= __put_user((u64)f->bufblocks, &((struct floppy_drive_struct32 *)arg)->bufblocks);
1232 break;
1233 }
1234 case FDGETFDCSTAT32:
1235 {
1236 struct floppy_fdc_state *f = karg;
1237
1238 err = __put_user(f->spec1, &((struct floppy_fdc_state32 *)arg)->spec1);
1239 err |= __put_user(f->spec2, &((struct floppy_fdc_state32 *)arg)->spec2);
1240 err |= __put_user(f->dtr, &((struct floppy_fdc_state32 *)arg)->dtr);
1241 err |= __put_user(f->version, &((struct floppy_fdc_state32 *)arg)->version);
1242 err |= __put_user(f->dor, &((struct floppy_fdc_state32 *)arg)->dor);
1243 err |= __put_user(f->address, &((struct floppy_fdc_state32 *)arg)->address);
1244 err |= __copy_to_user((char *)&((struct floppy_fdc_state32 *)arg)->address
1245 + sizeof(((struct floppy_fdc_state32 *)arg)->address),
1246 (char *)&f->address + sizeof(f->address), sizeof(int));
1247 err |= __put_user(f->driver_version, &((struct floppy_fdc_state32 *)arg)->driver_version);
1248 err |= __copy_to_user(((struct floppy_fdc_state32 *)arg)->track, f->track, sizeof(f->track));
1249 break;
1250 }
1251 case FDWERRORGET32:
1252 {
1253 struct floppy_write_errors *f = karg;
1254
1255 err = __put_user(f->write_errors, &((struct floppy_write_errors32 *)arg)->write_errors);
1256 err |= __put_user(f->first_error_sector, &((struct floppy_write_errors32 *)arg)->first_error_sector);
1257 err |= __put_user(f->first_error_generation, &((struct floppy_write_errors32 *)arg)->first_error_generation);
1258 err |= __put_user(f->last_error_sector, &((struct floppy_write_errors32 *)arg)->last_error_sector);
1259 err |= __put_user(f->last_error_generation, &((struct floppy_write_errors32 *)arg)->last_error_generation);
1260 err |= __put_user(f->badness, &((struct floppy_write_errors32 *)arg)->badness);
1261 break;
1262 }
1263 default:
1264 break;
1265 }
1266 if (err)
1267 err = -EFAULT;
1268
1269out: if (karg) kfree(karg);
1270 return err;
1271}
1272
1273typedef struct sg_io_hdr32 {
1274 s32 interface_id;
1275 s32 dxfer_direction;
1276 u8 cmd_len;
1277 u8 mx_sb_len;
1278 u16 iovec_count;
1279 u32 dxfer_len;
1280 u32 dxferp;
1281
1282 u32 cmdp;
1283 u32 sbp;
1284 u32 timeout;
1285 u32 flags;
1286 s32 pack_id;
1287 u32 usr_ptr;
1288 u8 status;
1289 u8 masked_status;
1290 u8 msg_status;
1291 u8 sb_len_wr;
1292 u16 host_status;
1293 u16 driver_status;
1294 s32 resid;
1295 u32 duration;
1296 u32 info;
1297} sg_io_hdr32_t;
1298
1299typedef struct sg_iovec32 {
1300 u32 iov_base;
1301 u32 iov_len;
1302} sg_iovec32_t;
1303
1304#define EMU_SG_MAX 128
1305
1306static int alloc_sg_iovec(sg_io_hdr_t *sgp, u32 uptr32)
1307{
1308 sg_iovec32_t *uiov = (sg_iovec32_t *) A(uptr32);
1309 sg_iovec_t *kiov;
1310 int i;
1311
1312 if (sgp->iovec_count > EMU_SG_MAX)
1313 return -EINVAL;
1314 sgp->dxferp = kmalloc(sgp->iovec_count *
1315 sizeof(sg_iovec_t), GFP_KERNEL);
1316 if (!sgp->dxferp)
1317 return -ENOMEM;
1318 memset(sgp->dxferp, 0,
1319 sgp->iovec_count * sizeof(sg_iovec_t));
1320
1321 kiov = (sg_iovec_t *) sgp->dxferp;
1322 for (i = 0; i < sgp->iovec_count; i++) {
1323 u32 iov_base32;
1324 if (__get_user(iov_base32, &uiov->iov_base) ||
1325 __get_user(kiov->iov_len, &uiov->iov_len))
1326 return -EFAULT;
1327 if (verify_area(VERIFY_WRITE, (void *)A(iov_base32), kiov->iov_len))
1328 return -EFAULT;
1329 kiov->iov_base = (void *)A(iov_base32);
1330 uiov++;
1331 kiov++;
1332 }
1333
1334 return 0;
1335}
1336
1337static void free_sg_iovec(sg_io_hdr_t *sgp)
1338{
1339 kfree(sgp->dxferp);
1340 sgp->dxferp = NULL;
1341}
1342
1343static int sg_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1344{
1345 sg_io_hdr32_t *sg_io32;
1346 sg_io_hdr_t sg_io64;
1347 u32 dxferp32, cmdp32, sbp32;
1348 mm_segment_t old_fs;
1349 int err = 0;
1350
1351 sg_io32 = (sg_io_hdr32_t *)arg;
1352 err = __get_user(sg_io64.interface_id, &sg_io32->interface_id);
1353 err |= __get_user(sg_io64.dxfer_direction, &sg_io32->dxfer_direction);
1354 err |= __get_user(sg_io64.cmd_len, &sg_io32->cmd_len);
1355 err |= __get_user(sg_io64.mx_sb_len, &sg_io32->mx_sb_len);
1356 err |= __get_user(sg_io64.iovec_count, &sg_io32->iovec_count);
1357 err |= __get_user(sg_io64.dxfer_len, &sg_io32->dxfer_len);
1358 err |= __get_user(sg_io64.timeout, &sg_io32->timeout);
1359 err |= __get_user(sg_io64.flags, &sg_io32->flags);
1360 err |= __get_user(sg_io64.pack_id, &sg_io32->pack_id);
1361
1362 sg_io64.dxferp = NULL;
1363 sg_io64.cmdp = NULL;
1364 sg_io64.sbp = NULL;
1365
1366 err |= __get_user(cmdp32, &sg_io32->cmdp);
1367 if (sg_io64.cmd_len > 4*PAGE_SIZE || sg_io64.mx_sb_len > 4*PAGE_SIZE) {
1368 err = -EINVAL;
1369 goto out;
1370 }
1371 sg_io64.cmdp = kmalloc(sg_io64.cmd_len, GFP_KERNEL);
1372 if (!sg_io64.cmdp) {
1373 err = -ENOMEM;
1374 goto out;
1375 }
1376 if (copy_from_user(sg_io64.cmdp,
1377 (void *) A(cmdp32),
1378 sg_io64.cmd_len)) {
1379 err = -EFAULT;
1380 goto out;
1381 }
1382
1383 err |= __get_user(sbp32, &sg_io32->sbp);
1384 sg_io64.sbp = kmalloc(sg_io64.mx_sb_len, GFP_KERNEL);
1385 if (!sg_io64.sbp) {
1386 err = -ENOMEM;
1387 goto out;
1388 }
1389 if (copy_from_user(sg_io64.sbp,
1390 (void *) A(sbp32),
1391 sg_io64.mx_sb_len)) {
1392 err = -EFAULT;
1393 goto out;
1394 }
1395
1396 err |= __get_user(dxferp32, &sg_io32->dxferp);
1397 if (sg_io64.iovec_count) {
1398 int ret;
1399
1400 if ((ret = alloc_sg_iovec(&sg_io64, dxferp32))) {
1401 err = ret;
1402 goto out;
1403 }
1404 } else {
1405 if (sg_io64.dxfer_len > 4*PAGE_SIZE) {
1406 err = -EINVAL;
1407 goto out;
1408 }
1409 sg_io64.dxferp = kmalloc(sg_io64.dxfer_len, GFP_KERNEL);
1410 if (!sg_io64.dxferp) {
1411 err = -ENOMEM;
1412 goto out;
1413 }
1414 if (copy_from_user(sg_io64.dxferp,
1415 (void *) A(dxferp32),
1416 sg_io64.dxfer_len)) {
1417 err = -EFAULT;
1418 goto out;
1419 }
1420 }
1421
1422
1423 sg_io64.usr_ptr = NULL;
1424
1425 if (err)
1426 return -EFAULT;
1427
1428 old_fs = get_fs();
1429 set_fs (KERNEL_DS);
1430 err = sys_ioctl (fd, cmd, (unsigned long) &sg_io64);
1431 set_fs (old_fs);
1432
1433 if (err < 0)
1434 goto out;
1435
1436 err = __put_user(sg_io64.pack_id, &sg_io32->pack_id);
1437 err |= __put_user(sg_io64.status, &sg_io32->status);
1438 err |= __put_user(sg_io64.masked_status, &sg_io32->masked_status);
1439 err |= __put_user(sg_io64.msg_status, &sg_io32->msg_status);
1440 err |= __put_user(sg_io64.sb_len_wr, &sg_io32->sb_len_wr);
1441 err |= __put_user(sg_io64.host_status, &sg_io32->host_status);
1442 err |= __put_user(sg_io64.driver_status, &sg_io32->driver_status);
1443 err |= __put_user(sg_io64.resid, &sg_io32->resid);
1444 err |= __put_user(sg_io64.duration, &sg_io32->duration);
1445 err |= __put_user(sg_io64.info, &sg_io32->info);
1446 err |= copy_to_user((void *)A(sbp32), sg_io64.sbp, sg_io64.mx_sb_len);
1447 if (sg_io64.dxferp) {
1448 if (sg_io64.iovec_count)
1449 ;
1450 else
1451 err |= copy_to_user((void *)A(dxferp32),
1452 sg_io64.dxferp,
1453 sg_io64.dxfer_len);
1454 }
1455 if (err)
1456 err = -EFAULT;
1457
1458out:
1459 if (sg_io64.cmdp)
1460 kfree(sg_io64.cmdp);
1461 if (sg_io64.sbp)
1462 kfree(sg_io64.sbp);
1463 if (sg_io64.dxferp) {
1464 if (sg_io64.iovec_count) {
1465 free_sg_iovec(&sg_io64);
1466 } else {
1467 kfree(sg_io64.dxferp);
1468 }
1469 }
1470 return err;
1471}
1472
1473struct ppp_option_data32 {
1474 __kernel_caddr_t32 ptr;
1475 __u32 length;
1476 int transmit;
1477};
1478#define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
1479
1480struct ppp_idle32 {
1481 __kernel_time_t32 xmit_idle;
1482 __kernel_time_t32 recv_idle;
1483};
1484#define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
1485
1486static int ppp_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1487{
1488 mm_segment_t old_fs = get_fs();
1489 struct ppp_option_data32 data32;
1490 struct ppp_option_data data;
1491 struct ppp_idle32 idle32;
1492 struct ppp_idle idle;
1493 unsigned int kcmd;
1494 void *karg;
1495 int err = 0;
1496
1497 switch (cmd) {
1498 case PPPIOCGIDLE32:
1499 kcmd = PPPIOCGIDLE;
1500 karg = &idle;
1501 break;
1502 case PPPIOCSCOMPRESS32:
1503 if (copy_from_user(&data32, (struct ppp_option_data32 *)arg, sizeof(struct ppp_option_data32)))
1504 return -EFAULT;
1505 if (data32.length > PAGE_SIZE)
1506 return -EINVAL;
1507 data.ptr = kmalloc (data32.length, GFP_KERNEL);
1508 if (!data.ptr)
1509 return -ENOMEM;
1510 if (copy_from_user(data.ptr, (__u8 *)A(data32.ptr), data32.length)) {
1511 kfree(data.ptr);
1512 return -EFAULT;
1513 }
1514 data.length = data32.length;
1515 data.transmit = data32.transmit;
1516 kcmd = PPPIOCSCOMPRESS;
1517 karg = &data;
1518 break;
1519 default:
1520 do {
1521 static int count = 0;
1522 if (++count <= 20)
1523 printk("ppp_ioctl: Unknown cmd fd(%d) "
1524 "cmd(%08x) arg(%08x)\n",
1525 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1526 } while (0);
1527 return -EINVAL;
1528 }
1529 set_fs (KERNEL_DS);
1530 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1531 set_fs (old_fs);
1532 switch (cmd) {
1533 case PPPIOCGIDLE32:
1534 if (err)
1535 return err;
1536 idle32.xmit_idle = idle.xmit_idle;
1537 idle32.recv_idle = idle.recv_idle;
1538 if (copy_to_user((struct ppp_idle32 *)arg, &idle32, sizeof(struct ppp_idle32)))
1539 return -EFAULT;
1540 break;
1541 case PPPIOCSCOMPRESS32:
1542 kfree(data.ptr);
1543 break;
1544 default:
1545 break;
1546 }
1547 return err;
1548}
1549
1550
1551struct mtget32 {
1552 __u32 mt_type;
1553 __u32 mt_resid;
1554 __u32 mt_dsreg;
1555 __u32 mt_gstat;
1556 __u32 mt_erreg;
1557 __kernel_daddr_t32 mt_fileno;
1558 __kernel_daddr_t32 mt_blkno;
1559};
1560#define MTIOCGET32 _IOR('m', 2, struct mtget32)
1561
1562struct mtpos32 {
1563 __u32 mt_blkno;
1564};
1565#define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
1566
1567struct mtconfiginfo32 {
1568 __u32 mt_type;
1569 __u32 ifc_type;
1570 __u16 irqnr;
1571 __u16 dmanr;
1572 __u16 port;
1573 __u32 debug;
1574 __u32 have_dens:1;
1575 __u32 have_bsf:1;
1576 __u32 have_fsr:1;
1577 __u32 have_bsr:1;
1578 __u32 have_eod:1;
1579 __u32 have_seek:1;
1580 __u32 have_tell:1;
1581 __u32 have_ras1:1;
1582 __u32 have_ras2:1;
1583 __u32 have_ras3:1;
1584 __u32 have_qfa:1;
1585 __u32 pad1:5;
1586 char reserved[10];
1587};
1588#define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
1589#define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
1590
1591static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1592{
1593 mm_segment_t old_fs = get_fs();
1594 struct mtconfiginfo info;
1595 struct mtget get;
1596 struct mtpos pos;
1597 unsigned long kcmd;
1598 void *karg;
1599 int err = 0;
1600
1601 switch(cmd) {
1602 case MTIOCPOS32:
1603 kcmd = MTIOCPOS;
1604 karg = &pos;
1605 break;
1606 case MTIOCGET32:
1607 kcmd = MTIOCGET;
1608 karg = &get;
1609 break;
1610 case MTIOCGETCONFIG32:
1611 kcmd = MTIOCGETCONFIG;
1612 karg = &info;
1613 break;
1614 case MTIOCSETCONFIG32:
1615 kcmd = MTIOCSETCONFIG;
1616 karg = &info;
1617 err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1618 err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1619 err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1620 err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1621 err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1622 err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1623 err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
1624 (char *)&((struct mtconfiginfo32 *)arg)->debug
1625 + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
1626 if (err)
1627 return -EFAULT;
1628 break;
1629 default:
1630 do {
1631 static int count = 0;
1632 if (++count <= 20)
1633 printk("mt_ioctl: Unknown cmd fd(%d) "
1634 "cmd(%08x) arg(%08x)\n",
1635 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1636 } while (0);
1637 return -EINVAL;
1638 }
1639 set_fs (KERNEL_DS);
1640 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1641 set_fs (old_fs);
1642 if (err)
1643 return err;
1644 switch (cmd) {
1645 case MTIOCPOS32:
1646 err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
1647 break;
1648 case MTIOCGET32:
1649 err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
1650 err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
1651 err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
1652 err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
1653 err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
1654 err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
1655 err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
1656 break;
1657 case MTIOCGETCONFIG32:
1658 err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1659 err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1660 err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1661 err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1662 err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1663 err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1664 err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
1665 + sizeof(((struct mtconfiginfo32 *)arg)->debug),
1666 (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
1667 break;
1668 case MTIOCSETCONFIG32:
1669 break;
1670 }
1671 return err ? -EFAULT: 0;
1672}
1673
1674struct cdrom_read_audio32 {
1675 union cdrom_addr addr;
1676 u_char addr_format;
1677 int nframes;
1678 __kernel_caddr_t32 buf;
1679};
1680
1681struct cdrom_generic_command32 {
1682 unsigned char cmd[CDROM_PACKET_SIZE];
1683 __kernel_caddr_t32 buffer;
1684 unsigned int buflen;
1685 int stat;
1686 __kernel_caddr_t32 sense;
1687 __kernel_caddr_t32 reserved[3];
1688};
1689
1690static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1691{
1692 mm_segment_t old_fs = get_fs();
1693 struct cdrom_read_audio cdreadaudio;
1694 struct cdrom_generic_command cgc;
1695 __kernel_caddr_t32 addr;
1696 char *data = 0;
1697 void *karg;
1698 int err = 0;
1699
1700 switch(cmd) {
1701 case CDROMREADAUDIO:
1702 karg = &cdreadaudio;
1703 err = copy_from_user(&cdreadaudio.addr, &((struct cdrom_read_audio32 *)arg)->addr, sizeof(cdreadaudio.addr));
1704 err |= __get_user(cdreadaudio.addr_format, &((struct cdrom_read_audio32 *)arg)->addr_format);
1705 err |= __get_user(cdreadaudio.nframes, &((struct cdrom_read_audio32 *)arg)->nframes);
1706 err |= __get_user(addr, &((struct cdrom_read_audio32 *)arg)->buf);
1707 if (err)
1708 return -EFAULT;
1709 if (verify_area(VERIFY_WRITE, (void *)A(addr), cdreadaudio.nframes*2352))
1710 return -EFAULT;
1711 cdreadaudio.buf = (void *)A(addr);
1712 break;
1713 case CDROM_SEND_PACKET:
1714 karg = &cgc;
1715 err = copy_from_user(cgc.cmd, &((struct cdrom_generic_command32 *)arg)->cmd, sizeof(cgc.cmd));
1716 err |= __get_user(addr, &((struct cdrom_generic_command32 *)arg)->buffer);
1717 err |= __get_user(cgc.buflen, &((struct cdrom_generic_command32 *)arg)->buflen);
1718 if (err)
1719 return -EFAULT;
1720 if (verify_area(VERIFY_WRITE, (void *)A(addr), cgc.buflen))
1721 return -EFAULT;
1722 cgc.buffer = (void *)A(addr);
1723 break;
1724 default:
1725 do {
1726 static int count = 0;
1727 if (++count <= 20)
1728 printk("cdrom_ioctl: Unknown cmd fd(%d) "
1729 "cmd(%08x) arg(%08x)\n",
1730 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1731 } while (0);
1732 return -EINVAL;
1733 }
1734 set_fs (KERNEL_DS);
1735 err = sys_ioctl (fd, cmd, (unsigned long)karg);
1736 set_fs (old_fs);
1737out: if (data)
1738 kfree(data);
1739 return err ? -EFAULT : 0;
1740}
1741
1742struct loop_info32 {
1743 int lo_number;
1744 __kernel_dev_t32 lo_device;
1745 unsigned int lo_inode;
1746 __kernel_dev_t32 lo_rdevice;
1747 int lo_offset;
1748 int lo_encrypt_type;
1749 int lo_encrypt_key_size;
1750 int lo_flags;
1751 char lo_name[LO_NAME_SIZE];
1752 unsigned char lo_encrypt_key[LO_KEY_SIZE];
1753 unsigned int lo_init[2];
1754 char reserved[4];
1755};
1756
1757static int loop_status(unsigned int fd, unsigned int cmd, unsigned long arg)
1758{
1759 mm_segment_t old_fs = get_fs();
1760 struct loop_info l;
1761 int err = -EINVAL;
1762
1763 switch(cmd) {
1764 case LOOP_SET_STATUS:
1765 err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1766 err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1767 err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1768 err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1769 err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,
1770 8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1771 if (err) {
1772 err = -EFAULT;
1773 } else {
1774 set_fs (KERNEL_DS);
1775 err = sys_ioctl (fd, cmd, (unsigned long)&l);
1776 set_fs (old_fs);
1777 }
1778 break;
1779 case LOOP_GET_STATUS:
1780 set_fs (KERNEL_DS);
1781 err = sys_ioctl (fd, cmd, (unsigned long)&l);
1782 set_fs (old_fs);
1783 if (!err) {
1784 err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1785 err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1786 err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1787 err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1788 err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,
1789 (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1790 if (err)
1791 err = -EFAULT;
1792 }
1793 break;
1794 default: {
1795 static int count = 0;
1796 if (++count <= 20)
1797 printk("%s: Unknown loop ioctl cmd, fd(%d) "
1798 "cmd(%08x) arg(%08lx)\n",
1799 __FUNCTION__, fd, cmd, arg);
1800 }
1801 }
1802 return err;
1803}
1804
1805extern int tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg);
1806
1807#ifdef CONFIG_VT
1808static int vt_check(struct file *file)
1809{
1810 struct tty_struct *tty;
1811 struct inode *inode = file->f_dentry->d_inode;
1812
1813 if (file->f_op->ioctl != tty_ioctl)
1814 return -EINVAL;
1815
1816 tty = (struct tty_struct *)file->private_data;
1817 if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
1818 return -EINVAL;
1819
1820 if (tty->driver.ioctl != vt_ioctl)
1821 return -EINVAL;
1822
1823
1824
1825
1826
1827 if (current->tty == tty || suser())
1828 return 1;
1829 return 0;
1830}
1831
1832struct consolefontdesc32 {
1833 unsigned short charcount;
1834 unsigned short charheight;
1835 u32 chardata;
1836};
1837
1838static int do_fontx_ioctl(unsigned int fd, int cmd, struct consolefontdesc32 *user_cfd, struct file *file)
1839{
1840 struct consolefontdesc cfdarg;
1841 struct console_font_op op;
1842 int i, perm;
1843
1844 perm = vt_check(file);
1845 if (perm < 0) return perm;
1846
1847 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc32)))
1848 return -EFAULT;
1849
1850 cfdarg.chardata = (unsigned char *)A(((struct consolefontdesc32 *)&cfdarg)->chardata);
1851
1852 switch (cmd) {
1853 case PIO_FONTX:
1854 if (!perm)
1855 return -EPERM;
1856 op.op = KD_FONT_OP_SET;
1857 op.flags = 0;
1858 op.width = 8;
1859 op.height = cfdarg.charheight;
1860 op.charcount = cfdarg.charcount;
1861 op.data = cfdarg.chardata;
1862 return con_font_op(fg_console, &op);
1863 case GIO_FONTX:
1864 if (!cfdarg.chardata)
1865 return 0;
1866 op.op = KD_FONT_OP_GET;
1867 op.flags = 0;
1868 op.width = 8;
1869 op.height = cfdarg.charheight;
1870 op.charcount = cfdarg.charcount;
1871 op.data = cfdarg.chardata;
1872 i = con_font_op(fg_console, &op);
1873 if (i)
1874 return i;
1875 cfdarg.charheight = op.height;
1876 cfdarg.charcount = op.charcount;
1877 ((struct consolefontdesc32 *)&cfdarg)->chardata = (unsigned long)cfdarg.chardata;
1878 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc32)))
1879 return -EFAULT;
1880 return 0;
1881 }
1882 return -EINVAL;
1883}
1884
1885struct console_font_op32 {
1886 unsigned int op;
1887 unsigned int flags;
1888 unsigned int width, height;
1889 unsigned int charcount;
1890 u32 data;
1891};
1892
1893static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, struct console_font_op32 *fontop, struct file *file)
1894{
1895 struct console_font_op op;
1896 int perm = vt_check(file), i;
1897 struct vt_struct *vt;
1898
1899 if (perm < 0) return perm;
1900
1901 if (copy_from_user(&op, (void *) fontop, sizeof(struct console_font_op32)))
1902 return -EFAULT;
1903 if (!perm && op.op != KD_FONT_OP_GET)
1904 return -EPERM;
1905 op.data = (unsigned char *)A(((struct console_font_op32 *)&op)->data);
1906 op.flags |= KD_FONT_FLAG_OLD;
1907 vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data;
1908 i = con_font_op(vt->vc_num, &op);
1909 if (i) return i;
1910 ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
1911 if (copy_to_user((void *) fontop, &op, sizeof(struct console_font_op32)))
1912 return -EFAULT;
1913 return 0;
1914}
1915
1916struct fb_fix_screeninfo32 {
1917 char id[16];
1918 unsigned int smem_start;
1919
1920 __u32 smem_len;
1921 __u32 type;
1922 __u32 type_aux;
1923 __u32 visual;
1924 __u16 xpanstep;
1925 __u16 ypanstep;
1926 __u16 ywrapstep;
1927 __u32 line_length;
1928 unsigned int mmio_start;
1929
1930 __u32 mmio_len;
1931 __u32 accel;
1932 __u16 reserved[3];
1933};
1934
1935static int do_fbioget_fscreeninfo_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
1936{
1937 mm_segment_t old_fs = get_fs();
1938 struct fb_fix_screeninfo fix;
1939 int err;
1940
1941 set_fs(KERNEL_DS);
1942 err = sys_ioctl(fd, cmd, (long)&fix);
1943 set_fs(old_fs);
1944
1945 if (err == 0) {
1946 unsigned int smem_start = fix.smem_start;
1947 unsigned int mmio_start = fix.mmio_start;
1948 int i;
1949
1950 err = put_user(fix.id[0], &((struct fb_fix_screeninfo32 *)arg)->id[0]);
1951 for (i=1; i<16; i++) {
1952 err |= __put_user(fix.id[i], &((struct fb_fix_screeninfo32 *)arg)->id[i]);
1953 }
1954 err |= __put_user(smem_start, &((struct fb_fix_screeninfo32 *)arg)->smem_start);
1955 err |= __put_user(fix.smem_len, &((struct fb_fix_screeninfo32 *)arg)->smem_len);
1956 err |= __put_user(fix.type, &((struct fb_fix_screeninfo32 *)arg)->type);
1957 err |= __put_user(fix.type_aux, &((struct fb_fix_screeninfo32 *)arg)->type_aux);
1958 err |= __put_user(fix.visual, &((struct fb_fix_screeninfo32 *)arg)->visual);
1959 err |= __put_user(fix.xpanstep, &((struct fb_fix_screeninfo32 *)arg)->xpanstep);
1960 err |= __put_user(fix.ypanstep, &((struct fb_fix_screeninfo32 *)arg)->ypanstep);
1961 err |= __put_user(fix.ywrapstep, &((struct fb_fix_screeninfo32 *)arg)->ywrapstep);
1962 err |= __put_user(fix.line_length, &((struct fb_fix_screeninfo32 *)arg)->line_length);
1963 err |= __put_user(mmio_start, &((struct fb_fix_screeninfo32 *)arg)->mmio_start);
1964 err |= __put_user(fix.mmio_len, &((struct fb_fix_screeninfo32 *)arg)->mmio_len);
1965 err |= __put_user(fix.accel, &((struct fb_fix_screeninfo32 *)arg)->accel);
1966 err |= __put_user(fix.reserved[0], &((struct fb_fix_screeninfo32 *)arg)->reserved[0]);
1967 err |= __put_user(fix.reserved[1], &((struct fb_fix_screeninfo32 *)arg)->reserved[1]);
1968 err |= __put_user(fix.reserved[2], &((struct fb_fix_screeninfo32 *)arg)->reserved[2]);
1969 if (err)
1970 err = -EFAULT;
1971 }
1972 return err;
1973}
1974
1975struct fb_cmap32 {
1976 __u32 start;
1977 __u32 len;
1978 __u32 redptr;
1979 __u32 greenptr;
1980 __u32 blueptr;
1981 __u32 transpptr;
1982};
1983
1984static int do_fbiogetcmap_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
1985{
1986 mm_segment_t old_fs = get_fs();
1987 struct fb_cmap cmap;
1988 int err;
1989
1990 set_fs(KERNEL_DS);
1991 err = sys_ioctl(fd, cmd, (long)&cmap);
1992 set_fs(old_fs);
1993
1994 if (err == 0) {
1995 __u32 redptr = (__u32)(__u64)cmap.red;
1996 __u32 greenptr = (__u32)(__u64)cmap.green;
1997 __u32 blueptr = (__u32)(__u64)cmap.blue;
1998 __u32 transpptr = (__u32)(__u64)cmap.transp;
1999
2000 err = put_user(cmap.start, &((struct fb_cmap32 *)arg)->start);
2001 err |= __put_user(cmap.len, &((struct fb_cmap32 *)arg)->len);
2002 err |= __put_user(redptr, &((struct fb_cmap32 *)arg)->redptr);
2003 err |= __put_user(greenptr, &((struct fb_cmap32 *)arg)->greenptr);
2004 err |= __put_user(blueptr, &((struct fb_cmap32 *)arg)->blueptr);
2005 err |= __put_user(transpptr, &((struct fb_cmap32 *)arg)->transpptr);
2006 if (err)
2007 err = -EFAULT;
2008 }
2009 return err;
2010}
2011
2012static int do_fbioputcmap_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
2013{
2014 mm_segment_t old_fs = get_fs();
2015 struct fb_cmap cmap;
2016 __u32 redptr, greenptr, blueptr, transpptr;
2017 int err;
2018
2019 err = get_user(cmap.start, &((struct fb_cmap32 *)arg)->start);
2020 err |= __get_user(cmap.len, &((struct fb_cmap32 *)arg)->len);
2021 err |= __get_user(redptr, &((struct fb_cmap32 *)arg)->redptr);
2022 err |= __get_user(greenptr, &((struct fb_cmap32 *)arg)->greenptr);
2023 err |= __get_user(blueptr, &((struct fb_cmap32 *)arg)->blueptr);
2024 err |= __get_user(transpptr, &((struct fb_cmap32 *)arg)->transpptr);
2025
2026 if (err) {
2027 err = -EFAULT;
2028 } else {
2029 cmap.red = (__u16 *)(__u64)redptr;
2030 cmap.green = (__u16 *)(__u64)greenptr;
2031 cmap.blue = (__u16 *)(__u64)blueptr;
2032 cmap.transp = (__u16 *)(__u64)transpptr;
2033 set_fs (KERNEL_DS);
2034 err = sys_ioctl (fd, cmd, (unsigned long)&cmap);
2035 set_fs (old_fs);
2036 }
2037 return err;
2038}
2039
2040struct unimapdesc32 {
2041 unsigned short entry_ct;
2042 u32 entries;
2043};
2044
2045static int do_unimap_ioctl(unsigned int fd, unsigned int cmd, struct unimapdesc32 *user_ud, struct file *file)
2046{
2047 struct unimapdesc32 tmp;
2048 int perm = vt_check(file);
2049
2050 if (perm < 0) return perm;
2051 if (copy_from_user(&tmp, user_ud, sizeof tmp))
2052 return -EFAULT;
2053 switch (cmd) {
2054 case PIO_UNIMAP:
2055 if (!perm) return -EPERM;
2056 return con_set_unimap(fg_console, tmp.entry_ct, (struct unipair *)A(tmp.entries));
2057 case GIO_UNIMAP:
2058 return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), (struct unipair *)A(tmp.entries));
2059 }
2060 return 0;
2061}
2062#endif
2063static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long arg)
2064{
2065 mm_segment_t old_fs = get_fs();
2066 __kernel_uid_t kuid;
2067 int err;
2068
2069 cmd = SMB_IOC_GETMOUNTUID;
2070
2071 set_fs(KERNEL_DS);
2072 err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
2073 set_fs(old_fs);
2074
2075 if (err >= 0)
2076 err = put_user(kuid, (__kernel_uid_t32 *)arg);
2077
2078 return err;
2079}
2080
2081struct atmif_sioc32 {
2082 int number;
2083 int length;
2084 __kernel_caddr_t32 arg;
2085};
2086
2087struct atm_iobuf32 {
2088 int length;
2089 __kernel_caddr_t32 buffer;
2090};
2091
2092#define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
2093#define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
2094#define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
2095#define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
2096#define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
2097#define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
2098#define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
2099#define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
2100#define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
2101#define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
2102#define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
2103#define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
2104#define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
2105#define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
2106#define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
2107#define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
2108#define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
2109
2110static struct {
2111 unsigned int cmd32;
2112 unsigned int cmd;
2113} atm_ioctl_map[] = {
2114 { ATM_GETLINKRATE32, ATM_GETLINKRATE },
2115 { ATM_GETNAMES32, ATM_GETNAMES },
2116 { ATM_GETTYPE32, ATM_GETTYPE },
2117 { ATM_GETESI32, ATM_GETESI },
2118 { ATM_GETADDR32, ATM_GETADDR },
2119 { ATM_RSTADDR32, ATM_RSTADDR },
2120 { ATM_ADDADDR32, ATM_ADDADDR },
2121 { ATM_DELADDR32, ATM_DELADDR },
2122 { ATM_GETCIRANGE32, ATM_GETCIRANGE },
2123 { ATM_SETCIRANGE32, ATM_SETCIRANGE },
2124 { ATM_SETESI32, ATM_SETESI },
2125 { ATM_SETESIF32, ATM_SETESIF },
2126 { ATM_GETSTAT32, ATM_GETSTAT },
2127 { ATM_GETSTATZ32, ATM_GETSTATZ },
2128 { ATM_GETLOOP32, ATM_GETLOOP },
2129 { ATM_SETLOOP32, ATM_SETLOOP },
2130 { ATM_QUERYLOOP32, ATM_QUERYLOOP }
2131};
2132
2133#define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
2134
2135
2136static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
2137{
2138 struct atm_iobuf32 iobuf32;
2139 struct atm_iobuf iobuf = { 0, NULL };
2140 mm_segment_t old_fs;
2141 int err;
2142
2143 err = copy_from_user(&iobuf32, (struct atm_iobuf32*)arg,
2144 sizeof(struct atm_iobuf32));
2145 if (err)
2146 return -EFAULT;
2147
2148 iobuf.length = iobuf32.length;
2149
2150 if (iobuf32.buffer == (__kernel_caddr_t32) NULL || iobuf32.length == 0) {
2151 iobuf.buffer = (void*)(unsigned long)iobuf32.buffer;
2152 } else {
2153 iobuf.buffer = A(iobuf32.buffer);
2154 if (verify_area(VERIFY_WRITE, iobuf.buffer, iobuf.length))
2155 return -EINVAL;
2156 }
2157
2158 old_fs = get_fs(); set_fs (KERNEL_DS);
2159 err = sys_ioctl (fd, cmd, (unsigned long)&iobuf);
2160 set_fs (old_fs);
2161 if (!err)
2162 err = __put_user(iobuf.length, &(((struct atm_iobuf32*)arg)->length));
2163
2164 return err;
2165}
2166
2167
2168static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg)
2169{
2170 struct atmif_sioc32 sioc32;
2171 struct atmif_sioc sioc = { 0, 0, NULL };
2172 mm_segment_t old_fs;
2173 int err;
2174
2175 err = copy_from_user(&sioc32, (struct atmif_sioc32*)arg,
2176 sizeof(struct atmif_sioc32));
2177 if (err)
2178 return -EFAULT;
2179
2180 sioc.number = sioc32.number;
2181 sioc.length = sioc32.length;
2182
2183 if (sioc32.arg == (__kernel_caddr_t32) NULL || sioc32.length == 0) {
2184 sioc.arg = (void*)(unsigned long)sioc32.arg;
2185 } else {
2186 sioc.arg = A(sioc32.arg);
2187 if (verify_area(VERIFY_WRITE, sioc.arg, sioc32.length))
2188 return -EFAULT;
2189 }
2190
2191 old_fs = get_fs(); set_fs (KERNEL_DS);
2192 err = sys_ioctl (fd, cmd, (unsigned long)&sioc);
2193 set_fs (old_fs);
2194
2195 if (!err)
2196 err = __put_user(sioc.length, &(((struct atmif_sioc32*)arg)->length));
2197
2198 return err;
2199}
2200
2201
2202static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg)
2203{
2204 int i;
2205 unsigned int cmd = 0;
2206
2207 switch (cmd32) {
2208 case SONET_GETSTAT:
2209 case SONET_GETSTATZ:
2210 case SONET_GETDIAG:
2211 case SONET_SETDIAG:
2212 case SONET_CLRDIAG:
2213 case SONET_SETFRAMING:
2214 case SONET_GETFRAMING:
2215 case SONET_GETFRSENSE:
2216 return do_atmif_sioc(fd, cmd32, arg);
2217 }
2218
2219 for (i = 0; i < NR_ATM_IOCTL; i++) {
2220 if (cmd32 == atm_ioctl_map[i].cmd32) {
2221 cmd = atm_ioctl_map[i].cmd;
2222 break;
2223 }
2224 }
2225 if (i == NR_ATM_IOCTL) {
2226 return -EINVAL;
2227 }
2228
2229 switch (cmd) {
2230 case ATM_GETNAMES:
2231 return do_atm_iobuf(fd, cmd, arg);
2232
2233 case ATM_GETLINKRATE:
2234 case ATM_GETTYPE:
2235 case ATM_GETESI:
2236 case ATM_GETADDR:
2237 case ATM_RSTADDR:
2238 case ATM_ADDADDR:
2239 case ATM_DELADDR:
2240 case ATM_GETCIRANGE:
2241 case ATM_SETCIRANGE:
2242 case ATM_SETESI:
2243 case ATM_SETESIF:
2244 case ATM_GETSTAT:
2245 case ATM_GETSTATZ:
2246 case ATM_GETLOOP:
2247 case ATM_SETLOOP:
2248 case ATM_QUERYLOOP:
2249 return do_atmif_sioc(fd, cmd, arg);
2250 }
2251
2252 return -EINVAL;
2253}
2254
2255#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
2256
2257typedef struct {
2258 uint8_t vg_name[NAME_LEN];
2259 uint32_t vg_number;
2260 uint32_t vg_access;
2261 uint32_t vg_status;
2262 uint32_t lv_max;
2263 uint32_t lv_cur;
2264 uint32_t lv_open;
2265 uint32_t pv_max;
2266 uint32_t pv_cur;
2267 uint32_t pv_act;
2268 uint32_t dummy;
2269 uint32_t vgda;
2270 uint32_t pe_size;
2271 uint32_t pe_total;
2272 uint32_t pe_allocated;
2273 uint32_t pvg_total;
2274 u32 proc;
2275 u32 pv[ABS_MAX_PV + 1];
2276 u32 lv[ABS_MAX_LV + 1];
2277 uint8_t vg_uuid[UUID_LEN+1];
2278 uint8_t dummy1[200];
2279} vg32_t;
2280
2281typedef struct {
2282 uint8_t id[2];
2283 uint16_t version;
2284 lvm_disk_data_t pv_on_disk;
2285 lvm_disk_data_t vg_on_disk;
2286 lvm_disk_data_t pv_namelist_on_disk;
2287 lvm_disk_data_t lv_on_disk;
2288 lvm_disk_data_t pe_on_disk;
2289 uint8_t pv_name[NAME_LEN];
2290 uint8_t vg_name[NAME_LEN];
2291 uint8_t system_id[NAME_LEN];
2292 kdev_t pv_dev;
2293 uint32_t pv_number;
2294 uint32_t pv_status;
2295 uint32_t pv_allocatable;
2296 uint32_t pv_size;
2297 uint32_t lv_cur;
2298 uint32_t pe_size;
2299 uint32_t pe_total;
2300 uint32_t pe_allocated;
2301 uint32_t pe_stale;
2302 u32 pe;
2303 u32 inode;
2304 uint8_t pv_uuid[UUID_LEN+1];
2305} pv32_t;
2306
2307typedef struct {
2308 char lv_name[NAME_LEN];
2309 u32 lv;
2310} lv_req32_t;
2311
2312typedef struct {
2313 u32 lv_index;
2314 u32 lv;
2315
2316 uint16_t size;
2317} lv_status_byindex_req32_t;
2318
2319typedef struct {
2320 __kernel_dev_t32 dev;
2321 u32 lv;
2322} lv_status_bydev_req32_t;
2323
2324typedef struct {
2325 uint8_t lv_name[NAME_LEN];
2326 kdev_t old_dev;
2327 kdev_t new_dev;
2328 u32 old_pe;
2329 u32 new_pe;
2330} le_remap_req32_t;
2331
2332typedef struct {
2333 char pv_name[NAME_LEN];
2334 u32 pv;
2335} pv_status_req32_t;
2336
2337typedef struct {
2338 uint8_t lv_name[NAME_LEN];
2339 uint8_t vg_name[NAME_LEN];
2340 uint32_t lv_access;
2341 uint32_t lv_status;
2342 uint32_t lv_open;
2343 kdev_t lv_dev;
2344 uint32_t lv_number;
2345 uint32_t lv_mirror_copies;
2346 uint32_t lv_recovery;
2347 uint32_t lv_schedule;
2348 uint32_t lv_size;
2349 u32 lv_current_pe;
2350 uint32_t lv_current_le;
2351 uint32_t lv_allocated_le;
2352 uint32_t lv_stripes;
2353 uint32_t lv_stripesize;
2354 uint32_t lv_badblock;
2355 uint32_t lv_allocation;
2356 uint32_t lv_io_timeout;
2357 uint32_t lv_read_ahead;
2358
2359 u32 lv_snapshot_org;
2360 u32 lv_snapshot_prev;
2361 u32 lv_snapshot_next;
2362 u32 lv_block_exception;
2363 uint32_t lv_remap_ptr;
2364 uint32_t lv_remap_end;
2365 uint32_t lv_chunk_size;
2366 uint32_t lv_snapshot_minor;
2367 char dummy[200];
2368} lv32_t;
2369
2370typedef struct {
2371 u32 hash[2];
2372 u32 rsector_org;
2373 kdev_t rdev_org;
2374 u32 rsector_new;
2375 kdev_t rdev_new;
2376} lv_block_exception32_t;
2377
2378static void put_lv_t(lv_t *l)
2379{
2380 if (l->lv_current_pe) vfree(l->lv_current_pe);
2381 if (l->lv_block_exception) vfree(l->lv_block_exception);
2382 kfree(l);
2383}
2384
2385static lv_t *get_lv_t(u32 p, int *errp)
2386{
2387 int err, i;
2388 u32 ptr1, ptr2;
2389 size_t size;
2390 lv_block_exception32_t *lbe32;
2391 lv_block_exception_t *lbe;
2392 lv32_t *ul = (lv32_t *)A(p);
2393 lv_t *l = (lv_t *) kmalloc(sizeof(lv_t), GFP_KERNEL);
2394
2395 if (!l) {
2396 *errp = -ENOMEM;
2397 return NULL;
2398 }
2399 memset(l, 0, sizeof(lv_t));
2400 err = copy_from_user(l, ul, (long)&((lv32_t *)0)->lv_current_pe);
2401 err |= __copy_from_user(&l->lv_current_le, &ul->lv_current_le,
2402 ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
2403 err |= __copy_from_user(&l->lv_remap_ptr, &ul->lv_remap_ptr,
2404 ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
2405 err |= __get_user(ptr1, &ul->lv_current_pe);
2406 err |= __get_user(ptr2, &ul->lv_block_exception);
2407 if (err) {
2408 kfree(l);
2409 *errp = -EFAULT;
2410 return NULL;
2411 }
2412 if (ptr1) {
2413 if (l->lv_allocated_le > 2*PAGE_SIZE/sizeof(pe_t)) {
2414 kfree(l);
2415 *errp = -EINVAL;
2416 return NULL;
2417 }
2418 size = l->lv_allocated_le * sizeof(pe_t);
2419 l->lv_current_pe = vmalloc(size);
2420 if (l->lv_current_pe)
2421 err = copy_from_user(l->lv_current_pe, (void *)A(ptr1), size);
2422 }
2423 if (!err && ptr2) {
2424
2425
2426 if (l->lv_remap_end > 256*PAGE_SIZE/sizeof(lv_block_exception_t)) {
2427 put_lv_t(l);
2428 *errp = -EINVAL;
2429 return NULL;
2430 }
2431 size = l->lv_remap_end * sizeof(lv_block_exception_t);
2432 l->lv_block_exception = lbe = vmalloc(size);
2433 if (l->lv_block_exception) {
2434 lbe32 = (lv_block_exception32_t *)A(ptr2);
2435 memset(lbe, 0, size);
2436 for (i = 0; i < l->lv_remap_end; i++, lbe++, lbe32++) {
2437 err |= get_user(lbe->rsector_org, &lbe32->rsector_org);
2438 err |= __get_user(lbe->rdev_org, &lbe32->rdev_org);
2439 err |= __get_user(lbe->rsector_new, &lbe32->rsector_new);
2440 err |= __get_user(lbe->rdev_new, &lbe32->rdev_new);
2441 }
2442 }
2443 }
2444 if (err || (ptr1 && !l->lv_current_pe) || (ptr2 && !l->lv_block_exception)) {
2445 if (!err)
2446 *errp = -ENOMEM;
2447 else
2448 *errp = -EFAULT;
2449 put_lv_t(l);
2450 return NULL;
2451 }
2452 return l;
2453}
2454
2455static int copy_lv_t(u32 ptr, lv_t *l)
2456{
2457 int err;
2458 lv32_t *ul = (lv32_t *)A(ptr);
2459 u32 ptr1;
2460 size_t size;
2461
2462 err = get_user(ptr1, &ul->lv_current_pe);
2463 if (err)
2464 return -EFAULT;
2465 err = copy_to_user(ul, l, (long)&((lv32_t *)0)->lv_current_pe);
2466 err |= __copy_to_user(&ul->lv_current_le, &l->lv_current_le,
2467 ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
2468 err |= __copy_to_user(&ul->lv_remap_ptr, &l->lv_remap_ptr,
2469 ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
2470 size = l->lv_allocated_le * sizeof(pe_t);
2471 if (ptr1)
2472 err |= __copy_to_user((void *)A(ptr1), l->lv_current_pe, size);
2473 return err ? -EFAULT : 0;
2474}
2475
2476static int do_lvm_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
2477{
2478 vg_t *v = NULL;
2479 union {
2480 lv_req_t lv_req;
2481 le_remap_req_t le_remap;
2482 lv_status_byindex_req_t lv_byindex;
2483 lv_status_bydev_req_t lv_bydev;
2484 pv_status_req_t pv_status;
2485 } u;
2486 pv_t p;
2487 int err;
2488 u32 ptr = 0;
2489 int i;
2490 mm_segment_t old_fs;
2491 void *karg = &u;
2492
2493 switch (cmd) {
2494 case VG_STATUS:
2495 v = kmalloc(sizeof(vg_t), GFP_KERNEL);
2496 if (!v)
2497 return -ENOMEM;
2498 karg = v;
2499 break;
2500
2501 case VG_CREATE_OLD:
2502 case VG_CREATE:
2503 v = kmalloc(sizeof(vg_t), GFP_KERNEL);
2504 if (!v)
2505 return -ENOMEM;
2506 if (copy_from_user(v, (void *)arg, (long)&((vg32_t *)0)->proc)) {
2507 kfree(v);
2508 return -EFAULT;
2509 }
2510
2511 v->proc = NULL;
2512 if (copy_from_user(v->vg_uuid, ((vg32_t *)arg)->vg_uuid, UUID_LEN+1)) {
2513 kfree(v);
2514 return -EFAULT;
2515 }
2516
2517 karg = v;
2518 memset(v->pv, 0, sizeof(v->pv) + sizeof(v->lv));
2519 if (v->pv_max > ABS_MAX_PV || v->lv_max > ABS_MAX_LV)
2520 return -EPERM;
2521 for (i = 0; i < v->pv_max; i++) {
2522 err = __get_user(ptr, &((vg32_t *)arg)->pv[i]);
2523 if (err)
2524 break;
2525 if (ptr) {
2526 v->pv[i] = kmalloc(sizeof(pv_t), GFP_KERNEL);
2527 if (!v->pv[i]) {
2528 err = -ENOMEM;
2529 break;
2530 }
2531 err = copy_from_user(v->pv[i], (void *)A(ptr),
2532 sizeof(pv32_t) - 8 - UUID_LEN+1);
2533 if (err) {
2534 err = -EFAULT;
2535 break;
2536 }
2537 err = copy_from_user(v->pv[i]->pv_uuid,
2538 ((pv32_t *)A(ptr))->pv_uuid,
2539 UUID_LEN+1);
2540 if (err) {
2541 err = -EFAULT;
2542 break;
2543 }
2544
2545 v->pv[i]->pe = NULL;
2546 v->pv[i]->bd = NULL;
2547 }
2548 }
2549 if (!err) {
2550 for (i = 0; i < v->lv_max; i++) {
2551 err = __get_user(ptr, &((vg32_t *)arg)->lv[i]);
2552 if (err)
2553 break;
2554 if (ptr) {
2555 v->lv[i] = get_lv_t(ptr, &err);
2556 if (err)
2557 break;
2558 }
2559 }
2560 }
2561 break;
2562
2563 case LV_CREATE:
2564 case LV_EXTEND:
2565 case LV_REDUCE:
2566 case LV_REMOVE:
2567 case LV_RENAME:
2568 case LV_STATUS_BYNAME:
2569 err = copy_from_user(&u.pv_status, arg, sizeof(u.pv_status.pv_name));
2570 if (err)
2571 return -EFAULT;
2572 if (cmd != LV_REMOVE) {
2573 err = __get_user(ptr, &((lv_req32_t *)arg)->lv);
2574 if (err)
2575 return err;
2576 u.lv_req.lv = get_lv_t(ptr, &err);
2577 } else
2578 u.lv_req.lv = NULL;
2579 break;
2580
2581 case LV_STATUS_BYINDEX:
2582 err = get_user(u.lv_byindex.lv_index,
2583 &((lv_status_byindex_req32_t *)arg)->lv_index);
2584 err |= __get_user(ptr, &((lv_status_byindex_req32_t *)arg)->lv);
2585 if (err)
2586 return err;
2587 u.lv_byindex.lv = get_lv_t(ptr, &err);
2588 break;
2589
2590 case LV_STATUS_BYDEV:
2591 err = get_user(u.lv_bydev.dev, &((lv_status_bydev_req32_t *)arg)->dev);
2592 err |= __get_user(ptr, &((lv_status_bydev_req32_t *)arg)->lv);
2593 if (err)
2594 return err;
2595 u.lv_bydev.lv = get_lv_t(ptr, &err);
2596 break;
2597
2598 case VG_EXTEND:
2599 err = copy_from_user(&p, (void *)arg, sizeof(pv32_t) - 8 - UUID_LEN+1);
2600 if (err)
2601 return -EFAULT;
2602 err = copy_from_user(p.pv_uuid, ((pv32_t *)arg)->pv_uuid, UUID_LEN+1);
2603 if (err)
2604 return -EFAULT;
2605 p.pe = NULL;
2606 p.bd = NULL;
2607 karg = &p;
2608 break;
2609
2610 case PV_CHANGE:
2611 case PV_STATUS:
2612 err = copy_from_user(&u.pv_status, arg, sizeof(u.lv_req.lv_name));
2613 if (err)
2614 return -EFAULT;
2615 err = __get_user(ptr, &((pv_status_req32_t *)arg)->pv);
2616 if (err)
2617 return err;
2618 u.pv_status.pv = &p;
2619 if (cmd == PV_CHANGE) {
2620 err = copy_from_user(&p, (void *)A(ptr),
2621 sizeof(pv32_t) - 8 - UUID_LEN+1);
2622 if (err)
2623 return -EFAULT;
2624 p.pe = NULL;
2625 p.bd = NULL;
2626 }
2627 break;
2628 };
2629
2630 old_fs = get_fs(); set_fs (KERNEL_DS);
2631 err = sys_ioctl (fd, cmd, (unsigned long)karg);
2632 set_fs (old_fs);
2633
2634 switch (cmd) {
2635 case VG_STATUS:
2636 if (!err) {
2637 if (copy_to_user((void *)arg, v, (long)&((vg32_t *)0)->proc) ||
2638 clear_user(&((vg32_t *)arg)->proc, sizeof(vg32_t) - (long)&((vg32_t *)0)->proc))
2639 err = -EFAULT;
2640 }
2641 if (copy_to_user(((vg32_t *)arg)->vg_uuid, v->vg_uuid, UUID_LEN+1)) {
2642 err = -EFAULT;
2643 }
2644 kfree(v);
2645 break;
2646
2647 case VG_CREATE_OLD:
2648 case VG_CREATE:
2649 for (i = 0; i < v->pv_max; i++) {
2650 if (v->pv[i])
2651 kfree(v->pv[i]);
2652 }
2653 for (i = 0; i < v->lv_max; i++) {
2654 if (v->lv[i])
2655 put_lv_t(v->lv[i]);
2656 }
2657 kfree(v);
2658 break;
2659
2660 case LV_STATUS_BYNAME:
2661 if (!err && u.lv_req.lv)
2662 err = copy_lv_t(ptr, u.lv_req.lv);
2663
2664
2665 case LV_CREATE:
2666 case LV_EXTEND:
2667 case LV_REDUCE:
2668 if (u.lv_req.lv)
2669 put_lv_t(u.lv_req.lv);
2670 break;
2671
2672 case LV_STATUS_BYINDEX:
2673 if (u.lv_byindex.lv) {
2674 if (!err)
2675 err = copy_lv_t(ptr, u.lv_byindex.lv);
2676 put_lv_t(u.lv_byindex.lv);
2677 }
2678 break;
2679
2680 case LV_STATUS_BYDEV:
2681 if (u.lv_bydev.lv) {
2682 if (!err)
2683 err = copy_lv_t(ptr, u.lv_bydev.lv);
2684 put_lv_t(u.lv_byindex.lv);
2685 }
2686 break;
2687
2688 case PV_STATUS:
2689 if (!err) {
2690 err = copy_to_user((void *)A(ptr), &p, sizeof(pv32_t) - 8 - UUID_LEN+1);
2691 if (err)
2692 return -EFAULT;
2693 err = copy_to_user(((pv_t *)A(ptr))->pv_uuid, p.pv_uuid, UUID_LEN + 1);
2694 if (err)
2695 return -EFAULT;
2696 }
2697 break;
2698 };
2699
2700 return err;
2701}
2702#endif
2703
2704#if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
2705
2706#include "../../../drivers/char/drm/drm.h"
2707
2708typedef struct drm32_version {
2709 int version_major;
2710 int version_minor;
2711 int version_patchlevel;
2712 int name_len;
2713 u32 name;
2714 int date_len;
2715 u32 date;
2716 int desc_len;
2717 u32 desc;
2718} drm32_version_t;
2719#define DRM32_IOCTL_VERSION DRM_IOWR(0x00, drm32_version_t)
2720
2721static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
2722{
2723 drm32_version_t *uversion = (drm32_version_t *)arg;
2724 char *name_ptr, *date_ptr, *desc_ptr;
2725 u32 tmp1, tmp2, tmp3;
2726 drm_version_t kversion;
2727 mm_segment_t old_fs;
2728 int ret;
2729
2730 memset(&kversion, 0, sizeof(kversion));
2731 if (get_user(kversion.name_len, &uversion->name_len) ||
2732 get_user(kversion.date_len, &uversion->date_len) ||
2733 get_user(kversion.desc_len, &uversion->desc_len) ||
2734 get_user(tmp1, &uversion->name) ||
2735 get_user(tmp2, &uversion->date) ||
2736 get_user(tmp3, &uversion->desc))
2737 return -EFAULT;
2738
2739 name_ptr = (char *) A(tmp1);
2740 date_ptr = (char *) A(tmp2);
2741 desc_ptr = (char *) A(tmp3);
2742
2743 ret = -ENOMEM;
2744 if (kversion.name_len && name_ptr) {
2745 kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
2746 if (!kversion.name)
2747 goto out;
2748 }
2749 if (kversion.date_len && date_ptr) {
2750 kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
2751 if (!kversion.date)
2752 goto out;
2753 }
2754 if (kversion.desc_len && desc_ptr) {
2755 kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
2756 if (!kversion.desc)
2757 goto out;
2758 }
2759
2760 old_fs = get_fs();
2761 set_fs(KERNEL_DS);
2762 ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
2763 set_fs(old_fs);
2764
2765 if (!ret) {
2766 if ((kversion.name &&
2767 copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
2768 (kversion.date &&
2769 copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
2770 (kversion.desc &&
2771 copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
2772 ret = -EFAULT;
2773 if (put_user(kversion.version_major, &uversion->version_major) ||
2774 put_user(kversion.version_minor, &uversion->version_minor) ||
2775 put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
2776 put_user(kversion.name_len, &uversion->name_len) ||
2777 put_user(kversion.date_len, &uversion->date_len) ||
2778 put_user(kversion.desc_len, &uversion->desc_len))
2779 ret = -EFAULT;
2780 }
2781
2782out:
2783 if (kversion.name)
2784 kfree(kversion.name);
2785 if (kversion.date)
2786 kfree(kversion.date);
2787 if (kversion.desc)
2788 kfree(kversion.desc);
2789 return ret;
2790}
2791
2792typedef struct drm32_unique {
2793 int unique_len;
2794 u32 unique;
2795} drm32_unique_t;
2796#define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
2797#define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
2798
2799static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
2800{
2801 drm32_unique_t *uarg = (drm32_unique_t *)arg;
2802 drm_unique_t karg;
2803 mm_segment_t old_fs;
2804 char *uptr;
2805 u32 tmp;
2806 int ret;
2807
2808 if (get_user(karg.unique_len, &uarg->unique_len))
2809 return -EFAULT;
2810 karg.unique = NULL;
2811
2812 if (get_user(tmp, &uarg->unique))
2813 return -EFAULT;
2814
2815 uptr = (char *) A(tmp);
2816
2817 if (uptr) {
2818 karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
2819 if (!karg.unique)
2820 return -ENOMEM;
2821 if (cmd == DRM32_IOCTL_SET_UNIQUE &&
2822 copy_from_user(karg.unique, uptr, karg.unique_len)) {
2823 kfree(karg.unique);
2824 return -EFAULT;
2825 }
2826 }
2827
2828 old_fs = get_fs();
2829 set_fs(KERNEL_DS);
2830 if (cmd == DRM32_IOCTL_GET_UNIQUE)
2831 ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
2832 else
2833 ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
2834 set_fs(old_fs);
2835
2836 if (!ret) {
2837 if (cmd == DRM32_IOCTL_GET_UNIQUE &&
2838 uptr != NULL &&
2839 copy_to_user(uptr, karg.unique, karg.unique_len))
2840 ret = -EFAULT;
2841 if (put_user(karg.unique_len, &uarg->unique_len))
2842 ret = -EFAULT;
2843 }
2844
2845 if (karg.unique != NULL)
2846 kfree(karg.unique);
2847
2848 return ret;
2849}
2850
2851typedef struct drm32_map {
2852 u32 offset;
2853 u32 size;
2854 drm_map_type_t type;
2855 drm_map_flags_t flags;
2856 u32 handle;
2857
2858 int mtrr;
2859
2860} drm32_map_t;
2861#define DRM32_IOCTL_ADD_MAP DRM_IOWR(0x15, drm32_map_t)
2862
2863static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
2864{
2865 drm32_map_t *uarg = (drm32_map_t *) arg;
2866 drm_map_t karg;
2867 mm_segment_t old_fs;
2868 u32 tmp;
2869 int ret;
2870
2871 ret = get_user(karg.offset, &uarg->offset);
2872 ret |= get_user(karg.size, &uarg->size);
2873 ret |= get_user(karg.type, &uarg->type);
2874 ret |= get_user(karg.flags, &uarg->flags);
2875 ret |= get_user(tmp, &uarg->handle);
2876 ret |= get_user(karg.mtrr, &uarg->mtrr);
2877 if (ret)
2878 return -EFAULT;
2879
2880 karg.handle = (void *) A(tmp);
2881
2882 old_fs = get_fs();
2883 set_fs(KERNEL_DS);
2884 ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
2885 set_fs(old_fs);
2886
2887 if (!ret) {
2888 ret = put_user(karg.offset, &uarg->offset);
2889 ret |= put_user(karg.size, &uarg->size);
2890 ret |= put_user(karg.type, &uarg->type);
2891 ret |= put_user(karg.flags, &uarg->flags);
2892 tmp = (u32) (long)karg.handle;
2893 ret |= put_user(tmp, &uarg->handle);
2894 ret |= put_user(karg.mtrr, &uarg->mtrr);
2895 if (ret)
2896 ret = -EFAULT;
2897 }
2898
2899 return ret;
2900}
2901
2902typedef struct drm32_buf_info {
2903 int count;
2904 u32 list;
2905} drm32_buf_info_t;
2906#define DRM32_IOCTL_INFO_BUFS DRM_IOWR(0x18, drm32_buf_info_t)
2907
2908static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
2909{
2910 drm32_buf_info_t *uarg = (drm32_buf_info_t *)arg;
2911 drm_buf_desc_t *ulist;
2912 drm_buf_info_t karg;
2913 mm_segment_t old_fs;
2914 int orig_count, ret;
2915 u32 tmp;
2916
2917 if (get_user(karg.count, &uarg->count) ||
2918 get_user(tmp, &uarg->list))
2919 return -EFAULT;
2920
2921 ulist = (drm_buf_desc_t *) A(tmp);
2922
2923 orig_count = karg.count;
2924
2925 karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
2926 if (!karg.list)
2927 return -EFAULT;
2928
2929 old_fs = get_fs();
2930 set_fs(KERNEL_DS);
2931 ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
2932 set_fs(old_fs);
2933
2934 if (!ret) {
2935 if (karg.count <= orig_count &&
2936 (copy_to_user(ulist, karg.list,
2937 karg.count * sizeof(drm_buf_desc_t))))
2938 ret = -EFAULT;
2939 if (put_user(karg.count, &uarg->count))
2940 ret = -EFAULT;
2941 }
2942
2943 kfree(karg.list);
2944
2945 return ret;
2946}
2947
2948typedef struct drm32_buf_free {
2949 int count;
2950 u32 list;
2951} drm32_buf_free_t;
2952#define DRM32_IOCTL_FREE_BUFS DRM_IOW( 0x1a, drm32_buf_free_t)
2953
2954static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
2955{
2956 drm32_buf_free_t *uarg = (drm32_buf_free_t *)arg;
2957 drm_buf_free_t karg;
2958 mm_segment_t old_fs;
2959 int *ulist;
2960 int ret;
2961 u32 tmp;
2962
2963 if (get_user(karg.count, &uarg->count) ||
2964 get_user(tmp, &uarg->list))
2965 return -EFAULT;
2966
2967 ulist = (int *) A(tmp);
2968
2969 karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
2970 if (!karg.list)
2971 return -ENOMEM;
2972
2973 ret = -EFAULT;
2974 if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
2975 goto out;
2976
2977 old_fs = get_fs();
2978 set_fs(KERNEL_DS);
2979 ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
2980 set_fs(old_fs);
2981
2982out:
2983 kfree(karg.list);
2984
2985 return ret;
2986}
2987
2988typedef struct drm32_buf_pub {
2989 int idx;
2990 int total;
2991 int used;
2992 u32 address;
2993} drm32_buf_pub_t;
2994
2995typedef struct drm32_buf_map {
2996 int count;
2997 u32 virtual;
2998 u32 list;
2999} drm32_buf_map_t;
3000#define DRM32_IOCTL_MAP_BUFS DRM_IOWR(0x19, drm32_buf_map_t)
3001
3002static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
3003{
3004 drm32_buf_map_t *uarg = (drm32_buf_map_t *)arg;
3005 drm32_buf_pub_t *ulist;
3006 drm_buf_map_t karg;
3007 mm_segment_t old_fs;
3008 int orig_count, ret, i;
3009 u32 tmp1, tmp2;
3010
3011 if (get_user(karg.count, &uarg->count) ||
3012 get_user(tmp1, &uarg->virtual) ||
3013 get_user(tmp2, &uarg->list))
3014 return -EFAULT;
3015
3016 karg.virtual = (void *) A(tmp1);
3017 ulist = (drm32_buf_pub_t *) A(tmp2);
3018
3019 orig_count = karg.count;
3020
3021 karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
3022 if (!karg.list)
3023 return -ENOMEM;
3024
3025 ret = -EFAULT;
3026 for (i = 0; i < karg.count; i++) {
3027 if (get_user(karg.list[i].idx, &ulist[i].idx) ||
3028 get_user(karg.list[i].total, &ulist[i].total) ||
3029 get_user(karg.list[i].used, &ulist[i].used) ||
3030 get_user(tmp1, &ulist[i].address))
3031 goto out;
3032
3033 karg.list[i].address = (void *) A(tmp1);
3034 }
3035
3036 old_fs = get_fs();
3037 set_fs(KERNEL_DS);
3038 ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
3039 set_fs(old_fs);
3040
3041 if (!ret) {
3042 for (i = 0; i < orig_count; i++) {
3043 tmp1 = (u32) (long) karg.list[i].address;
3044 if (put_user(karg.list[i].idx, &ulist[i].idx) ||
3045 put_user(karg.list[i].total, &ulist[i].total) ||
3046 put_user(karg.list[i].used, &ulist[i].used) ||
3047 put_user(tmp1, &ulist[i].address)) {
3048 ret = -EFAULT;
3049 goto out;
3050 }
3051 }
3052 if (put_user(karg.count, &uarg->count))
3053 ret = -EFAULT;
3054 }
3055
3056out:
3057 kfree(karg.list);
3058 return ret;
3059}
3060
3061typedef struct drm32_dma {
3062
3063
3064 int context;
3065 int send_count;
3066 u32 send_indices;
3067 u32 send_sizes;
3068 drm_dma_flags_t flags;
3069 int request_count;
3070 int request_size;
3071 u32 request_indices;
3072 u32 request_sizes;
3073 int granted_count;
3074} drm32_dma_t;
3075#define DRM32_IOCTL_DMA DRM_IOWR(0x29, drm32_dma_t)
3076
3077
3078
3079
3080
3081static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
3082{
3083 drm32_dma_t *uarg = (drm32_dma_t *) arg;
3084 int *u_si, *u_ss, *u_ri, *u_rs;
3085 drm_dma_t karg;
3086 mm_segment_t old_fs;
3087 int ret;
3088 u32 tmp1, tmp2, tmp3, tmp4;
3089
3090 karg.send_indices = karg.send_sizes = NULL;
3091 karg.request_indices = karg.request_sizes = NULL;
3092
3093 if (get_user(karg.context, &uarg->context) ||
3094 get_user(karg.send_count, &uarg->send_count) ||
3095 get_user(tmp1, &uarg->send_indices) ||
3096 get_user(tmp2, &uarg->send_sizes) ||
3097 get_user(karg.flags, &uarg->flags) ||
3098 get_user(karg.request_count, &uarg->request_count) ||
3099 get_user(karg.request_size, &uarg->request_size) ||
3100 get_user(tmp3, &uarg->request_indices) ||
3101 get_user(tmp4, &uarg->request_sizes) ||
3102 get_user(karg.granted_count, &uarg->granted_count))
3103 return -EFAULT;
3104
3105 u_si = (int *) A(tmp1);
3106 u_ss = (int *) A(tmp2);
3107 u_ri = (int *) A(tmp3);
3108 u_rs = (int *) A(tmp4);
3109
3110 if (karg.send_count) {
3111 karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
3112 karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
3113
3114 ret = -ENOMEM;
3115 if (!karg.send_indices || !karg.send_sizes)
3116 goto out;
3117
3118 ret = -EFAULT;
3119 if (copy_from_user(karg.send_indices, u_si,
3120 (karg.send_count * sizeof(int))) ||
3121 copy_from_user(karg.send_sizes, u_ss,
3122 (karg.send_count * sizeof(int))))
3123 goto out;
3124 }
3125
3126 if (karg.request_count) {
3127 karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
3128 karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
3129
3130 ret = -ENOMEM;
3131 if (!karg.request_indices || !karg.request_sizes)
3132 goto out;
3133
3134 ret = -EFAULT;
3135 if (copy_from_user(karg.request_indices, u_ri,
3136 (karg.request_count * sizeof(int))) ||
3137 copy_from_user(karg.request_sizes, u_rs,
3138 (karg.request_count * sizeof(int))))
3139 goto out;
3140 }
3141
3142 old_fs = get_fs();
3143 set_fs(KERNEL_DS);
3144 ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
3145 set_fs(old_fs);
3146
3147 if (!ret) {
3148 if (put_user(karg.context, &uarg->context) ||
3149 put_user(karg.send_count, &uarg->send_count) ||
3150 put_user(karg.flags, &uarg->flags) ||
3151 put_user(karg.request_count, &uarg->request_count) ||
3152 put_user(karg.request_size, &uarg->request_size) ||
3153 put_user(karg.granted_count, &uarg->granted_count))
3154 ret = -EFAULT;
3155
3156 if (karg.send_count) {
3157 if (copy_to_user(u_si, karg.send_indices,
3158 (karg.send_count * sizeof(int))) ||
3159 copy_to_user(u_ss, karg.send_sizes,
3160 (karg.send_count * sizeof(int))))
3161 ret = -EFAULT;
3162 }
3163 if (karg.request_count) {
3164 if (copy_to_user(u_ri, karg.request_indices,
3165 (karg.request_count * sizeof(int))) ||
3166 copy_to_user(u_rs, karg.request_sizes,
3167 (karg.request_count * sizeof(int))))
3168 ret = -EFAULT;
3169 }
3170 }
3171
3172out:
3173 if (karg.send_indices)
3174 kfree(karg.send_indices);
3175 if (karg.send_sizes)
3176 kfree(karg.send_sizes);
3177 if (karg.request_indices)
3178 kfree(karg.request_indices);
3179 if (karg.request_sizes)
3180 kfree(karg.request_sizes);
3181
3182 return ret;
3183}
3184
3185typedef struct drm32_ctx_res {
3186 int count;
3187 u32 contexts;
3188} drm32_ctx_res_t;
3189#define DRM32_IOCTL_RES_CTX DRM_IOWR(0x26, drm32_ctx_res_t)
3190
3191static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
3192{
3193 drm32_ctx_res_t *uarg = (drm32_ctx_res_t *) arg;
3194 drm_ctx_t *ulist;
3195 drm_ctx_res_t karg;
3196 mm_segment_t old_fs;
3197 int orig_count, ret;
3198 u32 tmp;
3199
3200 karg.contexts = NULL;
3201 if (get_user(karg.count, &uarg->count) ||
3202 get_user(tmp, &uarg->contexts))
3203 return -EFAULT;
3204
3205 ulist = (drm_ctx_t *) A(tmp);
3206
3207 orig_count = karg.count;
3208 if (karg.count && ulist) {
3209 karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
3210 if (!karg.contexts)
3211 return -ENOMEM;
3212 if (copy_from_user(karg.contexts, ulist,
3213 (karg.count * sizeof(drm_ctx_t)))) {
3214 kfree(karg.contexts);
3215 return -EFAULT;
3216 }
3217 }
3218
3219 old_fs = get_fs();
3220 set_fs(KERNEL_DS);
3221 ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
3222 set_fs(old_fs);
3223
3224 if (!ret) {
3225 if (orig_count) {
3226 if (copy_to_user(ulist, karg.contexts,
3227 (orig_count * sizeof(drm_ctx_t))))
3228 ret = -EFAULT;
3229 }
3230 if (put_user(karg.count, &uarg->count))
3231 ret = -EFAULT;
3232 }
3233
3234 if (karg.contexts)
3235 kfree(karg.contexts);
3236
3237 return ret;
3238}
3239
3240#endif
3241
3242static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
3243{
3244 return -EINVAL;
3245}
3246
3247static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
3248{
3249
3250 return w_long(fd, BLKGETSIZE, arg);
3251}
3252
3253struct blkpg_ioctl_arg32 {
3254 int op;
3255 int flags;
3256 int datalen;
3257 u32 data;
3258};
3259
3260static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd, struct blkpg_ioctl_arg32 *arg)
3261{
3262 struct blkpg_ioctl_arg a;
3263 struct blkpg_partition p;
3264 int err;
3265 mm_segment_t old_fs = get_fs();
3266
3267 err = get_user(a.op, &arg->op);
3268 err |= __get_user(a.flags, &arg->flags);
3269 err |= __get_user(a.datalen, &arg->datalen);
3270 err |= __get_user((long)a.data, &arg->data);
3271 if (err) return err;
3272 switch (a.op) {
3273 case BLKPG_ADD_PARTITION:
3274 case BLKPG_DEL_PARTITION:
3275 if (a.datalen < sizeof(struct blkpg_partition))
3276 return -EINVAL;
3277 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
3278 return -EFAULT;
3279 a.data = &p;
3280 set_fs (KERNEL_DS);
3281 err = sys_ioctl(fd, cmd, (unsigned long)&a);
3282 set_fs (old_fs);
3283 break;
3284 default:
3285 return -EINVAL;
3286 }
3287 return err;
3288}
3289
3290static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
3291{
3292 return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
3293}
3294
3295struct usbdevfs_ctrltransfer32 {
3296 __u8 requesttype;
3297 __u8 request;
3298 __u16 value;
3299 __u16 index;
3300 __u16 length;
3301 __u32 timeout;
3302 __u32 data;
3303};
3304
3305#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
3306
3307static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
3308{
3309 struct usbdevfs_ctrltransfer kctrl;
3310 struct usbdevfs_ctrltransfer32 *uctrl;
3311 mm_segment_t old_fs;
3312 __u32 udata;
3313 void *uptr, *kptr;
3314 int err;
3315
3316 uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
3317
3318 if (copy_from_user(&kctrl, uctrl,
3319 (sizeof(struct usbdevfs_ctrltransfer) -
3320 sizeof(void *))))
3321 return -EFAULT;
3322
3323 if (get_user(udata, &uctrl->data))
3324 return -EFAULT;
3325 uptr = (void *) A(udata);
3326
3327
3328
3329
3330 if (!uptr || kctrl.length > PAGE_SIZE)
3331 return -EINVAL;
3332
3333 kptr = (void *)__get_free_page(GFP_KERNEL);
3334
3335 if ((kctrl.requesttype & 0x80) == 0) {
3336 err = -EFAULT;
3337 if (copy_from_user(kptr, uptr, kctrl.length))
3338 goto out;
3339 }
3340
3341 kctrl.data = kptr;
3342
3343 old_fs = get_fs();
3344 set_fs(KERNEL_DS);
3345 err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
3346 set_fs(old_fs);
3347
3348 if (err >= 0 &&
3349 ((kctrl.requesttype & 0x80) != 0)) {
3350 if (copy_to_user(uptr, kptr, kctrl.length))
3351 err = -EFAULT;
3352 }
3353
3354out:
3355 free_page((unsigned long) kptr);
3356 return err;
3357}
3358
3359struct usbdevfs_bulktransfer32 {
3360 unsigned int ep;
3361 unsigned int len;
3362 unsigned int timeout;
3363 __u32 data;
3364};
3365
3366#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
3367
3368static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
3369{
3370 struct usbdevfs_bulktransfer kbulk;
3371 struct usbdevfs_bulktransfer32 *ubulk;
3372 mm_segment_t old_fs;
3373 __u32 udata;
3374 void *uptr, *kptr;
3375 int err;
3376
3377 ubulk = (struct usbdevfs_bulktransfer32 *) arg;
3378
3379 if (get_user(kbulk.ep, &ubulk->ep) ||
3380 get_user(kbulk.len, &ubulk->len) ||
3381 get_user(kbulk.timeout, &ubulk->timeout) ||
3382 get_user(udata, &ubulk->data))
3383 return -EFAULT;
3384
3385 uptr = (void *) A(udata);
3386
3387
3388
3389
3390 if (!uptr || kbulk.len > PAGE_SIZE)
3391 return -EINVAL;
3392
3393 kptr = (void *) __get_free_page(GFP_KERNEL);
3394
3395 if ((kbulk.ep & 0x80) == 0) {
3396 err = -EFAULT;
3397 if (copy_from_user(kptr, uptr, kbulk.len))
3398 goto out;
3399 }
3400
3401 kbulk.data = kptr;
3402
3403 old_fs = get_fs();
3404 set_fs(KERNEL_DS);
3405 err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
3406 set_fs(old_fs);
3407
3408 if (err >= 0 &&
3409 ((kbulk.ep & 0x80) != 0)) {
3410 if (copy_to_user(uptr, kptr, kbulk.len))
3411 err = -EFAULT;
3412 }
3413
3414out:
3415 free_page((unsigned long) kptr);
3416 return err;
3417}
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459#if 0
3460struct usbdevfs_urb32 {
3461 __u8 type;
3462 __u8 endpoint;
3463 __s32 status;
3464 __u32 flags;
3465 __u32 buffer;
3466 __s32 buffer_length;
3467 __s32 actual_length;
3468 __s32 start_frame;
3469 __s32 number_of_packets;
3470 __s32 error_count;
3471 __u32 signr;
3472 __u32 usercontext;
3473 struct usbdevfs_iso_packet_desc iso_frame_desc[0];
3474};
3475
3476#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
3477
3478static int get_urb32(struct usbdevfs_urb *kurb,
3479 struct usbdevfs_urb32 *uurb)
3480{
3481 if (get_user(kurb->type, &uurb->type) ||
3482 __get_user(kurb->endpoint, &uurb->endpoint) ||
3483 __get_user(kurb->status, &uurb->status) ||
3484 __get_user(kurb->flags, &uurb->flags) ||
3485 __get_user(kurb->buffer_length, &uurb->buffer_length) ||
3486 __get_user(kurb->actual_length, &uurb->actual_length) ||
3487 __get_user(kurb->start_frame, &uurb->start_frame) ||
3488 __get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
3489 __get_user(kurb->error_count, &uurb->error_count) ||
3490 __get_user(kurb->signr, &uurb->signr))
3491 return -EFAULT;
3492
3493 kurb->usercontext = 0;
3494
3495 return 0;
3496}
3497
3498
3499static int put_urb32(struct usbdevfs_urb *kurb,
3500 struct usbdevfs_urb32 *uurb)
3501{
3502 if (put_user(kurb->status, &uurb->status) ||
3503 __put_user(kurb->actual_length, &uurb->actual_length) ||
3504 __put_user(kurb->error_count, &uurb->error_count))
3505 return -EFAULT;
3506
3507 if (kurb->number_of_packets != 0) {
3508 int i;
3509
3510 for (i = 0; i < kurb->number_of_packets; i++) {
3511 if (__put_user(kurb->iso_frame_desc[i].actual_length,
3512 &uurb->iso_frame_desc[i].actual_length) ||
3513 __put_user(kurb->iso_frame_desc[i].status,
3514 &uurb->iso_frame_desc[i].status))
3515 return -EFAULT;
3516 }
3517 }
3518
3519 return 0;
3520}
3521
3522static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
3523 struct usbdevfs_urb32 *uurb)
3524{
3525 unsigned int totlen;
3526 int i;
3527
3528 if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
3529 kurb->number_of_packets = 0;
3530 return 0;
3531 }
3532
3533 if (kurb->number_of_packets < 1 ||
3534 kurb->number_of_packets > 128)
3535 return -EINVAL;
3536
3537 if (copy_from_user(&kurb->iso_frame_desc[0],
3538 &uurb->iso_frame_desc[0],
3539 sizeof(struct usbdevfs_iso_packet_desc) *
3540 kurb->number_of_packets))
3541 return -EFAULT;
3542
3543 totlen = 0;
3544 for (i = 0; i < kurb->number_of_packets; i++) {
3545 unsigned int this_len;
3546
3547 this_len = kurb->iso_frame_desc[i].length;
3548 if (this_len > 1023)
3549 return -EINVAL;
3550
3551 totlen += this_len;
3552 }
3553
3554 if (totlen > 32768)
3555 return -EINVAL;
3556
3557 kurb->buffer_length = totlen;
3558
3559 return 0;
3560}
3561
3562static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
3563{
3564 struct usbdevfs_urb *kurb;
3565 struct usbdevfs_urb32 *uurb;
3566 mm_segment_t old_fs;
3567 __u32 udata;
3568 void *uptr, *kptr;
3569 unsigned int buflen;
3570 int err;
3571
3572 uurb = (struct usbdevfs_urb32 *) arg;
3573
3574 err = -ENOMEM;
3575 kurb = kmalloc(sizeof(struct usbdevfs_urb) +
3576 (sizeof(struct usbdevfs_iso_packet_desc) * 128),
3577 GFP_KERNEL);
3578 if (!kurb)
3579 goto out;
3580
3581 err = -EFAULT;
3582 if (get_urb32(kurb, uurb))
3583 goto out;
3584
3585 err = get_urb32_isoframes(kurb, uurb);
3586 if (err)
3587 goto out;
3588
3589 err = -EFAULT;
3590 if (__get_user(udata, &uurb->buffer))
3591 goto out;
3592 uptr = (void *) A(udata);
3593
3594 buflen = kurb->buffer_length;
3595
3596 err = verify_area(VERIFY_WRITE, uptr, buflen);
3597 if (err)
3598 goto out;
3599
3600 old_fs = get_fs();
3601 set_fs(KERNEL_DS);
3602 err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
3603 set_fs(old_fs);
3604
3605 if (err >= 0) {
3606
3607 if (put_urb32(kurb, uurb)) {
3608 err = -EFAULT;
3609 }
3610 }
3611
3612out:
3613 kfree(kurb);
3614 return err;
3615}
3616#endif
3617
3618#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
3619#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
3620
3621static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
3622{
3623 mm_segment_t old_fs;
3624 void *kptr;
3625 int err;
3626
3627 old_fs = get_fs();
3628 set_fs(KERNEL_DS);
3629 err = sys_ioctl(fd,
3630 (cmd == USBDEVFS_REAPURB32 ?
3631 USBDEVFS_REAPURB :
3632 USBDEVFS_REAPURBNDELAY),
3633 (unsigned long) &kptr);
3634 set_fs(old_fs);
3635
3636 if (err >= 0 &&
3637 put_user(((u32)(long)kptr), (u32 *) A(arg)))
3638 err = -EFAULT;
3639
3640 return err;
3641}
3642
3643struct usbdevfs_disconnectsignal32 {
3644 unsigned int signr;
3645 u32 context;
3646};
3647
3648#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
3649
3650static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
3651{
3652 struct usbdevfs_disconnectsignal kdis;
3653 struct usbdevfs_disconnectsignal32 *udis;
3654 mm_segment_t old_fs;
3655 u32 uctx;
3656 int err;
3657
3658 udis = (struct usbdevfs_disconnectsignal32 *) arg;
3659
3660 if (get_user(kdis.signr, &udis->signr) ||
3661 __get_user(uctx, &udis->context))
3662 return -EFAULT;
3663
3664 kdis.context = (void *) (long)uctx;
3665
3666 old_fs = get_fs();
3667 set_fs(KERNEL_DS);
3668 err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
3669 set_fs(old_fs);
3670
3671 return err;
3672}
3673
3674struct mtd_oob_buf32 {
3675 u32 start;
3676 u32 length;
3677 u32 ptr;
3678};
3679
3680#define MEMWRITEOOB32 _IOWR('M',3,struct mtd_oob_buf32)
3681#define MEMREADOOB32 _IOWR('M',4,struct mtd_oob_buf32)
3682
3683static inline int
3684mtd_rw_oob(unsigned int fd, unsigned int cmd, unsigned long arg)
3685{
3686 mm_segment_t old_fs = get_fs();
3687 struct mtd_oob_buf32 *uarg = (struct mtd_oob_buf32 *)arg;
3688 struct mtd_oob_buf karg;
3689 u32 tmp;
3690 int ret;
3691
3692 if (get_user(karg.start, &uarg->start) ||
3693 get_user(karg.length, &uarg->length) ||
3694 get_user(tmp, &uarg->ptr))
3695 return -EFAULT;
3696
3697 karg.ptr = A(tmp);
3698 if (verify_area(VERIFY_WRITE, karg.ptr, karg.length))
3699 return -EFAULT;
3700
3701 set_fs(KERNEL_DS);
3702 if (MEMREADOOB32 == cmd)
3703 ret = sys_ioctl(fd, MEMREADOOB, (unsigned long)&karg);
3704 else if (MEMWRITEOOB32 == cmd)
3705 ret = sys_ioctl(fd, MEMWRITEOOB, (unsigned long)&karg);
3706 else
3707 ret = -EINVAL;
3708 set_fs(old_fs);
3709
3710 if (0 == ret && cmd == MEMREADOOB32) {
3711 ret = put_user(karg.start, &uarg->start);
3712 ret |= put_user(karg.length, &uarg->length);
3713 }
3714
3715 return ret;
3716}
3717
3718
3719#define BLKELVGET_32 _IOR(0x12,106,int)
3720#define BLKELVSET_32 _IOW(0x12,107,int)
3721#define BLKBSZGET_32 _IOR(0x12,112,int)
3722#define BLKBSZSET_32 _IOW(0x12,113,int)
3723#define BLKGETSIZE64_32 _IOR(0x12,114,int)
3724
3725static int do_blkelvget(unsigned int fd, unsigned int cmd, unsigned long arg)
3726{
3727 return sys_ioctl(fd, BLKELVGET, arg);
3728}
3729
3730static int do_blkelvset(unsigned int fd, unsigned int cmd, unsigned long arg)
3731{
3732 return sys_ioctl(fd, BLKELVSET, arg);
3733}
3734
3735static int do_blkbszget(unsigned int fd, unsigned int cmd, unsigned long arg)
3736{
3737 return sys_ioctl(fd, BLKBSZGET, arg);
3738}
3739
3740static int do_blkbszset(unsigned int fd, unsigned int cmd, unsigned long arg)
3741{
3742 return sys_ioctl(fd, BLKBSZSET, arg);
3743}
3744
3745static int do_blkgetsize64(unsigned int fd, unsigned int cmd,
3746 unsigned long arg)
3747{
3748 return sys_ioctl(fd, BLKGETSIZE64, arg);
3749}
3750
3751struct ioctl_trans {
3752 unsigned long cmd;
3753 unsigned long handler;
3754 unsigned long next;
3755};
3756
3757#define COMPATIBLE_IOCTL(cmd) { cmd, (unsigned long)sys_ioctl, 0 }
3758
3759#define HANDLE_IOCTL(cmd,handler) { cmd, (unsigned long)handler, 0 }
3760
3761#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
3762#define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, __kernel_uid_t32)
3763
3764static struct ioctl_trans ioctl_translations[] = {
3765
3766
3767
3768
3769COMPATIBLE_IOCTL(TCGETA),
3770COMPATIBLE_IOCTL(TCSETA),
3771COMPATIBLE_IOCTL(TCSETAW),
3772COMPATIBLE_IOCTL(TCSETAF),
3773COMPATIBLE_IOCTL(TCSBRK),
3774COMPATIBLE_IOCTL(TCSBRKP),
3775COMPATIBLE_IOCTL(TCXONC),
3776COMPATIBLE_IOCTL(TCFLSH),
3777COMPATIBLE_IOCTL(TCGETS),
3778COMPATIBLE_IOCTL(TCSETS),
3779COMPATIBLE_IOCTL(TCSETSW),
3780COMPATIBLE_IOCTL(TCSETSF),
3781COMPATIBLE_IOCTL(TIOCLINUX),
3782COMPATIBLE_IOCTL(TIOCSTART),
3783
3784COMPATIBLE_IOCTL(TIOCGETD),
3785COMPATIBLE_IOCTL(TIOCSETD),
3786COMPATIBLE_IOCTL(TIOCEXCL),
3787COMPATIBLE_IOCTL(TIOCNXCL),
3788COMPATIBLE_IOCTL(TIOCCONS),
3789COMPATIBLE_IOCTL(TIOCGSOFTCAR),
3790COMPATIBLE_IOCTL(TIOCSSOFTCAR),
3791COMPATIBLE_IOCTL(TIOCSWINSZ),
3792COMPATIBLE_IOCTL(TIOCGWINSZ),
3793COMPATIBLE_IOCTL(TIOCMGET),
3794COMPATIBLE_IOCTL(TIOCMBIC),
3795COMPATIBLE_IOCTL(TIOCMBIS),
3796COMPATIBLE_IOCTL(TIOCMSET),
3797COMPATIBLE_IOCTL(TIOCPKT),
3798COMPATIBLE_IOCTL(TIOCNOTTY),
3799COMPATIBLE_IOCTL(TIOCSTI),
3800COMPATIBLE_IOCTL(TIOCOUTQ),
3801COMPATIBLE_IOCTL(TIOCSPGRP),
3802COMPATIBLE_IOCTL(TIOCGPGRP),
3803COMPATIBLE_IOCTL(TIOCSCTTY),
3804COMPATIBLE_IOCTL(TIOCGPTN),
3805COMPATIBLE_IOCTL(TIOCSPTLCK),
3806COMPATIBLE_IOCTL(TIOCGSERIAL),
3807COMPATIBLE_IOCTL(TIOCSSERIAL),
3808COMPATIBLE_IOCTL(TIOCSERGETLSR),
3809COMPATIBLE_IOCTL(TIOCSLTC),
3810COMPATIBLE_IOCTL(TIOCMIWAIT),
3811COMPATIBLE_IOCTL(TIOCGICOUNT),
3812
3813COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO),
3814COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO),
3815COMPATIBLE_IOCTL(FBIOPAN_DISPLAY),
3816COMPATIBLE_IOCTL(FBIOGET_FCURSORINFO),
3817COMPATIBLE_IOCTL(FBIOGET_VCURSORINFO),
3818COMPATIBLE_IOCTL(FBIOPUT_VCURSORINFO),
3819COMPATIBLE_IOCTL(FBIOGET_CURSORSTATE),
3820COMPATIBLE_IOCTL(FBIOPUT_CURSORSTATE),
3821COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP),
3822COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP),
3823#if 0
3824COMPATIBLE_IOCTL(FBIOBLANK),
3825#endif
3826
3827COMPATIBLE_IOCTL(FIOCLEX),
3828COMPATIBLE_IOCTL(FIONCLEX),
3829COMPATIBLE_IOCTL(FIOASYNC),
3830COMPATIBLE_IOCTL(FIONBIO),
3831COMPATIBLE_IOCTL(FIONREAD),
3832
3833COMPATIBLE_IOCTL(FIBMAP),
3834COMPATIBLE_IOCTL(FIGETBSZ),
3835
3836
3837
3838COMPATIBLE_IOCTL(HDIO_GET_IDENTITY),
3839COMPATIBLE_IOCTL(HDIO_SET_DMA),
3840COMPATIBLE_IOCTL(HDIO_SET_KEEPSETTINGS),
3841COMPATIBLE_IOCTL(HDIO_SET_UNMASKINTR),
3842COMPATIBLE_IOCTL(HDIO_SET_NOWERR),
3843COMPATIBLE_IOCTL(HDIO_SET_32BIT),
3844COMPATIBLE_IOCTL(HDIO_SET_MULTCOUNT),
3845COMPATIBLE_IOCTL(HDIO_DRIVE_CMD),
3846COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE),
3847COMPATIBLE_IOCTL(HDIO_SCAN_HWIF),
3848COMPATIBLE_IOCTL(HDIO_SET_NICE),
3849
3850COMPATIBLE_IOCTL(FDMSGON),
3851COMPATIBLE_IOCTL(FDMSGOFF),
3852COMPATIBLE_IOCTL(FDSETEMSGTRESH),
3853COMPATIBLE_IOCTL(FDFLUSH),
3854COMPATIBLE_IOCTL(FDWERRORCLR),
3855COMPATIBLE_IOCTL(FDSETMAXERRS),
3856COMPATIBLE_IOCTL(FDGETMAXERRS),
3857COMPATIBLE_IOCTL(FDGETDRVTYP),
3858COMPATIBLE_IOCTL(FDEJECT),
3859COMPATIBLE_IOCTL(FDCLRPRM),
3860COMPATIBLE_IOCTL(FDFMTBEG),
3861COMPATIBLE_IOCTL(FDFMTEND),
3862COMPATIBLE_IOCTL(FDRESET),
3863COMPATIBLE_IOCTL(FDTWADDLE),
3864COMPATIBLE_IOCTL(FDFMTTRK),
3865COMPATIBLE_IOCTL(FDRAWCMD),
3866
3867COMPATIBLE_IOCTL(BLKROSET),
3868COMPATIBLE_IOCTL(BLKROGET),
3869COMPATIBLE_IOCTL(BLKRRPART),
3870COMPATIBLE_IOCTL(BLKFLSBUF),
3871COMPATIBLE_IOCTL(BLKRASET),
3872COMPATIBLE_IOCTL(BLKFRASET),
3873COMPATIBLE_IOCTL(BLKSECTSET),
3874COMPATIBLE_IOCTL(BLKSSZGET),
3875COMPATIBLE_IOCTL(BLKBSZGET),
3876COMPATIBLE_IOCTL(BLKBSZSET),
3877COMPATIBLE_IOCTL(BLKGETSIZE64),
3878
3879
3880COMPATIBLE_IOCTL(RAID_VERSION),
3881COMPATIBLE_IOCTL(RAID_AUTORUN),
3882COMPATIBLE_IOCTL(GET_ARRAY_INFO),
3883COMPATIBLE_IOCTL(GET_DISK_INFO),
3884COMPATIBLE_IOCTL(PRINT_RAID_DEBUG),
3885COMPATIBLE_IOCTL(CLEAR_ARRAY),
3886COMPATIBLE_IOCTL(ADD_NEW_DISK),
3887COMPATIBLE_IOCTL(HOT_REMOVE_DISK),
3888COMPATIBLE_IOCTL(SET_ARRAY_INFO),
3889COMPATIBLE_IOCTL(SET_DISK_INFO),
3890COMPATIBLE_IOCTL(WRITE_RAID_INFO),
3891COMPATIBLE_IOCTL(UNPROTECT_ARRAY),
3892COMPATIBLE_IOCTL(PROTECT_ARRAY),
3893COMPATIBLE_IOCTL(HOT_ADD_DISK),
3894COMPATIBLE_IOCTL(SET_DISK_FAULTY),
3895COMPATIBLE_IOCTL(RUN_ARRAY),
3896COMPATIBLE_IOCTL(START_ARRAY),
3897COMPATIBLE_IOCTL(STOP_ARRAY),
3898COMPATIBLE_IOCTL(STOP_ARRAY_RO),
3899COMPATIBLE_IOCTL(RESTART_ARRAY_RW),
3900
3901COMPATIBLE_IOCTL(PIO_FONT),
3902COMPATIBLE_IOCTL(GIO_FONT),
3903COMPATIBLE_IOCTL(KDSIGACCEPT),
3904COMPATIBLE_IOCTL(KDGETKEYCODE),
3905COMPATIBLE_IOCTL(KDSETKEYCODE),
3906COMPATIBLE_IOCTL(KIOCSOUND),
3907COMPATIBLE_IOCTL(KDMKTONE),
3908COMPATIBLE_IOCTL(KDGKBTYPE),
3909COMPATIBLE_IOCTL(KDSETMODE),
3910COMPATIBLE_IOCTL(KDGETMODE),
3911COMPATIBLE_IOCTL(KDSKBMODE),
3912COMPATIBLE_IOCTL(KDGKBMODE),
3913COMPATIBLE_IOCTL(KDSKBMETA),
3914COMPATIBLE_IOCTL(KDGKBMETA),
3915COMPATIBLE_IOCTL(KDGKBENT),
3916COMPATIBLE_IOCTL(KDSKBENT),
3917COMPATIBLE_IOCTL(KDGKBSENT),
3918COMPATIBLE_IOCTL(KDSKBSENT),
3919COMPATIBLE_IOCTL(KDGKBDIACR),
3920COMPATIBLE_IOCTL(KDKBDREP),
3921COMPATIBLE_IOCTL(KDSKBDIACR),
3922COMPATIBLE_IOCTL(KDGKBLED),
3923COMPATIBLE_IOCTL(KDSKBLED),
3924COMPATIBLE_IOCTL(KDGETLED),
3925COMPATIBLE_IOCTL(KDSETLED),
3926COMPATIBLE_IOCTL(GIO_SCRNMAP),
3927COMPATIBLE_IOCTL(PIO_SCRNMAP),
3928COMPATIBLE_IOCTL(GIO_UNISCRNMAP),
3929COMPATIBLE_IOCTL(PIO_UNISCRNMAP),
3930COMPATIBLE_IOCTL(PIO_FONTRESET),
3931COMPATIBLE_IOCTL(PIO_UNIMAPCLR),
3932
3933COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN),
3934COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST),
3935COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI),
3936COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK),
3937COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK),
3938COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY),
3939COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_ENABLE),
3940COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_DISABLE),
3941COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER),
3942COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND),
3943
3944COMPATIBLE_IOCTL(TUNSETNOCSUM),
3945COMPATIBLE_IOCTL(TUNSETDEBUG),
3946COMPATIBLE_IOCTL(TUNSETIFF),
3947COMPATIBLE_IOCTL(TUNSETPERSIST),
3948COMPATIBLE_IOCTL(TUNSETOWNER),
3949
3950COMPATIBLE_IOCTL(VT_SETMODE),
3951COMPATIBLE_IOCTL(VT_GETMODE),
3952COMPATIBLE_IOCTL(VT_GETSTATE),
3953COMPATIBLE_IOCTL(VT_OPENQRY),
3954COMPATIBLE_IOCTL(VT_ACTIVATE),
3955COMPATIBLE_IOCTL(VT_WAITACTIVE),
3956COMPATIBLE_IOCTL(VT_RELDISP),
3957COMPATIBLE_IOCTL(VT_DISALLOCATE),
3958COMPATIBLE_IOCTL(VT_RESIZE),
3959COMPATIBLE_IOCTL(VT_RESIZEX),
3960COMPATIBLE_IOCTL(VT_LOCKSWITCH),
3961COMPATIBLE_IOCTL(VT_UNLOCKSWITCH),
3962
3963COMPATIBLE_IOCTL(VIDIOCGCAP),
3964COMPATIBLE_IOCTL(VIDIOCGCHAN),
3965COMPATIBLE_IOCTL(VIDIOCSCHAN),
3966COMPATIBLE_IOCTL(VIDIOCGPICT),
3967COMPATIBLE_IOCTL(VIDIOCSPICT),
3968COMPATIBLE_IOCTL(VIDIOCCAPTURE),
3969COMPATIBLE_IOCTL(VIDIOCKEY),
3970COMPATIBLE_IOCTL(VIDIOCGAUDIO),
3971COMPATIBLE_IOCTL(VIDIOCSAUDIO),
3972COMPATIBLE_IOCTL(VIDIOCSYNC),
3973COMPATIBLE_IOCTL(VIDIOCMCAPTURE),
3974COMPATIBLE_IOCTL(VIDIOCGMBUF),
3975COMPATIBLE_IOCTL(VIDIOCGUNIT),
3976COMPATIBLE_IOCTL(VIDIOCGCAPTURE),
3977COMPATIBLE_IOCTL(VIDIOCSCAPTURE),
3978
3979COMPATIBLE_IOCTL(_IOW('v', BASE_VIDIOCPRIVATE+0, char [256])),
3980COMPATIBLE_IOCTL(_IOR('v', BASE_VIDIOCPRIVATE+1, char [256])),
3981COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int)),
3982COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])),
3983COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int)),
3984COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int)),
3985COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int)),
3986COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int)),
3987
3988COMPATIBLE_IOCTL(_IOR('p', 20, int[7])),
3989COMPATIBLE_IOCTL(_IOW('p', 21, int[7])),
3990COMPATIBLE_IOCTL(RTC_AIE_ON),
3991COMPATIBLE_IOCTL(RTC_AIE_OFF),
3992COMPATIBLE_IOCTL(RTC_UIE_ON),
3993COMPATIBLE_IOCTL(RTC_UIE_OFF),
3994COMPATIBLE_IOCTL(RTC_PIE_ON),
3995COMPATIBLE_IOCTL(RTC_PIE_OFF),
3996COMPATIBLE_IOCTL(RTC_WIE_ON),
3997COMPATIBLE_IOCTL(RTC_WIE_OFF),
3998COMPATIBLE_IOCTL(RTC_ALM_SET),
3999COMPATIBLE_IOCTL(RTC_ALM_READ),
4000COMPATIBLE_IOCTL(RTC_RD_TIME),
4001COMPATIBLE_IOCTL(RTC_SET_TIME),
4002COMPATIBLE_IOCTL(RTC_WKALM_SET),
4003COMPATIBLE_IOCTL(RTC_WKALM_RD),
4004
4005COMPATIBLE_IOCTL(MTIOCTOP),
4006
4007COMPATIBLE_IOCTL(FIOSETOWN),
4008COMPATIBLE_IOCTL(SIOCSPGRP),
4009COMPATIBLE_IOCTL(FIOGETOWN),
4010COMPATIBLE_IOCTL(SIOCGPGRP),
4011COMPATIBLE_IOCTL(SIOCATMARK),
4012COMPATIBLE_IOCTL(SIOCSIFLINK),
4013COMPATIBLE_IOCTL(SIOCSIFENCAP),
4014COMPATIBLE_IOCTL(SIOCGIFENCAP),
4015COMPATIBLE_IOCTL(SIOCSIFBR),
4016COMPATIBLE_IOCTL(SIOCGIFBR),
4017COMPATIBLE_IOCTL(SIOCSARP),
4018COMPATIBLE_IOCTL(SIOCGARP),
4019COMPATIBLE_IOCTL(SIOCDARP),
4020COMPATIBLE_IOCTL(SIOCSRARP),
4021COMPATIBLE_IOCTL(SIOCGRARP),
4022COMPATIBLE_IOCTL(SIOCDRARP),
4023COMPATIBLE_IOCTL(SIOCADDDLCI),
4024COMPATIBLE_IOCTL(SIOCDELDLCI),
4025COMPATIBLE_IOCTL(SIOCGIFVLAN),
4026COMPATIBLE_IOCTL(SIOCSIFVLAN),
4027
4028COMPATIBLE_IOCTL(SG_SET_TIMEOUT),
4029COMPATIBLE_IOCTL(SG_GET_TIMEOUT),
4030COMPATIBLE_IOCTL(SG_EMULATED_HOST),
4031COMPATIBLE_IOCTL(SG_SET_TRANSFORM),
4032COMPATIBLE_IOCTL(SG_GET_TRANSFORM),
4033COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE),
4034COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE),
4035COMPATIBLE_IOCTL(SG_GET_SCSI_ID),
4036COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA),
4037COMPATIBLE_IOCTL(SG_GET_LOW_DMA),
4038COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID),
4039COMPATIBLE_IOCTL(SG_GET_PACK_ID),
4040COMPATIBLE_IOCTL(SG_GET_NUM_WAITING),
4041COMPATIBLE_IOCTL(SG_SET_DEBUG),
4042COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE),
4043COMPATIBLE_IOCTL(SG_GET_COMMAND_Q),
4044COMPATIBLE_IOCTL(SG_SET_COMMAND_Q),
4045COMPATIBLE_IOCTL(SG_GET_VERSION_NUM),
4046COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN),
4047COMPATIBLE_IOCTL(SG_SCSI_RESET),
4048COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE),
4049COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN),
4050COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN),
4051
4052COMPATIBLE_IOCTL(PPPIOCGFLAGS),
4053COMPATIBLE_IOCTL(PPPIOCSFLAGS),
4054COMPATIBLE_IOCTL(PPPIOCGASYNCMAP),
4055COMPATIBLE_IOCTL(PPPIOCSASYNCMAP),
4056COMPATIBLE_IOCTL(PPPIOCGUNIT),
4057COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP),
4058COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP),
4059COMPATIBLE_IOCTL(PPPIOCGMRU),
4060COMPATIBLE_IOCTL(PPPIOCSMRU),
4061COMPATIBLE_IOCTL(PPPIOCSMAXCID),
4062COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP),
4063COMPATIBLE_IOCTL(LPGETSTATUS),
4064COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP),
4065COMPATIBLE_IOCTL(PPPIOCXFERUNIT),
4066COMPATIBLE_IOCTL(PPPIOCGNPMODE),
4067COMPATIBLE_IOCTL(PPPIOCSNPMODE),
4068COMPATIBLE_IOCTL(PPPIOCGDEBUG),
4069COMPATIBLE_IOCTL(PPPIOCSDEBUG),
4070COMPATIBLE_IOCTL(PPPIOCNEWUNIT),
4071COMPATIBLE_IOCTL(PPPIOCATTACH),
4072COMPATIBLE_IOCTL(PPPIOCDETACH),
4073COMPATIBLE_IOCTL(PPPIOCSMRRU),
4074COMPATIBLE_IOCTL(PPPIOCCONNECT),
4075COMPATIBLE_IOCTL(PPPIOCDISCONN),
4076COMPATIBLE_IOCTL(PPPIOCATTCHAN),
4077COMPATIBLE_IOCTL(PPPIOCGCHAN),
4078
4079COMPATIBLE_IOCTL(PPPOEIOCSFWD),
4080COMPATIBLE_IOCTL(PPPOEIOCDFWD),
4081
4082COMPATIBLE_IOCTL(CDROMPAUSE),
4083COMPATIBLE_IOCTL(CDROMRESUME),
4084COMPATIBLE_IOCTL(CDROMPLAYMSF),
4085COMPATIBLE_IOCTL(CDROMPLAYTRKIND),
4086COMPATIBLE_IOCTL(CDROMREADCOOKED),
4087COMPATIBLE_IOCTL(CDROMREADMODE1),
4088COMPATIBLE_IOCTL(CDROMREADMODE2),
4089COMPATIBLE_IOCTL(CDROMREADRAW),
4090COMPATIBLE_IOCTL(CDROMREADTOCHDR),
4091COMPATIBLE_IOCTL(CDROMREADTOCENTRY),
4092COMPATIBLE_IOCTL(CDROMSTOP),
4093COMPATIBLE_IOCTL(CDROMSTART),
4094COMPATIBLE_IOCTL(CDROMEJECT),
4095COMPATIBLE_IOCTL(CDROMVOLCTRL),
4096COMPATIBLE_IOCTL(CDROMSUBCHNL),
4097COMPATIBLE_IOCTL(CDROMEJECT_SW),
4098COMPATIBLE_IOCTL(CDROMMULTISESSION),
4099COMPATIBLE_IOCTL(CDROM_GET_MCN),
4100COMPATIBLE_IOCTL(CDROMRESET),
4101COMPATIBLE_IOCTL(CDROMVOLREAD),
4102COMPATIBLE_IOCTL(CDROMSEEK),
4103COMPATIBLE_IOCTL(CDROMPLAYBLK),
4104COMPATIBLE_IOCTL(CDROMCLOSETRAY),
4105COMPATIBLE_IOCTL(CDROM_SET_OPTIONS),
4106COMPATIBLE_IOCTL(CDROM_CLEAR_OPTIONS),
4107COMPATIBLE_IOCTL(CDROM_SELECT_SPEED),
4108COMPATIBLE_IOCTL(CDROM_SELECT_DISC),
4109COMPATIBLE_IOCTL(CDROM_MEDIA_CHANGED),
4110COMPATIBLE_IOCTL(CDROM_DRIVE_STATUS),
4111COMPATIBLE_IOCTL(CDROM_DISC_STATUS),
4112COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS),
4113COMPATIBLE_IOCTL(CDROM_LOCKDOOR),
4114COMPATIBLE_IOCTL(CDROM_DEBUG),
4115COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY),
4116
4117COMPATIBLE_IOCTL(DVD_READ_STRUCT),
4118COMPATIBLE_IOCTL(DVD_WRITE_STRUCT),
4119COMPATIBLE_IOCTL(DVD_AUTH),
4120
4121COMPATIBLE_IOCTL(LOOP_SET_FD),
4122COMPATIBLE_IOCTL(LOOP_CLR_FD),
4123
4124COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET),
4125COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC),
4126COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO),
4127COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE),
4128COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT),
4129COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT),
4130COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE),
4131COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR),
4132COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI),
4133COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES),
4134COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS),
4135COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS),
4136COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO),
4137COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD),
4138COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL),
4139COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE),
4140COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC),
4141COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND),
4142COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME),
4143COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID),
4144COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL),
4145COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE),
4146
4147COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE),
4148COMPATIBLE_IOCTL(SNDCTL_TMR_START),
4149COMPATIBLE_IOCTL(SNDCTL_TMR_STOP),
4150COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE),
4151COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO),
4152COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE),
4153COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME),
4154COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT),
4155
4156COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME),
4157COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE),
4158COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD),
4159
4160COMPATIBLE_IOCTL(SNDCTL_DSP_RESET),
4161COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC),
4162COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED),
4163COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO),
4164COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE),
4165COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS),
4166COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER),
4167COMPATIBLE_IOCTL(SNDCTL_DSP_POST),
4168COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE),
4169COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT),
4170COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS),
4171COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT),
4172COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE),
4173COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE),
4174COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK),
4175COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS),
4176COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER),
4177COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER),
4178COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR),
4179COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR),
4180
4181
4182COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO),
4183COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX),
4184COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY),
4185COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE),
4186COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE),
4187COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS),
4188COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS),
4189COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER),
4190
4191COMPATIBLE_IOCTL(SNDCTL_COPR_RESET),
4192COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD),
4193COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA),
4194COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE),
4195COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA),
4196COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE),
4197COMPATIBLE_IOCTL(SNDCTL_COPR_RUN),
4198COMPATIBLE_IOCTL(SNDCTL_COPR_HALT),
4199COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG),
4200COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG),
4201
4202COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME),
4203COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS),
4204COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE),
4205COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH),
4206COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM),
4207COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER),
4208COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE),
4209COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC),
4210COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD),
4211COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX),
4212COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM),
4213COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV),
4214COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN),
4215COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN),
4216COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1),
4217COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2),
4218COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3),
4219COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1)),
4220COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2)),
4221COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3)),
4222COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN)),
4223COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT)),
4224COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO)),
4225COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO)),
4226COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR)),
4227COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE),
4228
4229
4230COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC),
4231COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK),
4232COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK),
4233COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS),
4234COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS),
4235COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME),
4236COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS),
4237COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE),
4238COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH),
4239COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM),
4240COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER),
4241COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE),
4242COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC),
4243COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD),
4244COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX),
4245COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM),
4246COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV),
4247COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN),
4248COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN),
4249COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1),
4250COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2),
4251COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3),
4252COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1)),
4253COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2)),
4254COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3)),
4255COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN)),
4256COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT)),
4257COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO)),
4258COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO)),
4259COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR)),
4260COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE),
4261
4262
4263COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC),
4264COMPATIBLE_IOCTL(SOUND_MIXER_INFO),
4265COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO),
4266COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS),
4267COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1),
4268COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2),
4269COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3),
4270COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4),
4271COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5),
4272COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS),
4273COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS),
4274COMPATIBLE_IOCTL(OSS_GETVERSION),
4275
4276COMPATIBLE_IOCTL(AUTOFS_IOC_READY),
4277COMPATIBLE_IOCTL(AUTOFS_IOC_FAIL),
4278COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC),
4279COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER),
4280COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE),
4281COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI),
4282COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOSUBVER),
4283COMPATIBLE_IOCTL(AUTOFS_IOC_ASKREGHOST),
4284COMPATIBLE_IOCTL(AUTOFS_IOC_TOGGLEREGHOST),
4285COMPATIBLE_IOCTL(AUTOFS_IOC_ASKUMOUNT),
4286
4287COMPATIBLE_IOCTL(DEVFSDIOC_GET_PROTO_REV),
4288COMPATIBLE_IOCTL(DEVFSDIOC_SET_EVENT_MASK),
4289COMPATIBLE_IOCTL(DEVFSDIOC_RELEASE_EVENT_QUEUE),
4290COMPATIBLE_IOCTL(DEVFSDIOC_SET_DEBUG_MASK),
4291
4292COMPATIBLE_IOCTL(RAW_SETBIND),
4293COMPATIBLE_IOCTL(RAW_GETBIND),
4294
4295COMPATIBLE_IOCTL(SMB_IOC_NEWCONN),
4296
4297COMPATIBLE_IOCTL(ATMSIGD_CTRL),
4298COMPATIBLE_IOCTL(ATMARPD_CTRL),
4299COMPATIBLE_IOCTL(ATMLEC_CTRL),
4300COMPATIBLE_IOCTL(ATMLEC_MCAST),
4301COMPATIBLE_IOCTL(ATMLEC_DATA),
4302COMPATIBLE_IOCTL(ATM_SETSC),
4303COMPATIBLE_IOCTL(SIOCSIFATMTCP),
4304COMPATIBLE_IOCTL(SIOCMKCLIP),
4305COMPATIBLE_IOCTL(ATMARP_MKIP),
4306COMPATIBLE_IOCTL(ATMARP_SETENTRY),
4307COMPATIBLE_IOCTL(ATMARP_ENCAP),
4308COMPATIBLE_IOCTL(ATMTCP_CREATE),
4309COMPATIBLE_IOCTL(ATMTCP_REMOVE),
4310COMPATIBLE_IOCTL(ATMMPC_CTRL),
4311COMPATIBLE_IOCTL(ATMMPC_DATA),
4312#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
4313
4314COMPATIBLE_IOCTL(VG_SET_EXTENDABLE),
4315COMPATIBLE_IOCTL(VG_STATUS_GET_COUNT),
4316COMPATIBLE_IOCTL(VG_STATUS_GET_NAMELIST),
4317COMPATIBLE_IOCTL(VG_REMOVE),
4318COMPATIBLE_IOCTL(VG_RENAME),
4319COMPATIBLE_IOCTL(VG_REDUCE),
4320COMPATIBLE_IOCTL(PE_LOCK_UNLOCK),
4321COMPATIBLE_IOCTL(PV_FLUSH),
4322COMPATIBLE_IOCTL(LVM_LOCK_LVM),
4323COMPATIBLE_IOCTL(LVM_GET_IOP_VERSION),
4324#ifdef LVM_TOTAL_RESET
4325COMPATIBLE_IOCTL(LVM_RESET),
4326#endif
4327COMPATIBLE_IOCTL(LV_SET_ACCESS),
4328COMPATIBLE_IOCTL(LV_SET_STATUS),
4329COMPATIBLE_IOCTL(LV_SET_ALLOCATION),
4330COMPATIBLE_IOCTL(LE_REMAP),
4331COMPATIBLE_IOCTL(LV_BMAP),
4332COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE),
4333#endif
4334#if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
4335COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC),
4336COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID),
4337COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC),
4338COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK),
4339COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK),
4340COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL),
4341COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS),
4342COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS),
4343COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX),
4344COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX),
4345COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX),
4346COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX),
4347COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX),
4348COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX),
4349COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW),
4350COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW),
4351COMPATIBLE_IOCTL(DRM_IOCTL_LOCK),
4352COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK),
4353COMPATIBLE_IOCTL(DRM_IOCTL_FINISH),
4354#endif
4355
4356COMPATIBLE_IOCTL(BLKELVGET),
4357COMPATIBLE_IOCTL(BLKELVSET),
4358
4359
4360COMPATIBLE_IOCTL(WDIOC_GETSTATUS),
4361COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS),
4362COMPATIBLE_IOCTL(WDIOC_GETTEMP),
4363COMPATIBLE_IOCTL(WDIOC_SETOPTIONS),
4364COMPATIBLE_IOCTL(WDIOC_KEEPALIVE),
4365
4366COMPATIBLE_IOCTL(RNDGETENTCNT),
4367COMPATIBLE_IOCTL(RNDADDTOENTCNT),
4368COMPATIBLE_IOCTL(RNDGETPOOL),
4369COMPATIBLE_IOCTL(RNDADDENTROPY),
4370COMPATIBLE_IOCTL(RNDZAPENTCNT),
4371COMPATIBLE_IOCTL(RNDCLEARPOOL),
4372
4373COMPATIBLE_IOCTL(HCIDEVUP),
4374COMPATIBLE_IOCTL(HCIDEVDOWN),
4375COMPATIBLE_IOCTL(HCIDEVRESET),
4376COMPATIBLE_IOCTL(HCIDEVRESTAT),
4377COMPATIBLE_IOCTL(HCIGETDEVINFO),
4378COMPATIBLE_IOCTL(HCIGETDEVLIST),
4379COMPATIBLE_IOCTL(HCISETRAW),
4380COMPATIBLE_IOCTL(HCISETSCAN),
4381COMPATIBLE_IOCTL(HCISETAUTH),
4382COMPATIBLE_IOCTL(HCIINQUIRY),
4383COMPATIBLE_IOCTL(PCIIOC_CONTROLLER),
4384COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO),
4385COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM),
4386COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE),
4387
4388COMPATIBLE_IOCTL(USBDEVFS_RESETEP),
4389COMPATIBLE_IOCTL(USBDEVFS_SETINTERFACE),
4390COMPATIBLE_IOCTL(USBDEVFS_SETCONFIGURATION),
4391COMPATIBLE_IOCTL(USBDEVFS_GETDRIVER),
4392COMPATIBLE_IOCTL(USBDEVFS_DISCARDURB),
4393COMPATIBLE_IOCTL(USBDEVFS_CLAIMINTERFACE),
4394COMPATIBLE_IOCTL(USBDEVFS_RELEASEINTERFACE),
4395COMPATIBLE_IOCTL(USBDEVFS_CONNECTINFO),
4396COMPATIBLE_IOCTL(USBDEVFS_HUB_PORTINFO),
4397COMPATIBLE_IOCTL(USBDEVFS_RESET),
4398COMPATIBLE_IOCTL(USBDEVFS_CLEAR_HALT),
4399
4400COMPATIBLE_IOCTL(MEMGETINFO),
4401COMPATIBLE_IOCTL(MEMERASE),
4402COMPATIBLE_IOCTL(MEMLOCK),
4403COMPATIBLE_IOCTL(MEMUNLOCK),
4404COMPATIBLE_IOCTL(MEMGETREGIONCOUNT),
4405COMPATIBLE_IOCTL(MEMGETREGIONINFO),
4406
4407COMPATIBLE_IOCTL(NBD_SET_SOCK),
4408COMPATIBLE_IOCTL(NBD_SET_BLKSIZE),
4409COMPATIBLE_IOCTL(NBD_SET_SIZE),
4410COMPATIBLE_IOCTL(NBD_DO_IT),
4411COMPATIBLE_IOCTL(NBD_CLEAR_SOCK),
4412COMPATIBLE_IOCTL(NBD_CLEAR_QUE),
4413COMPATIBLE_IOCTL(NBD_PRINT_DEBUG),
4414COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS),
4415COMPATIBLE_IOCTL(NBD_DISCONNECT),
4416
4417COMPATIBLE_IOCTL(SIOCDEVPRIVATE),
4418COMPATIBLE_IOCTL(SIOCDEVPRIVATE+1),
4419COMPATIBLE_IOCTL(SIOCDEVPRIVATE+2),
4420COMPATIBLE_IOCTL(SIOCGMIIPHY),
4421COMPATIBLE_IOCTL(SIOCGMIIREG),
4422COMPATIBLE_IOCTL(SIOCSMIIREG),
4423
4424HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob),
4425HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob),
4426#ifdef CONFIG_NET
4427HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32),
4428#endif
4429HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf),
4430HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc),
4431HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc),
4432HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc),
4433HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc),
4434HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc),
4435HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc),
4436HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc),
4437HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc),
4438HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc),
4439HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc),
4440HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc),
4441HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc),
4442HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc),
4443HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc),
4444HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc),
4445HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc),
4446HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc),
4447HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc),
4448HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc),
4449HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc),
4450HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc),
4451HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc),
4452HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc),
4453HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc),
4454HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc),
4455HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc),
4456HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc),
4457HANDLE_IOCTL(SIOCETHTOOL, ethtool_ioctl),
4458HANDLE_IOCTL(SIOCBONDENSLAVE, bond_ioctl),
4459HANDLE_IOCTL(SIOCBONDRELEASE, bond_ioctl),
4460HANDLE_IOCTL(SIOCBONDSETHWADDR, bond_ioctl),
4461HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY, bond_ioctl),
4462HANDLE_IOCTL(SIOCBONDINFOQUERY, bond_ioctl),
4463HANDLE_IOCTL(SIOCBONDCHANGEACTIVE, bond_ioctl),
4464HANDLE_IOCTL(SIOCADDRT, routing_ioctl),
4465HANDLE_IOCTL(SIOCDELRT, routing_ioctl),
4466
4467
4468HANDLE_IOCTL(SIOCRTMSG, ret_einval),
4469HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp),
4470HANDLE_IOCTL(HDIO_GETGEO, hdio_getgeo),
4471HANDLE_IOCTL(HDIO_GETGEO_BIG, hdio_getgeo_big),
4472HANDLE_IOCTL(HDIO_GETGEO_BIG_RAW, hdio_getgeo_big),
4473HANDLE_IOCTL(BLKRAGET, w_long),
4474HANDLE_IOCTL(BLKGETSIZE, w_long),
4475HANDLE_IOCTL(0x1260, broken_blkgetsize),
4476HANDLE_IOCTL(BLKFRAGET, w_long),
4477HANDLE_IOCTL(BLKSECTGET, w_long),
4478HANDLE_IOCTL(BLKPG, blkpg_ioctl_trans),
4479HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans),
4480HANDLE_IOCTL(HDIO_GET_UNMASKINTR, hdio_ioctl_trans),
4481HANDLE_IOCTL(HDIO_GET_DMA, hdio_ioctl_trans),
4482HANDLE_IOCTL(HDIO_GET_32BIT, hdio_ioctl_trans),
4483HANDLE_IOCTL(HDIO_GET_MULTCOUNT, hdio_ioctl_trans),
4484HANDLE_IOCTL(HDIO_GET_NOWERR, hdio_ioctl_trans),
4485HANDLE_IOCTL(HDIO_GET_NICE, hdio_ioctl_trans),
4486HANDLE_IOCTL(FDSETPRM32, fd_ioctl_trans),
4487HANDLE_IOCTL(FDDEFPRM32, fd_ioctl_trans),
4488HANDLE_IOCTL(FDGETPRM32, fd_ioctl_trans),
4489HANDLE_IOCTL(FDSETDRVPRM32, fd_ioctl_trans),
4490HANDLE_IOCTL(FDGETDRVPRM32, fd_ioctl_trans),
4491HANDLE_IOCTL(FDGETDRVSTAT32, fd_ioctl_trans),
4492HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans),
4493HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans),
4494HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans),
4495HANDLE_IOCTL(SG_IO,sg_ioctl_trans),
4496HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans),
4497HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans),
4498HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans),
4499HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans),
4500HANDLE_IOCTL(MTIOCGETCONFIG32, mt_ioctl_trans),
4501HANDLE_IOCTL(MTIOCSETCONFIG32, mt_ioctl_trans),
4502HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans),
4503HANDLE_IOCTL(CDROMREADALL, cdrom_ioctl_trans),
4504HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans),
4505HANDLE_IOCTL(LOOP_SET_STATUS, loop_status),
4506HANDLE_IOCTL(LOOP_GET_STATUS, loop_status),
4507HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout),
4508#ifdef CONFIG_VT
4509HANDLE_IOCTL(PIO_FONTX, do_fontx_ioctl),
4510HANDLE_IOCTL(GIO_FONTX, do_fontx_ioctl),
4511HANDLE_IOCTL(PIO_UNIMAP, do_unimap_ioctl),
4512HANDLE_IOCTL(GIO_UNIMAP, do_unimap_ioctl),
4513HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl),
4514HANDLE_IOCTL(FBIOGET_FSCREENINFO, do_fbioget_fscreeninfo_ioctl),
4515HANDLE_IOCTL(FBIOGETCMAP, do_fbiogetcmap_ioctl),
4516HANDLE_IOCTL(FBIOPUTCMAP, do_fbioputcmap_ioctl),
4517#endif
4518HANDLE_IOCTL(EXT2_IOC32_GETFLAGS, do_ext2_ioctl),
4519HANDLE_IOCTL(EXT2_IOC32_SETFLAGS, do_ext2_ioctl),
4520HANDLE_IOCTL(EXT2_IOC32_GETVERSION, do_ext2_ioctl),
4521HANDLE_IOCTL(EXT2_IOC32_SETVERSION, do_ext2_ioctl),
4522HANDLE_IOCTL(VIDIOCGTUNER32, do_video_ioctl),
4523HANDLE_IOCTL(VIDIOCSTUNER32, do_video_ioctl),
4524HANDLE_IOCTL(VIDIOCGWIN32, do_video_ioctl),
4525HANDLE_IOCTL(VIDIOCSWIN32, do_video_ioctl),
4526HANDLE_IOCTL(VIDIOCGFBUF32, do_video_ioctl),
4527HANDLE_IOCTL(VIDIOCSFBUF32, do_video_ioctl),
4528HANDLE_IOCTL(VIDIOCGFREQ32, do_video_ioctl),
4529HANDLE_IOCTL(VIDIOCSFREQ32, do_video_ioctl),
4530
4531HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid),
4532HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl),
4533HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl),
4534HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl),
4535HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl),
4536HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl),
4537HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl),
4538HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl),
4539HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl),
4540HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl),
4541HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl),
4542HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl),
4543HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl),
4544HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl),
4545HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl),
4546HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl),
4547HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl),
4548HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl),
4549HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl),
4550HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl),
4551HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl),
4552HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl),
4553HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl),
4554HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl),
4555HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl),
4556HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl),
4557#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
4558HANDLE_IOCTL(VG_STATUS, do_lvm_ioctl),
4559HANDLE_IOCTL(VG_CREATE_OLD, do_lvm_ioctl),
4560HANDLE_IOCTL(VG_CREATE, do_lvm_ioctl),
4561HANDLE_IOCTL(VG_EXTEND, do_lvm_ioctl),
4562HANDLE_IOCTL(LV_CREATE, do_lvm_ioctl),
4563HANDLE_IOCTL(LV_REMOVE, do_lvm_ioctl),
4564HANDLE_IOCTL(LV_EXTEND, do_lvm_ioctl),
4565HANDLE_IOCTL(LV_REDUCE, do_lvm_ioctl),
4566HANDLE_IOCTL(LV_RENAME, do_lvm_ioctl),
4567HANDLE_IOCTL(LV_STATUS_BYNAME, do_lvm_ioctl),
4568HANDLE_IOCTL(LV_STATUS_BYINDEX, do_lvm_ioctl),
4569HANDLE_IOCTL(LV_STATUS_BYDEV, do_lvm_ioctl),
4570HANDLE_IOCTL(PV_CHANGE, do_lvm_ioctl),
4571HANDLE_IOCTL(PV_STATUS, do_lvm_ioctl),
4572#endif
4573#if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
4574HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version),
4575HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique),
4576HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique),
4577HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap),
4578HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs),
4579HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs),
4580HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs),
4581HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma),
4582HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx),
4583#endif
4584HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control),
4585HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk),
4586
4587HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb),
4588HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb),
4589HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal),
4590
4591
4592HANDLE_IOCTL(BLKELVGET_32, do_blkelvget),
4593HANDLE_IOCTL(BLKELVSET_32, do_blkelvset),
4594
4595HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget),
4596HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset),
4597HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64),
4598};
4599
4600unsigned long ioctl32_hash_table[1024];
4601
4602static inline unsigned long ioctl32_hash(unsigned long cmd)
4603{
4604 return ((cmd >> 6) ^ (cmd >> 4) ^ cmd) & 0x3ff;
4605}
4606
4607static void ioctl32_insert_translation(struct ioctl_trans *trans)
4608{
4609 unsigned long hash;
4610 struct ioctl_trans *t;
4611
4612 hash = ioctl32_hash (trans->cmd);
4613 if (!ioctl32_hash_table[hash])
4614 ioctl32_hash_table[hash] = (long)trans;
4615 else {
4616 t = (struct ioctl_trans *)ioctl32_hash_table[hash];
4617 while (t->next)
4618 t = (struct ioctl_trans *)(long)t->next;
4619 trans->next = 0;
4620 t->next = (long)trans;
4621 }
4622}
4623
4624static int __init init_sys32_ioctl(void)
4625{
4626 int i, size = sizeof(ioctl_translations) / sizeof(struct ioctl_trans);
4627 for (i=0; i < size ;i++)
4628 ioctl32_insert_translation(&ioctl_translations[i]);
4629 return 0;
4630}
4631
4632__initcall(init_sys32_ioctl);
4633
4634static struct ioctl_trans *additional_ioctls;
4635
4636
4637
4638int register_ioctl32_conversion(unsigned int cmd, int (*handler)(unsigned int, unsigned int, unsigned long, struct file *))
4639{
4640 int i;
4641 if (!additional_ioctls) {
4642 additional_ioctls = module_map(PAGE_SIZE);
4643 if (!additional_ioctls)
4644 return -ENOMEM;
4645 memset(additional_ioctls, 0, PAGE_SIZE);
4646 }
4647 for (i = 0; i < PAGE_SIZE/sizeof(struct ioctl_trans); i++)
4648 if (!additional_ioctls[i].cmd)
4649 break;
4650 if (i == PAGE_SIZE/sizeof(struct ioctl_trans))
4651 return -ENOMEM;
4652 additional_ioctls[i].cmd = cmd;
4653 if (!handler)
4654 additional_ioctls[i].handler = (long)sys_ioctl;
4655 else
4656 additional_ioctls[i].handler = (long)handler;
4657 ioctl32_insert_translation(&additional_ioctls[i]);
4658 return 0;
4659}
4660
4661int unregister_ioctl32_conversion(unsigned int cmd)
4662{
4663 unsigned long hash = ioctl32_hash(cmd);
4664 struct ioctl_trans *t, *t1;
4665
4666 t = (struct ioctl_trans *)ioctl32_hash_table[hash];
4667 if (!t) return -EINVAL;
4668 if (t->cmd == cmd && t >= additional_ioctls &&
4669 (unsigned long)t < ((unsigned long)additional_ioctls) + PAGE_SIZE) {
4670 ioctl32_hash_table[hash] = t->next;
4671 t->cmd = 0;
4672 return 0;
4673 } else while (t->next) {
4674 t1 = (struct ioctl_trans *)t->next;
4675 if (t1->cmd == cmd && t1 >= additional_ioctls &&
4676 (unsigned long)t1 < ((unsigned long)additional_ioctls) + PAGE_SIZE) {
4677 t1->cmd = 0;
4678 t->next = t1->next;
4679 return 0;
4680 }
4681 t = t1;
4682 }
4683 return -EINVAL;
4684}
4685
4686asmlinkage int sys32_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
4687{
4688 struct file * filp;
4689 int error = -EBADF;
4690 int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
4691 struct ioctl_trans *t;
4692
4693 filp = fget(fd);
4694 if (!filp)
4695 goto out2;
4696
4697 if (!filp->f_op || !filp->f_op->ioctl) {
4698 error = sys_ioctl (fd, cmd, arg);
4699 goto out;
4700 }
4701
4702 t = (struct ioctl_trans *)ioctl32_hash_table [ioctl32_hash (cmd)];
4703
4704 while (t && t->cmd != cmd)
4705 t = (struct ioctl_trans *)t->next;
4706 if (t) {
4707 handler = (void *)t->handler;
4708 error = handler(fd, cmd, arg, filp);
4709 } else {
4710 static int count = 0;
4711 if (++count <= 20)
4712 printk("sys32_ioctl(%s:%d): Unknown cmd fd(%d) "
4713 "cmd(%08x) arg(%08x)\n",
4714 current->comm, current->pid,
