1
2
3
4
5
6
7
8
9
10
11#include <linux/config.h>
12#include <linux/types.h>
13#include <linux/kernel.h>
14#include <linux/sched.h>
15#include <linux/sched.h>
16#include <linux/smp.h>
17#include <linux/smp_lock.h>
18#include <linux/ioctl.h>
19#include <linux/if.h>
20#include <linux/slab.h>
21#include <linux/hdreg.h>
22#include <linux/raid/md_u.h>
23#include <linux/kd.h>
24#include <linux/route.h>
25#include <linux/vt.h>
26#include <linux/fs.h>
27#include <linux/ppp_defs.h>
28#include <linux/if_ppp.h>
29#include <linux/if_pppox.h>
30#include <linux/if_tun.h>
31#include <linux/mtio.h>
32#include <linux/cdrom.h>
33#include <linux/loop.h>
34#include <linux/auto_fs.h>
35#include <linux/auto_fs4.h>
36#include <linux/devfs_fs.h>
37#include <linux/tty.h>
38#include <linux/vt_kern.h>
39#include <linux/fb.h>
40#include <linux/ext2_fs.h>
41#include <linux/videodev.h>
42#include <linux/netdevice.h>
43#include <linux/raw.h>
44#include <linux/blkpg.h>
45#include <linux/blk.h>
46#include <linux/elevator.h>
47#include <linux/file.h>
48#include <linux/rtc.h>
49#include <linux/pci.h>
50#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
51#include <linux/lvm.h>
52#endif
53
54#include <scsi/scsi.h>
55#undef __KERNEL__
56#include <scsi/scsi_ioctl.h>
57#define __KERNEL__
58#include <scsi/sg.h>
59
60#include <asm/types.h>
61#include <asm/uaccess.h>
62#include <linux/soundcard.h>
63
64#include <linux/mtd/mtd.h>
65#include <linux/serial.h>
66
67#ifdef CONFIG_SIBYTE_TBPROF
68#include <asm/sibyte/trace_prof.h>
69#endif
70
71long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
72
73static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
74{
75 mm_segment_t old_fs = get_fs();
76 int err;
77 unsigned long val;
78
79 set_fs (KERNEL_DS);
80 err = sys_ioctl(fd, cmd, (unsigned long)&val);
81 set_fs (old_fs);
82 if (!err && put_user((unsigned int) val, (u32 *)arg))
83 return -EFAULT;
84 return err;
85}
86
87static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
88{
89 mm_segment_t old_fs = get_fs();
90 int err;
91 unsigned long val;
92
93 if (get_user(val, (u32 *)arg))
94 return -EFAULT;
95 set_fs(KERNEL_DS);
96 err = sys_ioctl(fd, cmd, (unsigned long)&val);
97 set_fs (old_fs);
98 if (!err && put_user(val, (u32 *)arg))
99 return -EFAULT;
100 return err;
101}
102
103#define A(__x) ((unsigned long)(__x))
104
105
106#ifdef CONFIG_FB
107
108struct fb_fix_screeninfo32 {
109 char id[16];
110 __u32 smem_start;
111
112 __u32 smem_len;
113 __u32 type;
114 __u32 type_aux;
115 __u32 visual;
116 __u16 xpanstep;
117 __u16 ypanstep;
118 __u16 ywrapstep;
119 __u32 line_length;
120 __u32 mmio_start;
121
122 __u32 mmio_len;
123 __u32 accel;
124 __u16 reserved[3];
125};
126
127static int do_fbioget_fscreeninfo_ioctl(unsigned int fd, unsigned int cmd,
128 unsigned long arg)
129{
130 mm_segment_t old_fs = get_fs();
131 struct fb_fix_screeninfo fix;
132 struct fb_fix_screeninfo32 *fix32 = (struct fb_fix_screeninfo32 *)arg;
133 int err;
134
135 set_fs(KERNEL_DS);
136 err = sys_ioctl(fd, cmd, (unsigned long)&fix);
137 set_fs(old_fs);
138
139 if (err == 0) {
140 err = __copy_to_user((char *)fix32->id, (char *)fix.id,
141 sizeof(fix.id));
142 err |= __put_user((__u32)(unsigned long)fix.smem_start,
143 &fix32->smem_start);
144 err |= __put_user(fix.smem_len, &fix32->smem_len);
145 err |= __put_user(fix.type, &fix32->type);
146 err |= __put_user(fix.type_aux, &fix32->type_aux);
147 err |= __put_user(fix.visual, &fix32->visual);
148 err |= __put_user(fix.xpanstep, &fix32->xpanstep);
149 err |= __put_user(fix.ypanstep, &fix32->ypanstep);
150 err |= __put_user(fix.ywrapstep, &fix32->ywrapstep);
151 err |= __put_user(fix.line_length, &fix32->line_length);
152 err |= __put_user((__u32)(unsigned long)fix.mmio_start,
153 &fix32->mmio_start);
154 err |= __put_user(fix.mmio_len, &fix32->mmio_len);
155 err |= __put_user(fix.accel, &fix32->accel);
156 err |= __copy_to_user((char *)fix32->reserved,
157 (char *)fix.reserved,
158 sizeof(fix.reserved));
159 if (err)
160 err = -EFAULT;
161 }
162
163 return err;
164}
165
166struct fb_cmap32 {
167 __u32 start;
168 __u32 len;
169 __u32 red;
170 __u32 green;
171 __u32 blue;
172 __u32 transp;
173};
174
175static int do_fbiocmap_ioctl(unsigned int fd, unsigned int cmd,
176 unsigned long arg)
177{
178 mm_segment_t old_fs = get_fs();
179 u32 red = 0, green = 0, blue = 0, transp = 0;
180 struct fb_cmap cmap;
181 struct fb_cmap32 *cmap32 = (struct fb_cmap32 *)arg;
182 int err;
183
184 memset(&cmap, 0, sizeof(cmap));
185
186 err = __get_user(cmap.start, &cmap32->start);
187 err |= __get_user(cmap.len, &cmap32->len);
188 err |= __get_user(red, &cmap32->red);
189 err |= __get_user(green, &cmap32->green);
190 err |= __get_user(blue, &cmap32->blue);
191 err |= __get_user(transp, &cmap32->transp);
192 if (err)
193 return -EFAULT;
194
195 err = -ENOMEM;
196 cmap.red = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
197 if (!cmap.red)
198 goto out;
199 cmap.green = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
200 if (!cmap.green)
201 goto out;
202 cmap.blue = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
203 if (!cmap.blue)
204 goto out;
205 if (transp) {
206 cmap.transp = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
207 if (!cmap.transp)
208 goto out;
209 }
210
211 if (cmd == FBIOPUTCMAP) {
212 err = __copy_from_user(cmap.red, (char *)A(red),
213 cmap.len * sizeof(__u16));
214 err |= __copy_from_user(cmap.green, (char *)A(green),
215 cmap.len * sizeof(__u16));
216 err |= __copy_from_user(cmap.blue, (char *)A(blue),
217 cmap.len * sizeof(__u16));
218 if (cmap.transp)
219 err |= __copy_from_user(cmap.transp, (char *)A(transp),
220 cmap.len * sizeof(__u16));
221 if (err) {
222 err = -EFAULT;
223 goto out;
224 }
225 }
226
227 set_fs(KERNEL_DS);
228 err = sys_ioctl(fd, cmd, (unsigned long)&cmap);
229 set_fs(old_fs);
230 if (err)
231 goto out;
232
233 if (cmd == FBIOGETCMAP) {
234 err = __copy_to_user((char *)A(red), cmap.red,
235 cmap.len * sizeof(__u16));
236 err |= __copy_to_user((char *)A(green), cmap.blue,
237 cmap.len * sizeof(__u16));
238 err |= __copy_to_user((char *)A(blue), cmap.blue,
239 cmap.len * sizeof(__u16));
240 if (cmap.transp)
241 err |= __copy_to_user((char *)A(transp), cmap.transp,
242 cmap.len * sizeof(__u16));
243 if (err) {
244 err = -EFAULT;
245 goto out;
246 }
247 }
248
249out:
250 if (cmap.red)
251 kfree(cmap.red);
252 if (cmap.green)
253 kfree(cmap.green);
254 if (cmap.blue)
255 kfree(cmap.blue);
256 if (cmap.transp)
257 kfree(cmap.transp);
258
259 return err;
260}
261
262#endif
263
264
265struct timeval32 {
266 int tv_sec;
267 int tv_usec;
268};
269
270static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
271{
272 struct timeval32 *up = (struct timeval32 *)arg;
273 struct timeval ktv;
274 mm_segment_t old_fs = get_fs();
275 int err;
276
277 set_fs(KERNEL_DS);
278 err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
279 set_fs(old_fs);
280 if (!err) {
281 err = put_user(ktv.tv_sec, &up->tv_sec);
282 err |= __put_user(ktv.tv_usec, &up->tv_usec);
283 }
284
285 return err;
286}
287
288#define EXT2_IOC32_GETFLAGS _IOR('f', 1, int)
289#define EXT2_IOC32_SETFLAGS _IOW('f', 2, int)
290#define EXT2_IOC32_GETVERSION _IOR('v', 1, int)
291#define EXT2_IOC32_SETVERSION _IOW('v', 2, int)
292
293struct ifmap32 {
294 unsigned int mem_start;
295 unsigned int mem_end;
296 unsigned short base_addr;
297 unsigned char irq;
298 unsigned char dma;
299 unsigned char port;
300};
301
302struct ifreq32 {
303#define IFHWADDRLEN 6
304#define IFNAMSIZ 16
305 union {
306 char ifrn_name[IFNAMSIZ];
307 } ifr_ifrn;
308 union {
309 struct sockaddr ifru_addr;
310 struct sockaddr ifru_dstaddr;
311 struct sockaddr ifru_broadaddr;
312 struct sockaddr ifru_netmask;
313 struct sockaddr ifru_hwaddr;
314 short ifru_flags;
315 int ifru_ivalue;
316 int ifru_mtu;
317 struct ifmap32 ifru_map;
318 char ifru_slave[IFNAMSIZ];
319 char ifru_newname[IFNAMSIZ];
320 __kernel_caddr_t32 ifru_data;
321 } ifr_ifru;
322};
323
324struct ifconf32 {
325 int ifc_len;
326 __kernel_caddr_t32 ifcbuf;
327};
328
329#ifdef CONFIG_NET
330
331static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
332{
333 struct ireq32 *uir32 = (struct ireq32 *)arg;
334 struct net_device *dev;
335 struct ifreq32 ifr32;
336
337 if (copy_from_user(&ifr32, uir32, sizeof(struct ifreq32)))
338 return -EFAULT;
339
340 read_lock(&dev_base_lock);
341 dev = __dev_get_by_index(ifr32.ifr_ifindex);
342 if (!dev) {
343 read_unlock(&dev_base_lock);
344 return -ENODEV;
345 }
346
347 strcpy(ifr32.ifr_name, dev->name);
348 read_unlock(&dev_base_lock);
349
350 if (copy_to_user(uir32, &ifr32, sizeof(struct ifreq32)))
351 return -EFAULT;
352
353 return 0;
354}
355
356static inline int dev_ifconf(unsigned int fd, unsigned int cmd,
357 unsigned long arg)
358{
359 struct ioconf32 *uifc32 = (struct ioconf32 *)arg;
360 struct ifconf32 ifc32;
361 struct ifconf ifc;
362 struct ifreq32 *ifr32;
363 struct ifreq *ifr;
364 mm_segment_t old_fs;
365 unsigned int i, j;
366 int err;
367
368 if (copy_from_user(&ifc32, uifc32, sizeof(struct ifconf32)))
369 return -EFAULT;
370
371 if(ifc32.ifcbuf == 0) {
372 ifc32.ifc_len = 0;
373 ifc.ifc_len = 0;
374 ifc.ifc_buf = NULL;
375 } else {
376 ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32))) *
377 sizeof (struct ifreq);
378 ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
379 if (!ifc.ifc_buf)
380 return -ENOMEM;
381 }
382 ifr = ifc.ifc_req;
383 ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
384 for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
385 if (copy_from_user(ifr++, ifr32++, sizeof (struct ifreq32))) {
386 kfree (ifc.ifc_buf);
387 return -EFAULT;
388 }
389 }
390
391 old_fs = get_fs(); set_fs (KERNEL_DS);
392 err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
393 set_fs (old_fs);
394 if (err)
395 goto out;
396
397 ifr = ifc.ifc_req;
398 ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
399 for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
400 i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
401 if (copy_to_user(ifr32++, ifr++, sizeof (struct ifreq32))) {
402 err = -EFAULT;
403 goto out;
404 }
405 }
406 if (ifc32.ifcbuf == 0) {
407
408
409
410 i = ifc.ifc_len;
411 i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
412 ifc32.ifc_len = i;
413 } else {
414 if (i <= ifc32.ifc_len)
415 ifc32.ifc_len = i;
416 else
417 ifc32.ifc_len = i - sizeof (struct ifreq32);
418 }
419 if (copy_to_user(uifc32, &ifc32, sizeof(struct ifconf32))) {
420 err = -EFAULT;
421 goto out;
422 }
423out:
424 if(ifc.ifc_buf != NULL)
425 kfree (ifc.ifc_buf);
426 return err;
427}
428
429static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
430{
431 struct ifreq ifr;
432 mm_segment_t old_fs;
433 int err;
434
435 switch (cmd) {
436 case SIOCSIFMAP:
437 err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
438 err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
439 err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
440 err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
441 err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
442 err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
443 err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
444 if (err)
445 return -EFAULT;
446 break;
447 default:
448 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
449 return -EFAULT;
450 break;
451 }
452 old_fs = get_fs();
453 set_fs (KERNEL_DS);
454 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
455 set_fs (old_fs);
456 if (!err) {
457 switch (cmd) {
458 case SIOCGIFFLAGS:
459 case SIOCGIFMETRIC:
460 case SIOCGIFMTU:
461 case SIOCGIFMEM:
462 case SIOCGIFHWADDR:
463 case SIOCGIFINDEX:
464 case SIOCGIFADDR:
465 case SIOCGIFBRDADDR:
466 case SIOCGIFDSTADDR:
467 case SIOCGIFNETMASK:
468 case SIOCGIFTXQLEN:
469 if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
470 return -EFAULT;
471 break;
472 case SIOCGIFMAP:
473 err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
474 err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
475 err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
476 err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
477 err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
478 err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
479 err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
480 if (err)
481 err = -EFAULT;
482 break;
483 }
484 }
485 return err;
486}
487
488struct rtentry32
489{
490 unsigned int rt_pad1;
491 struct sockaddr rt_dst;
492 struct sockaddr rt_gateway;
493 struct sockaddr rt_genmask;
494 unsigned short rt_flags;
495 short rt_pad2;
496 unsigned int rt_pad3;
497 unsigned int rt_pad4;
498 short rt_metric;
499 unsigned int rt_dev;
500 unsigned int rt_mtu;
501#ifndef __KERNEL__
502#define rt_mss rt_mtu
503#endif
504 unsigned int rt_window;
505 unsigned short rt_irtt;
506};
507
508static inline int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
509{
510 struct rtentry32 *ur = (struct rtentry32 *)arg;
511 struct rtentry r;
512 char devname[16];
513 u32 rtdev;
514 int ret;
515 mm_segment_t old_fs = get_fs();
516
517 ret = copy_from_user (&r.rt_dst, &(ur->rt_dst), 3 * sizeof(struct sockaddr));
518 ret |= __get_user (r.rt_flags, &(ur->rt_flags));
519 ret |= __get_user (r.rt_metric, &(ur->rt_metric));
520 ret |= __get_user (r.rt_mtu, &(ur->rt_mtu));
521 ret |= __get_user (r.rt_window, &(ur->rt_window));
522 ret |= __get_user (r.rt_irtt, &(ur->rt_irtt));
523 ret |= __get_user (rtdev, &(ur->rt_dev));
524 if (rtdev) {
525 ret |= copy_from_user (devname, (char *)A(rtdev), 15);
526 r.rt_dev = devname; devname[15] = 0;
527 } else
528 r.rt_dev = 0;
529 if (ret)
530 return -EFAULT;
531 set_fs (KERNEL_DS);
532 ret = sys_ioctl (fd, cmd, (long)&r);
533 set_fs (old_fs);
534 return ret;
535}
536
537#endif
538
539static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
540{
541
542 switch (cmd) {
543 case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
544 case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
545 case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
546 case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
547 }
548 return sys_ioctl(fd, cmd, arg);
549}
550
551struct video_tuner32 {
552 s32 tuner;
553 u8 name[32];
554 u32 rangelow, rangehigh;
555 u32 flags;
556 u16 mode, signal;
557};
558
559static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
560{
561 int i;
562
563 if(get_user(kp->tuner, &up->tuner))
564 return -EFAULT;
565 for(i = 0; i < 32; i++)
566 __get_user(kp->name[i], &up->name[i]);
567 __get_user(kp->rangelow, &up->rangelow);
568 __get_user(kp->rangehigh, &up->rangehigh);
569 __get_user(kp->flags, &up->flags);
570 __get_user(kp->mode, &up->mode);
571 __get_user(kp->signal, &up->signal);
572 return 0;
573}
574
575static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
576{
577 int i;
578
579 if(put_user(kp->tuner, &up->tuner))
580 return -EFAULT;
581 for(i = 0; i < 32; i++)
582 __put_user(kp->name[i], &up->name[i]);
583 __put_user(kp->rangelow, &up->rangelow);
584 __put_user(kp->rangehigh, &up->rangehigh);
585 __put_user(kp->flags, &up->flags);
586 __put_user(kp->mode, &up->mode);
587 __put_user(kp->signal, &up->signal);
588 return 0;
589}
590
591struct video_buffer32 {
592 u32 base;
593 s32 height, width, depth, bytesperline;
594};
595
596static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
597{
598 u32 tmp;
599
600 if(get_user(tmp, &up->base))
601 return -EFAULT;
602 kp->base = (void *) ((unsigned long)tmp);
603 __get_user(kp->height, &up->height);
604 __get_user(kp->width, &up->width);
605 __get_user(kp->depth, &up->depth);
606 __get_user(kp->bytesperline, &up->bytesperline);
607 return 0;
608}
609
610static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
611{
612 u32 tmp = (u32)((unsigned long)kp->base);
613
614 if(put_user(tmp, &up->base))
615 return -EFAULT;
616 __put_user(kp->height, &up->height);
617 __put_user(kp->width, &up->width);
618 __put_user(kp->depth, &up->depth);
619 __put_user(kp->bytesperline, &up->bytesperline);
620 return 0;
621}
622
623struct video_clip32 {
624 s32 x, y, width, height;
625 u32 next;
626};
627
628struct video_window32 {
629 u32 x, y, width, height, chromakey, flags;
630 u32 clips;
631 s32 clipcount;
632};
633
634static void free_kvideo_clips(struct video_window *kp)
635{
636 struct video_clip *cp;
637
638 cp = kp->clips;
639 if(cp != NULL)
640 kfree(cp);
641}
642
643static int get_video_window32(struct video_window *kp, struct video_window32 *up)
644{
645 struct video_clip32 *ucp;
646 struct video_clip *kcp;
647 int nclips, err, i;
648 u32 tmp;
649
650 if(get_user(kp->x, &up->x))
651 return -EFAULT;
652 __get_user(kp->y, &up->y);
653 __get_user(kp->width, &up->width);
654 __get_user(kp->height, &up->height);
655 __get_user(kp->chromakey, &up->chromakey);
656 __get_user(kp->flags, &up->flags);
657 __get_user(kp->clipcount, &up->clipcount);
658 __get_user(tmp, &up->clips);
659 ucp = (struct video_clip32 *)A(tmp);
660 kp->clips = NULL;
661
662 nclips = kp->clipcount;
663 if(nclips == 0)
664 return 0;
665
666 if(ucp == 0)
667 return -EINVAL;
668
669
670 if(nclips < 0)
671 nclips = VIDEO_CLIPMAP_SIZE;
672
673 kcp = kmalloc(nclips * sizeof(struct video_clip), GFP_KERNEL);
674 err = -ENOMEM;
675 if(kcp == NULL)
676 goto cleanup_and_err;
677
678 kp->clips = kcp;
679 for(i = 0; i < nclips; i++) {
680 __get_user(kcp[i].x, &ucp[i].x);
681 __get_user(kcp[i].y, &ucp[i].y);
682 __get_user(kcp[i].width, &ucp[i].width);
683 __get_user(kcp[i].height, &ucp[i].height);
684 kcp[nclips].next = NULL;
685 }
686
687 return 0;
688
689cleanup_and_err:
690 free_kvideo_clips(kp);
691 return err;
692}
693
694
695static int put_video_window32(struct video_window *kp, struct video_window32 *up)
696{
697 if(put_user(kp->x, &up->x))
698 return -EFAULT;
699 __put_user(kp->y, &up->y);
700 __put_user(kp->width, &up->width);
701 __put_user(kp->height, &up->height);
702 __put_user(kp->chromakey, &up->chromakey);
703 __put_user(kp->flags, &up->flags);
704 __put_user(kp->clipcount, &up->clipcount);
705 return 0;
706}
707
708#define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
709#define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
710#define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
711#define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
712#define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
713#define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
714#define VIDIOCGFREQ32 _IOR('v',14, u32)
715#define VIDIOCSFREQ32 _IOW('v',15, u32)
716
717static int do_video_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
718{
719 union {
720 struct video_tuner vt;
721 struct video_buffer vb;
722 struct video_window vw;
723 unsigned long vx;
724 } karg;
725 mm_segment_t old_fs = get_fs();
726 void *up = (void *)arg;
727 int err = 0;
728
729
730 switch(cmd) {
731 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
732 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
733 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
734 case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
735 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
736 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
737 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
738 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
739 };
740
741 switch(cmd) {
742 case VIDIOCSTUNER:
743 case VIDIOCGTUNER:
744 err = get_video_tuner32(&karg.vt, up);
745 break;
746
747 case VIDIOCSWIN:
748 err = get_video_window32(&karg.vw, up);
749 break;
750
751 case VIDIOCSFBUF:
752 err = get_video_buffer32(&karg.vb, up);
753 break;
754
755 case VIDIOCSFREQ:
756 err = get_user(karg.vx, (u32 *)up);
757 break;
758 };
759 if(err)
760 goto out;
761
762 set_fs(KERNEL_DS);
763 err = sys_ioctl(fd, cmd, (unsigned long)&karg);
764 set_fs(old_fs);
765
766 if(cmd == VIDIOCSWIN)
767 free_kvideo_clips(&karg.vw);
768
769 if(err == 0) {
770 switch(cmd) {
771 case VIDIOCGTUNER:
772 err = put_video_tuner32(&karg.vt, up);
773 break;
774
775 case VIDIOCGWIN:
776 err = put_video_window32(&karg.vw, up);
777 break;
778
779 case VIDIOCGFBUF:
780 err = put_video_buffer32(&karg.vb, up);
781 break;
782
783 case VIDIOCGFREQ:
784 err = put_user(((u32)karg.vx), (u32 *)up);
785 break;
786 };
787 }
788out:
789 return err;
790}
791struct hd_geometry32 {
792 unsigned char heads;
793 unsigned char sectors;
794 unsigned short cylinders;
795 u32 start;
796};
797
798static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
799{
800 mm_segment_t old_fs = get_fs();
801 struct hd_geometry geo;
802 int err;
803
804 set_fs (KERNEL_DS);
805 err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
806 set_fs (old_fs);
807 if (!err) {
808 err = copy_to_user ((struct hd_geometry32 *)arg, &geo, 4);
809 err |= __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start));
810 }
811
812 return err ? -EFAULT : 0;
813}
814
815static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
816{
817 mm_segment_t old_fs = get_fs();
818 unsigned long kval;
819 unsigned int *uvp;
820 int error;
821
822 set_fs(KERNEL_DS);
823 error = sys_ioctl(fd, cmd, (long)&kval);
824 set_fs(old_fs);
825
826 if (error == 0) {
827 uvp = (unsigned int *)arg;
828 if (put_user(kval, uvp))
829 error = -EFAULT;
830 }
831
832 return error;
833}
834
835static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
836{
837 return -EINVAL;
838}
839
840static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
841{
842
843 return w_long(fd, BLKGETSIZE, arg);
844}
845
846struct blkpg_ioctl_arg32 {
847 int op;
848 int flags;
849 int datalen;
850 u32 data;
851};
852
853static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd,
854 struct blkpg_ioctl_arg32 *arg)
855{
856 struct blkpg_ioctl_arg a;
857 struct blkpg_partition p;
858 int err;
859 mm_segment_t old_fs = get_fs();
860
861 err = get_user(a.op, &arg->op);
862 err |= __get_user(a.flags, &arg->flags);
863 err |= __get_user(a.datalen, &arg->datalen);
864 err |= __get_user((long)a.data, &arg->data);
865 if (err) return err;
866 switch (a.op) {
867 case BLKPG_ADD_PARTITION:
868 case BLKPG_DEL_PARTITION:
869 if (a.datalen < sizeof(struct blkpg_partition))
870 return -EINVAL;
871 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
872 return -EFAULT;
873 a.data = &p;
874 set_fs (KERNEL_DS);
875 err = sys_ioctl(fd, cmd, (unsigned long)&a);
876 set_fs (old_fs);
877 default:
878 return -EINVAL;
879 }
880 return err;
881}
882
883
884#define BLKELVGET_32 _IOR(0x12,106,int)
885#define BLKELVSET_32 _IOW(0x12,107,int)
886#define BLKBSZGET_32 _IOR(0x12,112,int)
887#define BLKBSZSET_32 _IOW(0x12,113,int)
888#define BLKGETSIZE64_32 _IOR(0x12,114,int)
889
890static int do_blkelvget(unsigned int fd, unsigned int cmd, unsigned long arg)
891{
892 return sys_ioctl(fd, BLKELVGET, arg);
893}
894
895static int do_blkelvset(unsigned int fd, unsigned int cmd, unsigned long arg)
896{
897 return sys_ioctl(fd, BLKELVSET, arg);
898}
899
900static int do_blkbszget(unsigned int fd, unsigned int cmd, unsigned long arg)
901{
902 return sys_ioctl(fd, BLKBSZGET, arg);
903}
904
905static int do_blkbszset(unsigned int fd, unsigned int cmd, unsigned long arg)
906{
907 return sys_ioctl(fd, BLKBSZSET, arg);
908}
909
910static int do_blkgetsize64(unsigned int fd, unsigned int cmd,
911 unsigned long arg)
912{
913 return sys_ioctl(fd, BLKGETSIZE64, arg);
914}
915
916struct mtget32 {
917 __u32 mt_type;
918 __u32 mt_resid;
919 __u32 mt_dsreg;
920 __u32 mt_gstat;
921 __u32 mt_erreg;
922 __kernel_daddr_t32 mt_fileno;
923 __kernel_daddr_t32 mt_blkno;
924};
925#define MTIOCGET32 _IOR('m', 2, struct mtget32)
926
927struct mtpos32 {
928 __u32 mt_blkno;
929};
930#define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
931
932struct mtconfiginfo32 {
933 __u32 mt_type;
934 __u32 ifc_type;
935 __u16 irqnr;
936 __u16 dmanr;
937 __u16 port;
938 __u32 debug;
939 __u32 have_dens:1;
940 __u32 have_bsf:1;
941 __u32 have_fsr:1;
942 __u32 have_bsr:1;
943 __u32 have_eod:1;
944 __u32 have_seek:1;
945 __u32 have_tell:1;
946 __u32 have_ras1:1;
947 __u32 have_ras2:1;
948 __u32 have_ras3:1;
949 __u32 have_qfa:1;
950 __u32 pad1:5;
951 char reserved[10];
952};
953#define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
954#define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
955
956static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
957{
958 mm_segment_t old_fs = get_fs();
959 struct mtconfiginfo info;
960 struct mtget get;
961 struct mtpos pos;
962 unsigned long kcmd;
963 void *karg;
964 int err = 0;
965
966 switch(cmd) {
967 case MTIOCPOS32:
968 kcmd = MTIOCPOS;
969 karg = &pos;
970 break;
971 case MTIOCGET32:
972 kcmd = MTIOCGET;
973 karg = &get;
974 break;
975 case MTIOCGETCONFIG32:
976 kcmd = MTIOCGETCONFIG;
977 karg = &info;
978 break;
979 case MTIOCSETCONFIG32:
980 kcmd = MTIOCSETCONFIG;
981 karg = &info;
982 err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
983 err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
984 err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
985 err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
986 err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
987 err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
988 err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
989 (char *)&((struct mtconfiginfo32 *)arg)->debug
990 + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
991 if (err)
992 return -EFAULT;
993 break;
994 default:
995 do {
996 static int count = 0;
997 if (++count <= 20)
998 printk("mt_ioctl: Unknown cmd fd(%d) "
999 "cmd(%08x) arg(%08x)\n",
1000 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1001 } while(0);
1002 return -EINVAL;
1003 }
1004 set_fs (KERNEL_DS);
1005 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1006 set_fs (old_fs);
1007 if (err)
1008 return err;
1009 switch (cmd) {
1010 case MTIOCPOS32:
1011 err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
1012 break;
1013 case MTIOCGET32:
1014 err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
1015 err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
1016 err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
1017 err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
1018 err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
1019 err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
1020 err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
1021 break;
1022 case MTIOCGETCONFIG32:
1023 err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1024 err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1025 err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1026 err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1027 err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1028 err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1029 err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
1030 + sizeof(((struct mtconfiginfo32 *)arg)->debug),
1031 (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
1032 break;
1033 case MTIOCSETCONFIG32:
1034 break;
1035 }
1036 return err ? -EFAULT: 0;
1037}
1038
1039#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
1040
1041static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
1042{
1043 return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
1044}
1045
1046
1047
1048
1049struct serial_struct32 {
1050 int type;
1051 int line;
1052 unsigned int port;
1053 int irq;
1054 int flags;
1055 int xmit_fifo_size;
1056 int custom_divisor;
1057 int baud_base;
1058 unsigned short close_delay;
1059 char io_type;
1060 char reserved_char[1];
1061 int hub6;
1062 unsigned short closing_wait;
1063 unsigned short closing_wait2;
1064 __u32 iomem_base;
1065 unsigned short iomem_reg_shift;
1066 unsigned int port_high;
1067 int reserved[1];
1068};
1069
1070static int serial_struct_ioctl(unsigned fd, unsigned cmd, void *ptr)
1071{
1072 typedef struct serial_struct SS;
1073 struct serial_struct32 *ss32 = ptr;
1074 int err = 0;
1075 struct serial_struct ss;
1076 mm_segment_t oldseg = get_fs();
1077 set_fs(KERNEL_DS);
1078 if (cmd == TIOCSSERIAL) {
1079 err = -EFAULT;
1080 if (copy_from_user(&ss, ss32, sizeof(struct serial_struct32)))
1081 goto out;
1082 memmove(&ss.iomem_reg_shift, ((char*)&ss.iomem_base)+4,
1083 sizeof(SS)-offsetof(SS,iomem_reg_shift));
1084 ss.iomem_base = (void *)(long)ss.iomem_base;
1085 }
1086 if (!err)
1087 err = sys_ioctl(fd,cmd,(unsigned long)(&ss));
1088 if (cmd == TIOCGSERIAL && err >= 0) {
1089 __u32 base;
1090 if (__copy_to_user(ss32,&ss,offsetof(SS,iomem_base)) ||
1091 __copy_to_user(&ss32->iomem_reg_shift,
1092 &ss.iomem_reg_shift,
1093 sizeof(SS) - offsetof(SS, iomem_reg_shift)))
1094 err = -EFAULT;
1095 base = (unsigned long)ss.iomem_base;
1096 err |= __put_user(base, &ss32->iomem_base);
1097 }
1098 out:
1099 set_fs(oldseg);
1100 return err;
1101}
1102
1103
1104struct loop_info32 {
1105 int lo_number;
1106 __kernel_dev_t32 lo_device;
1107 unsigned int lo_inode;
1108 __kernel_dev_t32 lo_rdevice;
1109 int lo_offset;
1110 int lo_encrypt_type;
1111 int lo_encrypt_key_size;
1112 int lo_flags;
1113 char lo_name[LO_NAME_SIZE];
1114 unsigned char lo_encrypt_key[LO_KEY_SIZE];
1115 unsigned int lo_init[2];
1116 char reserved[4];
1117};
1118
1119static int loop_status(unsigned int fd, unsigned int cmd, unsigned long arg)
1120{
1121 mm_segment_t old_fs = get_fs();
1122 struct loop_info l;
1123 int err = -EINVAL;
1124
1125 switch(cmd) {
1126 case LOOP_SET_STATUS:
1127 err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1128 err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1129 err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1130 err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1131 err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,
1132 8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1133 if (err) {
1134 err = -EFAULT;
1135 } else {
1136 set_fs (KERNEL_DS);
1137 err = sys_ioctl (fd, cmd, (unsigned long)&l);
1138 set_fs (old_fs);
1139 }
1140 break;
1141 case LOOP_GET_STATUS:
1142 set_fs (KERNEL_DS);
1143 err = sys_ioctl (fd, cmd, (unsigned long)&l);
1144 set_fs (old_fs);
1145 if (!err) {
1146 err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1147 err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1148 err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1149 err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1150 err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,
1151 (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1152 if (err)
1153 err = -EFAULT;
1154 }
1155 break;
1156 default: {
1157 static int count;
1158 if (++count <= 20)
1159 printk("%s: Unknown loop ioctl cmd, fd(%d) "
1160 "cmd(%08x) arg(%08lx)\n",
1161 __FUNCTION__, fd, cmd, arg);
1162 }
1163 }
1164 return err;
1165}
1166
1167#ifdef CONFIG_VT
1168
1169extern int tty_ioctl(struct inode * inode, struct file * file,
1170 unsigned int cmd, unsigned long arg);
1171
1172static int vt_check(struct file *file)
1173{
1174 struct tty_struct *tty;
1175 struct inode *inode = file->f_dentry->d_inode;
1176
1177 if (file->f_op->ioctl != tty_ioctl)
1178 return -EINVAL;
1179
1180 tty = (struct tty_struct *)file->private_data;
1181 if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
1182 return -EINVAL;
1183
1184 if (tty->driver.ioctl != vt_ioctl)
1185 return -EINVAL;
1186
1187
1188
1189
1190
1191 if (current->tty == tty || suser())
1192 return 1;
1193 return 0;
1194}
1195
1196struct consolefontdesc32 {
1197 unsigned short charcount;
1198 unsigned short charheight;
1199 u32 chardata;
1200};
1201
1202static int do_fontx_ioctl(unsigned int fd, int cmd, struct consolefontdesc32 *user_cfd, struct file *file)
1203{
1204 struct consolefontdesc cfdarg;
1205 struct console_font_op op;
1206 int i, perm;
1207
1208 perm = vt_check(file);
1209 if (perm < 0) return perm;
1210
1211 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc32)))
1212 return -EFAULT;
1213
1214 cfdarg.chardata = (unsigned char *)A(((struct consolefontdesc32 *)&cfdarg)->chardata);
1215
1216 switch (cmd) {
1217 case PIO_FONTX:
1218 if (!perm)
1219 return -EPERM;
1220 op.op = KD_FONT_OP_SET;
1221 op.flags = 0;
1222 op.width = 8;
1223 op.height = cfdarg.charheight;
1224 op.charcount = cfdarg.charcount;
1225 op.data = cfdarg.chardata;
1226 return con_font_op(fg_console, &op);
1227 case GIO_FONTX:
1228 if (!cfdarg.chardata)
1229 return 0;
1230 op.op = KD_FONT_OP_GET;
1231 op.flags = 0;
1232 op.width = 8;
1233 op.height = cfdarg.charheight;
1234 op.charcount = cfdarg.charcount;
1235 op.data = cfdarg.chardata;
1236 i = con_font_op(fg_console, &op);
1237 if (i)
1238 return i;
1239 cfdarg.charheight = op.height;
1240 cfdarg.charcount = op.charcount;
1241 ((struct consolefontdesc32 *)&cfdarg)->chardata = (unsigned long)cfdarg.chardata;
1242 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc32)))
1243 return -EFAULT;
1244 return 0;
1245 }
1246 return -EINVAL;
1247}
1248
1249struct console_font_op32 {
1250 unsigned int op;
1251 unsigned int flags;
1252 unsigned int width, height;
1253 unsigned int charcount;
1254 u32 data;
1255};
1256
1257static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, struct console_font_op32 *fontop, struct file *file)
1258{
1259 struct console_font_op op;
1260 int perm = vt_check(file), i;
1261 struct vt_struct *vt;
1262
1263 if (perm < 0) return perm;
1264
1265 if (copy_from_user(&op, (void *) fontop, sizeof(struct console_font_op32)))
1266 return -EFAULT;
1267 if (!perm && op.op != KD_FONT_OP_GET)
1268 return -EPERM;
1269 op.data = (unsigned char *)A(((struct console_font_op32 *)&op)->data);
1270 op.flags |= KD_FONT_FLAG_OLD;
1271 vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data;
1272 i = con_font_op(vt->vc_num, &op);
1273 if (i) return i;
1274 ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
1275 if (copy_to_user((void *) fontop, &op, sizeof(struct console_font_op32)))
1276 return -EFAULT;
1277 return 0;
1278}
1279
1280#endif
1281
1282#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
1283
1284typedef struct {
1285 uint8_t vg_name[NAME_LEN];
1286 uint32_t vg_number;
1287 uint32_t vg_access;
1288 uint32_t vg_status;
1289 uint32_t lv_max;
1290 uint32_t lv_cur;
1291 uint32_t lv_open;
1292 uint32_t pv_max;
1293 uint32_t pv_cur;
1294 uint32_t pv_act;
1295 uint32_t dummy;
1296 uint32_t vgda;
1297 uint32_t pe_size;
1298 uint32_t pe_total;
1299 uint32_t pe_allocated;
1300 uint32_t pvg_total;
1301 u32 proc;
1302 u32 pv[ABS_MAX_PV + 1];
1303 u32 lv[ABS_MAX_LV + 1];
1304 uint8_t vg_uuid[UUID_LEN+1];
1305 uint8_t dummy1[200];
1306} vg32_t;
1307
1308typedef struct {
1309 uint8_t id[2];
1310 uint16_t version;
1311 lvm_disk_data_t pv_on_disk;
1312 lvm_disk_data_t vg_on_disk;
1313 lvm_disk_data_t pv_namelist_on_disk;
1314 lvm_disk_data_t lv_on_disk;
1315 lvm_disk_data_t pe_on_disk;
1316 uint8_t pv_name[NAME_LEN];
1317 uint8_t vg_name[NAME_LEN];
1318 uint8_t system_id[NAME_LEN];
1319 kdev_t pv_dev;
1320 uint32_t pv_number;
1321 uint32_t pv_status;
1322 uint32_t pv_allocatable;
1323 uint32_t pv_size;
1324 uint32_t lv_cur;
1325 uint32_t pe_size;
1326 uint32_t pe_total;
1327 uint32_t pe_allocated;
1328 uint32_t pe_stale;
1329 u32 pe;
1330 u32 inode;
1331 uint8_t pv_uuid[UUID_LEN+1];
1332} pv32_t;
1333
1334typedef struct {
1335 char lv_name[NAME_LEN];
1336 u32 lv;
1337} lv_req32_t;
1338
1339typedef struct {
1340 u32 lv_index;
1341 u32 lv;
1342
1343 uint16_t size;
1344} lv_status_byindex_req32_t;
1345
1346typedef struct {
1347 __kernel_dev_t32 dev;
1348 u32 lv;
1349} lv_status_bydev_req32_t;
1350
1351typedef struct {
1352 uint8_t lv_name[NAME_LEN];
1353 kdev_t old_dev;
1354 kdev_t new_dev;
1355 u32 old_pe;
1356 u32 new_pe;
1357} le_remap_req32_t;
1358
1359typedef struct {
1360 char pv_name[NAME_LEN];
1361 u32 pv;
1362} pv_status_req32_t;
1363
1364typedef struct {
1365 uint8_t lv_name[NAME_LEN];
1366 uint8_t vg_name[NAME_LEN];
1367 uint32_t lv_access;
1368 uint32_t lv_status;
1369 uint32_t lv_open;
1370 kdev_t lv_dev;
1371 uint32_t lv_number;
1372 uint32_t lv_mirror_copies;
1373 uint32_t lv_recovery;
1374 uint32_t lv_schedule;
1375 uint32_t lv_size;
1376 u32 lv_current_pe;
1377 uint32_t lv_current_le;
1378 uint32_t lv_allocated_le;
1379 uint32_t lv_stripes;
1380 uint32_t lv_stripesize;
1381 uint32_t lv_badblock;
1382 uint32_t lv_allocation;
1383 uint32_t lv_io_timeout;
1384 uint32_t lv_read_ahead;
1385
1386 u32 lv_snapshot_org;
1387 u32 lv_snapshot_prev;
1388 u32 lv_snapshot_next;
1389 u32 lv_block_exception;
1390 uint32_t lv_remap_ptr;
1391 uint32_t lv_remap_end;
1392 uint32_t lv_chunk_size;
1393 uint32_t lv_snapshot_minor;
1394 char dummy[200];
1395} lv32_t;
1396
1397typedef struct {
1398 u32 hash[2];
1399 u32 rsector_org;
1400 kdev_t rdev_org;
1401 u32 rsector_new;
1402 kdev_t rdev_new;
1403} lv_block_exception32_t;
1404
1405static void put_lv_t(lv_t *l)
1406{
1407 if (l->lv_current_pe) vfree(l->lv_current_pe);
1408 if (l->lv_block_exception) vfree(l->lv_block_exception);
1409 kfree(l);
1410}
1411
1412static lv_t *get_lv_t(u32 p, int *errp)
1413{
1414 int err, i;
1415 u32 ptr1, ptr2;
1416 size_t size;
1417 lv_block_exception32_t *lbe32;
1418 lv_block_exception_t *lbe;
1419 lv32_t *ul = (lv32_t *)A(p);
1420 lv_t *l = (lv_t *) kmalloc(sizeof(lv_t), GFP_KERNEL);
1421
1422 if (!l) {
1423 *errp = -ENOMEM;
1424 return NULL;
1425 }
1426 memset(l, 0, sizeof(lv_t));
1427 err = copy_from_user(l, ul, (long)&((lv32_t *)0)->lv_current_pe);
1428 err |= __copy_from_user(&l->lv_current_le, &ul->lv_current_le,
1429 ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
1430 err |= __copy_from_user(&l->lv_remap_ptr, &ul->lv_remap_ptr,
1431 ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
1432 err |= __get_user(ptr1, &ul->lv_current_pe);
1433 err |= __get_user(ptr2, &ul->lv_block_exception);
1434 if (err) {
1435 kfree(l);
1436 *errp = -EFAULT;
1437 return NULL;
1438 }
1439 if (ptr1) {
1440 size = l->lv_allocated_le * sizeof(pe_t);
1441 l->lv_current_pe = vmalloc(size);
1442 if (l->lv_current_pe)
1443 err = copy_from_user(l->lv_current_pe, (void *)A(ptr1), size);
1444 }
1445 if (!err && ptr2) {
1446 size = l->lv_remap_end * sizeof(lv_block_exception_t);
1447 l->lv_block_exception = lbe = vmalloc(size);
1448 if (l->lv_block_exception) {
1449 lbe32 = (lv_block_exception32_t *)A(ptr2);
1450 memset(lbe, 0, size);
1451 for (i = 0; i < l->lv_remap_end; i++, lbe++, lbe32++) {
1452 err |= get_user(lbe->rsector_org, &lbe32->rsector_org);
1453 err |= __get_user(lbe->rdev_org, &lbe32->rdev_org);
1454 err |= __get_user(lbe->rsector_new, &lbe32->rsector_new);
1455 err |= __get_user(lbe->rdev_new, &lbe32->rdev_new);
1456 }
1457 }
1458 }
1459 if (err || (ptr1 && !l->lv_current_pe) || (ptr2 && !l->lv_block_exception)) {
1460 if (!err)
1461 *errp = -ENOMEM;
1462 else
1463 *errp = -EFAULT;
1464 put_lv_t(l);
1465 return NULL;
1466 }
1467 return l;
1468}
1469
1470static int copy_lv_t(u32 ptr, lv_t *l)
1471{
1472 int err;
1473 lv32_t *ul = (lv32_t *)A(ptr);
1474 u32 ptr1;
1475 size_t size;
1476
1477 err = get_user(ptr1, &ul->lv_current_pe);
1478 if (err)
1479 return -EFAULT;
1480 err = copy_to_user(ul, l, (long)&((lv32_t *)0)->lv_current_pe);
1481 err |= __copy_to_user(&ul->lv_current_le, &l->lv_current_le,
1482 ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
1483 err |= __copy_to_user(&ul->lv_remap_ptr, &l->lv_remap_ptr,
1484 ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
1485 size = l->lv_allocated_le * sizeof(pe_t);
1486 if (ptr1)
1487 err |= __copy_to_user((void *)A(ptr1), l->lv_current_pe, size);
1488 return err ? -EFAULT : 0;
1489}
1490
1491static int do_lvm_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
1492{
1493 vg_t *v = NULL;
1494 union {
1495 lv_req_t lv_req;
1496 le_remap_req_t le_remap;
1497 lv_status_byindex_req_t lv_byindex;
1498 lv_status_bydev_req_t lv_bydev;
1499 pv_status_req_t pv_status;
1500 } u;
1501 pv_t p;
1502 int err;
1503 u32 ptr = 0;
1504 int i;
1505 mm_segment_t old_fs;
1506 void *karg = &u;
1507
1508 switch (cmd) {
1509 case VG_STATUS:
1510 v = kmalloc(sizeof(vg_t), GFP_KERNEL);
1511 if (!v)
1512 return -ENOMEM;
1513 karg = v;
1514 break;
1515
1516 case VG_CREATE_OLD:
1517 case VG_CREATE:
1518 v = kmalloc(sizeof(vg_t), GFP_KERNEL);
1519 if (!v)
1520 return -ENOMEM;
1521 if (copy_from_user(v, (void *)arg, (long)&((vg32_t *)0)->proc)) {
1522 kfree(v);
1523 return -EFAULT;
1524 }
1525
1526 v->proc = NULL;
1527 if (copy_from_user(v->vg_uuid, ((vg32_t *)arg)->vg_uuid, UUID_LEN+1)) {
1528 kfree(v);
1529 return -EFAULT;
1530 }
1531
1532 karg = v;
1533 memset(v->pv, 0, sizeof(v->pv) + sizeof(v->lv));
1534 if (v->pv_max > ABS_MAX_PV || v->lv_max > ABS_MAX_LV)
1535 return -EPERM;
1536 for (i = 0; i < v->pv_max; i++) {
1537 err = __get_user(ptr, &((vg32_t *)arg)->pv[i]);
1538 if (err)
1539 break;
1540 if (ptr) {
1541 v->pv[i] = kmalloc(sizeof(pv_t), GFP_KERNEL);
1542 if (!v->pv[i]) {
1543 err = -ENOMEM;
1544 break;
1545 }
1546 err = copy_from_user(v->pv[i], (void *)A(ptr),
1547 sizeof(pv32_t) - 8 - UUID_LEN+1);
1548 if (err) {
1549 err = -EFAULT;
1550 break;
1551 }
1552 err = copy_from_user(v->pv[i]->pv_uuid,
1553 ((pv32_t *)A(ptr))->pv_uuid,
1554 UUID_LEN+1);
1555 if (err) {
1556 err = -EFAULT;
1557 break;
1558 }
1559
1560 v->pv[i]->pe = NULL;
1561 v->pv[i]->bd = NULL;
1562 }
1563 }
1564 if (!err) {
1565 for (i = 0; i < v->lv_max; i++) {
1566 err = __get_user(ptr, &((vg32_t *)arg)->lv[i]);
1567 if (err)
1568 break;
1569 if (ptr) {
1570 v->lv[i] = get_lv_t(ptr, &err);
1571 if (err)
1572 break;
1573 }
1574 }
1575 }
1576 break;
1577
1578 case LV_CREATE:
1579 case LV_EXTEND:
1580 case LV_REDUCE:
1581 case LV_REMOVE:
1582 case LV_RENAME:
1583 case LV_STATUS_BYNAME:
1584 err = copy_from_user(&u.pv_status, arg, sizeof(u.pv_status.pv_name));
1585 if (err)
1586 return -EFAULT;
1587 if (cmd != LV_REMOVE) {
1588 err = __get_user(ptr, &((lv_req32_t *)arg)->lv);
1589 if (err)
1590 return err;
1591 u.lv_req.lv = get_lv_t(ptr, &err);
1592 } else
1593 u.lv_req.lv = NULL;
1594 break;
1595
1596 case LV_STATUS_BYINDEX:
1597 err = get_user(u.lv_byindex.lv_index,
1598 &((lv_status_byindex_req32_t *)arg)->lv_index);
1599 err |= __get_user(ptr, &((lv_status_byindex_req32_t *)arg)->lv);
1600 if (err)
1601 return err;
1602 u.lv_byindex.lv = get_lv_t(ptr, &err);
1603 break;
1604
1605 case LV_STATUS_BYDEV:
1606 err = get_user(u.lv_bydev.dev, &((lv_status_bydev_req32_t *)arg)->dev);
1607 err |= __get_user(ptr, &((lv_status_bydev_req32_t *)arg)->lv);
1608 if (err)
1609 return err;
1610 u.lv_bydev.lv = get_lv_t(ptr, &err);
1611 break;
1612
1613 case VG_EXTEND:
1614 err = copy_from_user(&p, (void *)arg, sizeof(pv32_t) - 8 - UUID_LEN+1);
1615 if (err)
1616 return -EFAULT;
1617 err = copy_from_user(p.pv_uuid, ((pv32_t *)arg)->pv_uuid, UUID_LEN+1);
1618 if (err)
1619 return -EFAULT;
1620 p.pe = NULL;
1621 p.bd = NULL;
1622 karg = &p;
1623 break;
1624
1625 case PV_CHANGE:
1626 case PV_STATUS:
1627 err = copy_from_user(&u.pv_status, arg, sizeof(u.lv_req.lv_name));
1628 if (err)
1629 return -EFAULT;
1630 err = __get_user(ptr, &((pv_status_req32_t *)arg)->pv);
1631 if (err)
1632 return err;
1633 u.pv_status.pv = &p;
1634 if (cmd == PV_CHANGE) {
1635 err = copy_from_user(&p, (void *)A(ptr),
1636 sizeof(pv32_t) - 8 - UUID_LEN+1);
1637 if (err)
1638 return -EFAULT;
1639 p.pe = NULL;
1640 p.bd = NULL;
1641 }
1642 break;
1643 };
1644
1645 old_fs = get_fs(); set_fs (KERNEL_DS);
1646 err = sys_ioctl (fd, cmd, (unsigned long)karg);
1647 set_fs (old_fs);
1648
1649 switch (cmd) {
1650 case VG_STATUS:
1651 if (!err) {
1652 if (copy_to_user((void *)arg, v, (long)&((vg32_t *)0)->proc) ||
1653 clear_user(&((vg32_t *)arg)->proc, sizeof(vg32_t) - (long)&((vg32_t *)0)->proc))
1654 err = -EFAULT;
1655 }
1656 if (copy_to_user(((vg32_t *)arg)->vg_uuid, v->vg_uuid, UUID_LEN+1)) {
1657 err = -EFAULT;
1658 }
1659 kfree(v);
1660 break;
1661
1662 case VG_CREATE_OLD:
1663 case VG_CREATE:
1664 for (i = 0; i < v->pv_max; i++) {
1665 if (v->pv[i])
1666 kfree(v->pv[i]);
1667 }
1668 for (i = 0; i < v->lv_max; i++) {
1669 if (v->lv[i])
1670 put_lv_t(v->lv[i]);
1671 }
1672 kfree(v);
1673 break;
1674
1675 case LV_STATUS_BYNAME:
1676 if (!err && u.lv_req.lv)
1677 err = copy_lv_t(ptr, u.lv_req.lv);
1678
1679
1680 case LV_CREATE:
1681 case LV_EXTEND:
1682 case LV_REDUCE:
1683 if (u.lv_req.lv)
1684 put_lv_t(u.lv_req.lv);
1685 break;
1686
1687 case LV_STATUS_BYINDEX:
1688 if (u.lv_byindex.lv) {
1689 if (!err)
1690 err = copy_lv_t(ptr, u.lv_byindex.lv);
1691 put_lv_t(u.lv_byindex.lv);
1692 }
1693 break;
1694
1695 case LV_STATUS_BYDEV:
1696 if (u.lv_bydev.lv) {
1697 if (!err)
1698 err = copy_lv_t(ptr, u.lv_bydev.lv);
1699 put_lv_t(u.lv_byindex.lv);
1700 }
1701 break;
1702
1703 case PV_STATUS:
1704 if (!err) {
1705 err = copy_to_user((void *)A(ptr), &p, sizeof(pv32_t) - 8 - UUID_LEN+1);
1706 if (err)
1707 return -EFAULT;
1708 err = copy_to_user(((pv_t *)A(ptr))->pv_uuid, p.pv_uuid, UUID_LEN + 1);
1709 if (err)
1710 return -EFAULT;
1711 }
1712 break;
1713 };
1714
1715 return err;
1716}
1717#endif
1718
1719struct ioctl32_handler {
1720 unsigned int cmd;
1721 int (*function)(unsigned int, unsigned int, unsigned long);
1722};
1723
1724struct ioctl32_list {
1725 struct ioctl32_handler handler;
1726 struct ioctl32_list *next;
1727};
1728
1729#define IOCTL32_DEFAULT(cmd) { { cmd, (void *) sys_ioctl }, 0 }
1730#define IOCTL32_HANDLER(cmd, handler) { { cmd, (void *) handler }, 0 }
1731
1732static struct ioctl32_list ioctl32_handler_table[] = {
1733 IOCTL32_DEFAULT(TCGETA),
1734 IOCTL32_DEFAULT(TCSETA),
1735 IOCTL32_DEFAULT(TCSETAW),
1736 IOCTL32_DEFAULT(TCSETAF),
1737 IOCTL32_DEFAULT(TCSBRK),
1738 IOCTL32_DEFAULT(TCSBRKP),
1739 IOCTL32_DEFAULT(TCXONC),
1740 IOCTL32_DEFAULT(TCFLSH),
1741 IOCTL32_DEFAULT(TCGETS),
1742 IOCTL32_DEFAULT(TCSETS),
1743 IOCTL32_DEFAULT(TCSETSW),
1744 IOCTL32_DEFAULT(TCSETSF),
1745 IOCTL32_DEFAULT(TIOCLINUX),
1746
1747 IOCTL32_DEFAULT(TIOCGETD),
1748 IOCTL32_DEFAULT(TIOCSETD),
1749 IOCTL32_DEFAULT(TIOCEXCL),
1750 IOCTL32_DEFAULT(TIOCNXCL),
1751 IOCTL32_DEFAULT(TIOCCONS),
1752 IOCTL32_DEFAULT(TIOCGSOFTCAR),
1753 IOCTL32_DEFAULT(TIOCSSOFTCAR),
1754 IOCTL32_DEFAULT(TIOCSWINSZ),
1755 IOCTL32_DEFAULT(TIOCGWINSZ),
1756 IOCTL32_DEFAULT(TIOCMGET),
1757 IOCTL32_DEFAULT(TIOCMBIC),
1758 IOCTL32_DEFAULT(TIOCMBIS),
1759 IOCTL32_DEFAULT(TIOCMSET),
1760 IOCTL32_DEFAULT(TIOCPKT),
1761 IOCTL32_DEFAULT(TIOCNOTTY),
1762 IOCTL32_DEFAULT(TIOCSTI),
1763 IOCTL32_DEFAULT(TIOCOUTQ),
1764 IOCTL32_DEFAULT(TIOCSPGRP),
1765 IOCTL32_DEFAULT(TIOCGPGRP),
1766 IOCTL32_DEFAULT(TIOCSCTTY),
1767 IOCTL32_DEFAULT(TIOCGPTN),
1768 IOCTL32_DEFAULT(TIOCSPTLCK),
1769 IOCTL32_HANDLER(TIOCGSERIAL, serial_struct_ioctl),
1770 IOCTL32_HANDLER(TIOCSSERIAL, serial_struct_ioctl),
1771 IOCTL32_DEFAULT(TIOCSERGETLSR),
1772
1773 IOCTL32_DEFAULT(FIOCLEX),
1774 IOCTL32_DEFAULT(FIONCLEX),
1775 IOCTL32_DEFAULT(FIOASYNC),
1776 IOCTL32_DEFAULT(FIONBIO),
1777 IOCTL32_DEFAULT(FIONREAD),
1778
1779#ifdef CONFIG_FB
1780
1781 IOCTL32_DEFAULT(FBIOGET_VSCREENINFO),
1782 IOCTL32_DEFAULT(FBIOPUT_VSCREENINFO),
1783 IOCTL32_HANDLER(FBIOGET_FSCREENINFO, do_fbioget_fscreeninfo_ioctl),
1784 IOCTL32_HANDLER(FBIOGETCMAP, do_fbiocmap_ioctl),
1785 IOCTL32_HANDLER(FBIOPUTCMAP, do_fbiocmap_ioctl),
1786 IOCTL32_DEFAULT(FBIOPAN_DISPLAY),
1787#endif
1788
1789
1790 IOCTL32_DEFAULT(VIDIOCGCAP),
1791 IOCTL32_DEFAULT(VIDIOCGCHAN),
1792 IOCTL32_DEFAULT(VIDIOCSCHAN),
1793 IOCTL32_DEFAULT(VIDIOCGPICT),
1794 IOCTL32_DEFAULT(VIDIOCSPICT),
1795 IOCTL32_DEFAULT(VIDIOCCAPTURE),
1796
1797 IOCTL32_DEFAULT(VIDIOCGWIN),
1798 IOCTL32_DEFAULT(VIDIOCSWIN),
1799 IOCTL32_DEFAULT(VIDIOCGFBUF),
1800 IOCTL32_DEFAULT(VIDIOCSFBUF),
1801
1802 IOCTL32_DEFAULT(VIDIOCKEY),
1803 IOCTL32_DEFAULT(VIDIOCGAUDIO),
1804 IOCTL32_DEFAULT(VIDIOCSAUDIO),
1805 IOCTL32_DEFAULT(VIDIOCSYNC),
1806 IOCTL32_DEFAULT(VIDIOCMCAPTURE),
1807 IOCTL32_DEFAULT(VIDIOCGMBUF),
1808 IOCTL32_DEFAULT(VIDIOCGUNIT),
1809 IOCTL32_DEFAULT(VIDIOCGCAPTURE),
1810 IOCTL32_DEFAULT(VIDIOCSCAPTURE),
1811
1812 IOCTL32_DEFAULT(_IOW('v', BASE_VIDIOCPRIVATE+0, char [256])),
1813 IOCTL32_DEFAULT(_IOR('v', BASE_VIDIOCPRIVATE+1, char [256])),
1814 IOCTL32_DEFAULT(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int)),
1815 IOCTL32_DEFAULT(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])),
1816 IOCTL32_DEFAULT(_IOR('v' , BASE_VIDIOCPRIVATE+4, int)),
1817 IOCTL32_DEFAULT(_IOR('v' , BASE_VIDIOCPRIVATE+5, int)),
1818 IOCTL32_DEFAULT(_IOR('v' , BASE_VIDIOCPRIVATE+6, int)),
1819 IOCTL32_DEFAULT(_IOR('v' , BASE_VIDIOCPRIVATE+7, int)),
1820
1821
1822 IOCTL32_DEFAULT(FIOSETOWN),
1823 IOCTL32_DEFAULT(SIOCSPGRP),
1824 IOCTL32_DEFAULT(FIOGETOWN),
1825 IOCTL32_DEFAULT(SIOCGPGRP),
1826 IOCTL32_DEFAULT(SIOCATMARK),
1827 IOCTL32_DEFAULT(SIOCSIFLINK),
1828 IOCTL32_DEFAULT(SIOCSIFENCAP),
1829 IOCTL32_DEFAULT(SIOCGIFENCAP),
1830 IOCTL32_DEFAULT(SIOCSIFBR),
1831 IOCTL32_DEFAULT(SIOCGIFBR),
1832 IOCTL32_DEFAULT(SIOCSARP),
1833 IOCTL32_DEFAULT(SIOCGARP),
1834 IOCTL32_DEFAULT(SIOCDARP),
1835 IOCTL32_DEFAULT(SIOCSRARP),
1836 IOCTL32_DEFAULT(SIOCGRARP),
1837 IOCTL32_DEFAULT(SIOCDRARP),
1838 IOCTL32_DEFAULT(SIOCADDDLCI),
1839 IOCTL32_DEFAULT(SIOCDELDLCI),
1840
1841 IOCTL32_DEFAULT(SG_SET_TIMEOUT),
1842 IOCTL32_DEFAULT(SG_GET_TIMEOUT),
1843 IOCTL32_DEFAULT(SG_EMULATED_HOST),
1844 IOCTL32_DEFAULT(SG_SET_TRANSFORM),
1845 IOCTL32_DEFAULT(SG_GET_TRANSFORM),
1846 IOCTL32_DEFAULT(SG_SET_RESERVED_SIZE),
1847 IOCTL32_DEFAULT(SG_GET_RESERVED_SIZE),
1848 IOCTL32_DEFAULT(SG_GET_SCSI_ID),
1849 IOCTL32_DEFAULT(SG_SET_FORCE_LOW_DMA),
1850 IOCTL32_DEFAULT(SG_GET_LOW_DMA),
1851 IOCTL32_DEFAULT(SG_SET_FORCE_PACK_ID),
1852 IOCTL32_DEFAULT(SG_GET_PACK_ID),
1853 IOCTL32_DEFAULT(SG_GET_NUM_WAITING),
1854 IOCTL32_DEFAULT(SG_SET_DEBUG),
1855 IOCTL32_DEFAULT(SG_GET_SG_TABLESIZE),
1856 IOCTL32_DEFAULT(SG_GET_COMMAND_Q),
1857 IOCTL32_DEFAULT(SG_SET_COMMAND_Q),
1858 IOCTL32_DEFAULT(SG_GET_VERSION_NUM),
1859 IOCTL32_DEFAULT(SG_NEXT_CMD_LEN),
1860 IOCTL32_DEFAULT(SG_SCSI_RESET),
1861 IOCTL32_DEFAULT(SG_IO),
1862 IOCTL32_DEFAULT(SG_GET_REQUEST_TABLE),
1863 IOCTL32_DEFAULT(SG_SET_KEEP_ORPHAN),
1864 IOCTL32_DEFAULT(SG_GET_KEEP_ORPHAN),
1865
1866 IOCTL32_DEFAULT(PPPIOCGFLAGS),
1867 IOCTL32_DEFAULT(PPPIOCSFLAGS),
1868 IOCTL32_DEFAULT(PPPIOCGASYNCMAP),
1869 IOCTL32_DEFAULT(PPPIOCSASYNCMAP),
1870 IOCTL32_DEFAULT(PPPIOCGUNIT),
1871 IOCTL32_DEFAULT(PPPIOCGRASYNCMAP),
1872 IOCTL32_DEFAULT(PPPIOCSRASYNCMAP),
1873 IOCTL32_DEFAULT(PPPIOCGMRU),
1874 IOCTL32_DEFAULT(PPPIOCSMRU),
1875 IOCTL32_DEFAULT(PPPIOCSMAXCID),
1876 IOCTL32_DEFAULT(PPPIOCGXASYNCMAP),
1877 IOCTL32_DEFAULT(PPPIOCSXASYNCMAP),
1878 IOCTL32_DEFAULT(PPPIOCXFERUNIT),
1879 IOCTL32_DEFAULT(PPPIOCGNPMODE),
1880 IOCTL32_DEFAULT(PPPIOCSNPMODE),
1881 IOCTL32_DEFAULT(PPPIOCGDEBUG),
1882 IOCTL32_DEFAULT(PPPIOCSDEBUG),
1883 IOCTL32_DEFAULT(PPPIOCNEWUNIT),
1884 IOCTL32_DEFAULT(PPPIOCATTACH),
1885 IOCTL32_DEFAULT(PPPIOCGCHAN),
1886
1887 IOCTL32_DEFAULT(PPPOEIOCSFWD),
1888 IOCTL32_DEFAULT(PPPOEIOCDFWD),
1889
1890 IOCTL32_DEFAULT(CDROMPAUSE),
1891 IOCTL32_DEFAULT(CDROMRESUME),
1892 IOCTL32_DEFAULT(CDROMPLAYMSF),
1893 IOCTL32_DEFAULT(CDROMPLAYTRKIND),
1894 IOCTL32_DEFAULT(CDROMREADTOCHDR),
1895 IOCTL32_DEFAULT(CDROMREADTOCENTRY),
1896 IOCTL32_DEFAULT(CDROMSTOP),
1897 IOCTL32_DEFAULT(CDROMSTART),
1898 IOCTL32_DEFAULT(CDROMEJECT),
1899 IOCTL32_DEFAULT(CDROMVOLCTRL),
1900 IOCTL32_DEFAULT(CDROMSUBCHNL),
1901 IOCTL32_DEFAULT(CDROMEJECT_SW),
1902 IOCTL32_DEFAULT(CDROMMULTISESSION),
1903 IOCTL32_DEFAULT(CDROM_GET_MCN),
1904 IOCTL32_DEFAULT(CDROMRESET),
1905 IOCTL32_DEFAULT(CDROMVOLREAD),
1906 IOCTL32_DEFAULT(CDROMSEEK),
1907 IOCTL32_DEFAULT(CDROMPLAYBLK),
1908 IOCTL32_DEFAULT(CDROMCLOSETRAY),
1909 IOCTL32_DEFAULT(CDROM_SET_OPTIONS),
1910 IOCTL32_DEFAULT(CDROM_CLEAR_OPTIONS),
1911 IOCTL32_DEFAULT(CDROM_SELECT_SPEED),
1912 IOCTL32_DEFAULT(CDROM_SELECT_DISC),
1913 IOCTL32_DEFAULT(CDROM_MEDIA_CHANGED),
1914 IOCTL32_DEFAULT(CDROM_DRIVE_STATUS),
1915 IOCTL32_DEFAULT(CDROM_DISC_STATUS),
1916 IOCTL32_DEFAULT(CDROM_CHANGER_NSLOTS),
1917 IOCTL32_DEFAULT(CDROM_LOCKDOOR),
1918 IOCTL32_DEFAULT(CDROM_DEBUG),
1919 IOCTL32_DEFAULT(CDROM_GET_CAPABILITY),
1920
1921 IOCTL32_DEFAULT(DVD_READ_STRUCT),
1922 IOCTL32_DEFAULT(DVD_WRITE_STRUCT),
1923 IOCTL32_DEFAULT(DVD_AUTH),
1924
1925 IOCTL32_DEFAULT(LOOP_SET_FD),
1926 IOCTL32_DEFAULT(LOOP_CLR_FD),
1927 IOCTL32_HANDLER(LOOP_SET_STATUS, loop_status),
1928 IOCTL32_HANDLER(LOOP_GET_STATUS, loop_status),
1929
1930 IOCTL32_DEFAULT(SNDCTL_SEQ_RESET),
1931 IOCTL32_DEFAULT(SNDCTL_SEQ_SYNC),
1932 IOCTL32_DEFAULT(SNDCTL_SYNTH_INFO),
1933 IOCTL32_DEFAULT(SNDCTL_SEQ_CTRLRATE),
1934 IOCTL32_DEFAULT(SNDCTL_SEQ_GETOUTCOUNT),
1935 IOCTL32_DEFAULT(SNDCTL_SEQ_GETINCOUNT),
1936 IOCTL32_DEFAULT(SNDCTL_SEQ_PERCMODE),
1937 IOCTL32_DEFAULT(SNDCTL_FM_LOAD_INSTR),
1938 IOCTL32_DEFAULT(SNDCTL_SEQ_TESTMIDI),
1939 IOCTL32_DEFAULT(SNDCTL_SEQ_RESETSAMPLES),
1940 IOCTL32_DEFAULT(SNDCTL_SEQ_NRSYNTHS),
1941 IOCTL32_DEFAULT(SNDCTL_SEQ_NRMIDIS),
1942 IOCTL32_DEFAULT(SNDCTL_MIDI_INFO),
1943 IOCTL32_DEFAULT(SNDCTL_SEQ_THRESHOLD),
1944 IOCTL32_DEFAULT(SNDCTL_SYNTH_MEMAVL),
1945 IOCTL32_DEFAULT(SNDCTL_FM_4OP_ENABLE),
1946 IOCTL32_DEFAULT(SNDCTL_SEQ_PANIC),
1947 IOCTL32_DEFAULT(SNDCTL_SEQ_OUTOFBAND),
1948 IOCTL32_DEFAULT(SNDCTL_SEQ_GETTIME),
1949 IOCTL32_DEFAULT(SNDCTL_SYNTH_ID),
1950 IOCTL32_DEFAULT(SNDCTL_SYNTH_CONTROL),
1951 IOCTL32_DEFAULT(SNDCTL_SYNTH_REMOVESAMPLE),
1952
1953 IOCTL32_DEFAULT(SNDCTL_TMR_TIMEBASE),
1954 IOCTL32_DEFAULT(SNDCTL_TMR_START),
1955 IOCTL32_DEFAULT(SNDCTL_TMR_STOP),
1956 IOCTL32_DEFAULT(SNDCTL_TMR_CONTINUE),
1957 IOCTL32_DEFAULT(SNDCTL_TMR_TEMPO),
1958 IOCTL32_DEFAULT(SNDCTL_TMR_SOURCE),
1959 IOCTL32_DEFAULT(SNDCTL_TMR_METRONOME),
1960 IOCTL32_DEFAULT(SNDCTL_TMR_SELECT),
1961
1962 IOCTL32_DEFAULT(SNDCTL_MIDI_PRETIME),
1963 IOCTL32_DEFAULT(SNDCTL_MIDI_MPUMODE),
1964 IOCTL32_DEFAULT(SNDCTL_MIDI_MPUCMD),
1965
1966 IOCTL32_DEFAULT(SNDCTL_DSP_RESET),
1967 IOCTL32_DEFAULT(SNDCTL_DSP_SYNC),
1968 IOCTL32_DEFAULT(SNDCTL_DSP_SPEED),
1969 IOCTL32_DEFAULT(SNDCTL_DSP_STEREO),
1970 IOCTL32_DEFAULT(SNDCTL_DSP_GETBLKSIZE),
1971 IOCTL32_DEFAULT(SNDCTL_DSP_CHANNELS),
1972 IOCTL32_DEFAULT(SOUND_PCM_WRITE_FILTER),
1973 IOCTL32_DEFAULT(SNDCTL_DSP_POST),
1974 IOCTL32_DEFAULT(SNDCTL_DSP_SUBDIVIDE),
1975 IOCTL32_DEFAULT(SNDCTL_DSP_SETFRAGMENT),
1976 IOCTL32_DEFAULT(SNDCTL_DSP_GETFMTS),
1977 IOCTL32_DEFAULT(SNDCTL_DSP_SETFMT),
1978 IOCTL32_DEFAULT(SNDCTL_DSP_GETOSPACE),
1979 IOCTL32_DEFAULT(SNDCTL_DSP_GETISPACE),
1980 IOCTL32_DEFAULT(SNDCTL_DSP_NONBLOCK),
1981 IOCTL32_DEFAULT(SNDCTL_DSP_GETCAPS),
1982 IOCTL32_DEFAULT(SNDCTL_DSP_GETTRIGGER),
1983 IOCTL32_DEFAULT(SNDCTL_DSP_SETTRIGGER),
1984 IOCTL32_DEFAULT(SNDCTL_DSP_GETIPTR),
1985 IOCTL32_DEFAULT(SNDCTL_DSP_GETOPTR),
1986
1987
1988 IOCTL32_DEFAULT(SNDCTL_DSP_SETSYNCRO),
1989 IOCTL32_DEFAULT(SNDCTL_DSP_SETDUPLEX),
1990 IOCTL32_DEFAULT(SNDCTL_DSP_GETODELAY),
1991 IOCTL32_DEFAULT(SNDCTL_DSP_PROFILE),
1992 IOCTL32_DEFAULT(SOUND_PCM_READ_RATE),
1993 IOCTL32_DEFAULT(SOUND_PCM_READ_CHANNELS),
1994 IOCTL32_DEFAULT(SOUND_PCM_READ_BITS),
1995 IOCTL32_DEFAULT(SOUND_PCM_READ_FILTER),
1996
1997 IOCTL32_DEFAULT(SNDCTL_COPR_RESET),
1998 IOCTL32_DEFAULT(SNDCTL_COPR_LOAD),
1999 IOCTL32_DEFAULT(SNDCTL_COPR_RDATA),
2000 IOCTL32_DEFAULT(SNDCTL_COPR_RCODE),
2001 IOCTL32_DEFAULT(SNDCTL_COPR_WDATA),
2002 IOCTL32_DEFAULT(SNDCTL_COPR_WCODE),
2003 IOCTL32_DEFAULT(SNDCTL_COPR_RUN),
2004 IOCTL32_DEFAULT(SNDCTL_COPR_HALT),
2005 IOCTL32_DEFAULT(SNDCTL_COPR_SENDMSG),
2006 IOCTL32_DEFAULT(SNDCTL_COPR_RCVMSG),
2007
2008 IOCTL32_DEFAULT(SOUND_MIXER_READ_VOLUME),
2009 IOCTL32_DEFAULT(SOUND_MIXER_READ_BASS),
2010 IOCTL32_DEFAULT(SOUND_MIXER_READ_TREBLE),
2011 IOCTL32_DEFAULT(SOUND_MIXER_READ_SYNTH),
2012 IOCTL32_DEFAULT(SOUND_MIXER_READ_PCM),
2013 IOCTL32_DEFAULT(SOUND_MIXER_READ_SPEAKER),
2014 IOCTL32_DEFAULT(SOUND_MIXER_READ_LINE),
2015 IOCTL32_DEFAULT(SOUND_MIXER_READ_MIC),
2016 IOCTL32_DEFAULT(SOUND_MIXER_READ_CD),
2017 IOCTL32_DEFAULT(SOUND_MIXER_READ_IMIX),
2018 IOCTL32_DEFAULT(SOUND_MIXER_READ_ALTPCM),
2019 IOCTL32_DEFAULT(SOUND_MIXER_READ_RECLEV),
2020 IOCTL32_DEFAULT(SOUND_MIXER_READ_IGAIN),
2021 IOCTL32_DEFAULT(SOUND_MIXER_READ_OGAIN),
2022 IOCTL32_DEFAULT(SOUND_MIXER_READ_LINE1),
2023 IOCTL32_DEFAULT(SOUND_MIXER_READ_LINE2),
2024 IOCTL32_DEFAULT(SOUND_MIXER_READ_LINE3),
2025 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_DIGITAL1)),
2026 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_DIGITAL2)),
2027 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_DIGITAL3)),
2028 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_PHONEIN)),
2029 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_PHONEOUT)),
2030 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_VIDEO)),
2031 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_RADIO)),
2032 IOCTL32_DEFAULT(MIXER_READ(SOUND_MIXER_MONITOR)),
2033 IOCTL32_DEFAULT(SOUND_MIXER_READ_MUTE),
2034
2035
2036 IOCTL32_DEFAULT(SOUND_MIXER_READ_RECSRC),
2037 IOCTL32_DEFAULT(SOUND_MIXER_READ_DEVMASK),
2038 IOCTL32_DEFAULT(SOUND_MIXER_READ_RECMASK),
2039 IOCTL32_DEFAULT(SOUND_MIXER_READ_STEREODEVS),
2040 IOCTL32_DEFAULT(SOUND_MIXER_READ_CAPS),
2041 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_VOLUME),
2042 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_BASS),
2043 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_TREBLE),
2044 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_SYNTH),
2045 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_PCM),
2046 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_SPEAKER),
2047 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_LINE),
2048 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_MIC),
2049 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_CD),
2050 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_IMIX),
2051 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_ALTPCM),
2052 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_RECLEV),
2053 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_IGAIN),
2054 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_OGAIN),
2055 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_LINE1),
2056 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_LINE2),
2057 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_LINE3),
2058 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_DIGITAL1)),
2059 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_DIGITAL2)),
2060 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_DIGITAL3)),
2061 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_PHONEIN)),
2062 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_PHONEOUT)),
2063 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_VIDEO)),
2064 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_RADIO)),
2065 IOCTL32_DEFAULT(MIXER_WRITE(SOUND_MIXER_MONITOR)),
2066 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_MUTE),
2067
2068
2069 IOCTL32_DEFAULT(SOUND_MIXER_WRITE_RECSRC),
2070 IOCTL32_DEFAULT(SOUND_MIXER_INFO),
2071 IOCTL32_DEFAULT(SOUND_OLD_MIXER_INFO),
2072 IOCTL32_DEFAULT(SOUND_MIXER_ACCESS),
2073 IOCTL32_DEFAULT(SOUND_MIXER_PRIVATE1),
2074 IOCTL32_DEFAULT(SOUND_MIXER_PRIVATE2),
2075 IOCTL32_DEFAULT(SOUND_MIXER_PRIVATE3),
2076 IOCTL32_DEFAULT(SOUND_MIXER_PRIVATE4),
2077 IOCTL32_DEFAULT(SOUND_MIXER_PRIVATE5),
2078 IOCTL32_DEFAULT(SOUND_MIXER_GETLEVELS),
2079 IOCTL32_DEFAULT(SOUND_MIXER_SETLEVELS),
2080 IOCTL32_DEFAULT(OSS_GETVERSION),
2081
2082#ifdef CONFIG_NET
2083
2084 IOCTL32_HANDLER(SIOCGIFNAME, dev_ifname32),
2085 IOCTL32_HANDLER(SIOCGIFCONF, dev_ifconf),
2086 IOCTL32_HANDLER(SIOCGIFFLAGS, dev_ifsioc),
2087 IOCTL32_HANDLER(SIOCSIFFLAGS, dev_ifsioc),
2088 IOCTL32_HANDLER(SIOCGIFMETRIC, dev_ifsioc),
2089 IOCTL32_HANDLER(SIOCSIFMETRIC, dev_ifsioc),
2090 IOCTL32_HANDLER(SIOCGIFMTU, dev_ifsioc),
2091 IOCTL32_HANDLER(SIOCSIFMTU, dev_ifsioc),
2092 IOCTL32_HANDLER(SIOCGIFMEM, dev_ifsioc),
2093 IOCTL32_HANDLER(SIOCSIFMEM, dev_ifsioc),
2094 IOCTL32_HANDLER(SIOCGIFHWADDR, dev_ifsioc),
2095 IOCTL32_HANDLER(SIOCSIFHWADDR, dev_ifsioc),
2096 IOCTL32_HANDLER(SIOCADDMULTI, dev_ifsioc),
2097 IOCTL32_HANDLER(SIOCDELMULTI, dev_ifsioc),
2098 IOCTL32_HANDLER(SIOCGIFINDEX, dev_ifsioc),
2099 IOCTL32_HANDLER(SIOCGIFMAP, dev_ifsioc),
2100 IOCTL32_HANDLER(SIOCSIFMAP, dev_ifsioc),
2101 IOCTL32_HANDLER(SIOCGIFADDR, dev_ifsioc),
2102 IOCTL32_HANDLER(SIOCSIFADDR, dev_ifsioc),
2103 IOCTL32_HANDLER(SIOCGIFBRDADDR, dev_ifsioc),
2104 IOCTL32_HANDLER(SIOCSIFBRDADDR, dev_ifsioc),
2105 IOCTL32_HANDLER(SIOCGIFDSTADDR, dev_ifsioc),
2106 IOCTL32_HANDLER(SIOCSIFDSTADDR, dev_ifsioc),
2107 IOCTL32_HANDLER(SIOCGIFNETMASK, dev_ifsioc),
2108 IOCTL32_HANDLER(SIOCSIFNETMASK, dev_ifsioc),
2109 IOCTL32_HANDLER(SIOCSIFPFLAGS, dev_ifsioc),
2110 IOCTL32_HANDLER(SIOCGIFPFLAGS, dev_ifsioc),
2111 IOCTL32_HANDLER(SIOCGPPPSTATS, dev_ifsioc),
2112 IOCTL32_HANDLER(SIOCGPPPCSTATS, dev_ifsioc),
2113 IOCTL32_HANDLER(SIOCGPPPVER, dev_ifsioc),
2114 IOCTL32_HANDLER(SIOCGIFTXQLEN, dev_ifsioc),
2115 IOCTL32_HANDLER(SIOCSIFTXQLEN, dev_ifsioc),
2116 IOCTL32_HANDLER(SIOCADDRT, routing_ioctl),
2117 IOCTL32_HANDLER(SIOCDELRT, routing_ioctl),
2118
2119
2120
2121
2122 IOCTL32_HANDLER(SIOCRTMSG, ret_einval),
2123 IOCTL32_HANDLER(SIOCGSTAMP, do_siocgstamp),
2124#endif
2125
2126 IOCTL32_HANDLER(BLKRAGET, w_long),
2127 IOCTL32_HANDLER(BLKGETSIZE, w_long),
2128
2129 IOCTL32_HANDLER(BLKFRAGET, w_long),
2130 IOCTL32_HANDLER(BLKSECTGET, w_long),
2131 IOCTL32_HANDLER(BLKPG, blkpg_ioctl_trans),
2132
2133 IOCTL32_HANDLER(EXT2_IOC32_GETFLAGS, do_ext2_ioctl),
2134 IOCTL32_HANDLER(EXT2_IOC32_SETFLAGS, do_ext2_ioctl),
2135 IOCTL32_HANDLER(EXT2_IOC32_GETVERSION, do_ext2_ioctl),
2136 IOCTL32_HANDLER(EXT2_IOC32_SETVERSION, do_ext2_ioctl),
2137
2138 IOCTL32_HANDLER(VIDIOCGTUNER32, do_video_ioctl),
2139 IOCTL32_HANDLER(VIDIOCSTUNER32, do_video_ioctl),
2140 IOCTL32_HANDLER(VIDIOCGWIN32, do_video_ioctl),
2141 IOCTL32_HANDLER(VIDIOCSWIN32, do_video_ioctl),
2142 IOCTL32_HANDLER(VIDIOCGFBUF32, do_video_ioctl),
2143 IOCTL32_HANDLER(VIDIOCSFBUF32, do_video_ioctl),
2144 IOCTL32_HANDLER(VIDIOCGFREQ32, do_video_ioctl),
2145 IOCTL32_HANDLER(VIDIOCSFREQ32, do_video_ioctl),
2146
2147#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
2148 IOCTL32_HANDLER(VG_STATUS, do_lvm_ioctl),
2149 IOCTL32_HANDLER(VG_CREATE_OLD, do_lvm_ioctl),
2150 IOCTL32_HANDLER(VG_CREATE, do_lvm_ioctl),
2151 IOCTL32_HANDLER(VG_EXTEND, do_lvm_ioctl),
2152 IOCTL32_HANDLER(LV_CREATE, do_lvm_ioctl),
2153 IOCTL32_HANDLER(LV_REMOVE, do_lvm_ioctl),
2154 IOCTL32_HANDLER(LV_EXTEND, do_lvm_ioctl),
2155 IOCTL32_HANDLER(LV_REDUCE, do_lvm_ioctl),
2156 IOCTL32_HANDLER(LV_RENAME, do_lvm_ioctl),
2157 IOCTL32_HANDLER(LV_STATUS_BYNAME, do_lvm_ioctl),
2158 IOCTL32_HANDLER(LV_STATUS_BYINDEX, do_lvm_ioctl),
2159 IOCTL32_HANDLER(LV_STATUS_BYDEV, do_lvm_ioctl),
2160 IOCTL32_HANDLER(PV_CHANGE, do_lvm_ioctl),
2161 IOCTL32_HANDLER(PV_STATUS, do_lvm_ioctl),
2162#endif
2163
2164
2165
2166 IOCTL32_HANDLER(BLKELVGET_32, do_blkelvget),
2167 IOCTL32_HANDLER(BLKELVSET_32, do_blkelvset),
2168
2169 IOCTL32_HANDLER(BLKBSZGET_32, do_blkbszget),
2170 IOCTL32_HANDLER(BLKBSZSET_32, do_blkbszset),
2171 IOCTL32_HANDLER(BLKGETSIZE64_32, do_blkgetsize64),
2172
2173 IOCTL32_HANDLER(HDIO_GETGEO, hdio_getgeo),
2174 IOCTL32_HANDLER(HDIO_GET_UNMASKINTR, hdio_ioctl_trans),
2175 IOCTL32_HANDLER(HDIO_GET_MULTCOUNT, hdio_ioctl_trans),
2176
2177 IOCTL32_HANDLER(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans),
2178 IOCTL32_HANDLER(HDIO_GET_32BIT, hdio_ioctl_trans),
2179 IOCTL32_HANDLER(HDIO_GET_NOWERR, hdio_ioctl_trans),
2180 IOCTL32_HANDLER(HDIO_GET_DMA, hdio_ioctl_trans),
2181 IOCTL32_HANDLER(HDIO_GET_NICE, hdio_ioctl_trans),
2182 IOCTL32_DEFAULT(HDIO_GET_IDENTITY),
2183 IOCTL32_DEFAULT(HDIO_DRIVE_RESET),
2184
2185
2186 IOCTL32_DEFAULT(HDIO_DRIVE_CMD),
2187 IOCTL32_DEFAULT(HDIO_SET_MULTCOUNT),
2188 IOCTL32_DEFAULT(HDIO_SET_UNMASKINTR),
2189 IOCTL32_DEFAULT(HDIO_SET_KEEPSETTINGS),
2190 IOCTL32_DEFAULT(HDIO_SET_32BIT),
2191 IOCTL32_DEFAULT(HDIO_SET_NOWERR),
2192 IOCTL32_DEFAULT(HDIO_SET_DMA),
2193 IOCTL32_DEFAULT(HDIO_SET_PIO_MODE),
2194 IOCTL32_DEFAULT(HDIO_SCAN_HWIF),
2195 IOCTL32_DEFAULT(HDIO_SET_NICE),
2196
2197
2198 IOCTL32_DEFAULT(BLKROSET),
2199 IOCTL32_DEFAULT(BLKROGET),
2200 IOCTL32_DEFAULT(BLKRRPART),
2201 IOCTL32_DEFAULT(BLKFLSBUF),
2202 IOCTL32_DEFAULT(BLKRASET),
2203 IOCTL32_DEFAULT(BLKFRASET),
2204 IOCTL32_DEFAULT(BLKSECTSET),
2205 IOCTL32_DEFAULT(BLKSSZGET),
2206
2207
2208 IOCTL32_DEFAULT(RAID_VERSION),
2209 IOCTL32_DEFAULT(GET_ARRAY_INFO),
2210 IOCTL32_DEFAULT(GET_DISK_INFO),
2211 IOCTL32_DEFAULT(PRINT_RAID_DEBUG),
2212 IOCTL32_DEFAULT(CLEAR_ARRAY),
2213 IOCTL32_DEFAULT(ADD_NEW_DISK),
2214 IOCTL32_DEFAULT(HOT_REMOVE_DISK),
2215 IOCTL32_DEFAULT(SET_ARRAY_INFO),
2216 IOCTL32_DEFAULT(SET_DISK_INFO),
2217 IOCTL32_DEFAULT(WRITE_RAID_INFO),
2218 IOCTL32_DEFAULT(UNPROTECT_ARRAY),
2219 IOCTL32_DEFAULT(PROTECT_ARRAY),
2220 IOCTL32_DEFAULT(HOT_ADD_DISK),
2221 IOCTL32_DEFAULT(SET_DISK_FAULTY),
2222 IOCTL32_DEFAULT(RUN_ARRAY),
2223 IOCTL32_DEFAULT(START_ARRAY),
2224 IOCTL32_DEFAULT(STOP_ARRAY),
2225 IOCTL32_DEFAULT(STOP_ARRAY_RO),
2226 IOCTL32_DEFAULT(RESTART_ARRAY_RW),
2227 IOCTL32_DEFAULT(RAID_AUTORUN),
2228
2229
2230 IOCTL32_DEFAULT(PIO_FONT),
2231 IOCTL32_DEFAULT(GIO_FONT),
2232#ifdef CONFIG_VT
2233 IOCTL32_HANDLER(GIO_FONTX, do_fontx_ioctl),
2234 IOCTL32_HANDLER(PIO_FONTX, do_fontx_ioctl),
2235#endif
2236 IOCTL32_DEFAULT(KDSIGACCEPT),
2237 IOCTL32_DEFAULT(KDGETKEYCODE),
2238 IOCTL32_DEFAULT(KDSETKEYCODE),
2239 IOCTL32_DEFAULT(KIOCSOUND),
2240 IOCTL32_DEFAULT(KDMKTONE),
2241 IOCTL32_DEFAULT(KDGKBTYPE),
2242 IOCTL32_DEFAULT(KDSETMODE),
2243 IOCTL32_DEFAULT(KDGETMODE),
2244 IOCTL32_DEFAULT(KDSKBMODE),
2245 IOCTL32_DEFAULT(KDGKBMODE),
2246 IOCTL32_DEFAULT(KDSKBMETA),
2247 IOCTL32_DEFAULT(KDGKBMETA),
2248 IOCTL32_DEFAULT(KDGKBENT),
2249 IOCTL32_DEFAULT(KDSKBENT),
2250 IOCTL32_DEFAULT(KDGKBSENT),
2251 IOCTL32_DEFAULT(KDSKBSENT),
2252 IOCTL32_DEFAULT(KDGKBDIACR),
2253 IOCTL32_DEFAULT(KDKBDREP),
2254#ifdef CONFIG_VT
2255 IOCTL32_HANDLER(KDFONTOP, do_kdfontop_ioctl),
2256#endif
2257 IOCTL32_DEFAULT(KDSKBDIACR),
2258 IOCTL32_DEFAULT(KDGKBLED),
2259 IOCTL32_DEFAULT(KDSKBLED),
2260 IOCTL32_DEFAULT(KDGETLED),
2261 IOCTL32_DEFAULT(KDSETLED),
2262 IOCTL32_DEFAULT(GIO_SCRNMAP),
2263 IOCTL32_DEFAULT(PIO_SCRNMAP),
2264 IOCTL32_DEFAULT(GIO_UNISCRNMAP),
2265 IOCTL32_DEFAULT(PIO_UNISCRNMAP),
2266 IOCTL32_DEFAULT(PIO_FONTRESET),
2267 IOCTL32_DEFAULT(PIO_UNIMAPCLR),
2268
2269
2270 IOCTL32_DEFAULT(SCSI_IOCTL_GET_IDLUN),
2271 IOCTL32_DEFAULT(SCSI_IOCTL_PROBE_HOST),
2272 IOCTL32_DEFAULT(SCSI_IOCTL_GET_PCI),
2273 IOCTL32_DEFAULT(SCSI_IOCTL_DOORLOCK),
2274 IOCTL32_DEFAULT(SCSI_IOCTL_DOORUNLOCK),
2275 IOCTL32_DEFAULT(SCSI_IOCTL_TEST_UNIT_READY),
2276 IOCTL32_DEFAULT(SCSI_IOCTL_TAGGED_ENABLE),
2277 IOCTL32_DEFAULT(SCSI_IOCTL_TAGGED_DISABLE),
2278 IOCTL32_DEFAULT(SCSI_IOCTL_GET_BUS_NUMBER),
2279 IOCTL32_DEFAULT(SCSI_IOCTL_SEND_COMMAND),
2280
2281
2282 IOCTL32_DEFAULT(TUNSETNOCSUM),
2283 IOCTL32_DEFAULT(TUNSETDEBUG),
2284 IOCTL32_DEFAULT(TUNSETIFF),
2285 IOCTL32_DEFAULT(TUNSETPERSIST),
2286 IOCTL32_DEFAULT(TUNSETOWNER),
2287
2288
2289 IOCTL32_DEFAULT(VT_SETMODE),
2290 IOCTL32_DEFAULT(VT_GETMODE),
2291 IOCTL32_DEFAULT(VT_GETSTATE),
2292 IOCTL32_DEFAULT(VT_OPENQRY),
2293 IOCTL32_DEFAULT(VT_ACTIVATE),
2294 IOCTL32_DEFAULT(VT_WAITACTIVE),
2295 IOCTL32_DEFAULT(VT_RELDISP),
2296 IOCTL32_DEFAULT(VT_DISALLOCATE),
2297 IOCTL32_DEFAULT(VT_RESIZE),
2298 IOCTL32_DEFAULT(VT_RESIZEX),
2299 IOCTL32_DEFAULT(VT_LOCKSWITCH),
2300 IOCTL32_DEFAULT(VT_UNLOCKSWITCH),
2301
2302#ifdef CONFIG_MD
2303
2304 IOCTL32_DEFAULT(RAID_VERSION),
2305 IOCTL32_DEFAULT(GET_ARRAY_INFO),
2306 IOCTL32_DEFAULT(GET_DISK_INFO),
2307 IOCTL32_DEFAULT(PRINT_RAID_DEBUG),
2308 IOCTL32_DEFAULT(RAID_AUTORUN),
2309
2310
2311 IOCTL32_DEFAULT(CLEAR_ARRAY),
2312 IOCTL32_DEFAULT(ADD_NEW_DISK),
2313 IOCTL32_DEFAULT(HOT_REMOVE_DISK),
2314 IOCTL32_DEFAULT(SET_ARRAY_INFO),
2315 IOCTL32_DEFAULT(SET_DISK_INFO),
2316 IOCTL32_DEFAULT(WRITE_RAID_INFO),
2317 IOCTL32_DEFAULT(UNPROTECT_ARRAY),
2318 IOCTL32_DEFAULT(PROTECT_ARRAY),
2319 IOCTL32_DEFAULT(HOT_ADD_DISK),
2320 IOCTL32_DEFAULT(SET_DISK_FAULTY),
2321
2322
2323 IOCTL32_DEFAULT(RUN_ARRAY),
2324 IOCTL32_DEFAULT(START_ARRAY),
2325 IOCTL32_DEFAULT(STOP_ARRAY),
2326 IOCTL32_DEFAULT(STOP_ARRAY_RO),
2327 IOCTL32_DEFAULT(RESTART_ARRAY_RW),
2328#endif
2329
2330#ifdef CONFIG_SIBYTE_TBPROF
2331 IOCTL32_DEFAULT(SBPROF_ZBSTART),
2332 IOCTL32_DEFAULT(SBPROF_ZBSTOP),
2333 IOCTL32_DEFAULT(SBPROF_ZBWAITFULL),
2334#endif
2335
2336 IOCTL32_DEFAULT(MTIOCTOP),
2337 IOCTL32_HANDLER(MTIOCGET32, mt_ioctl_trans),
2338 IOCTL32_HANDLER(MTIOCPOS32, mt_ioctl_trans),
2339 IOCTL32_HANDLER(MTIOCGETCONFIG32, mt_ioctl_trans),
2340 IOCTL32_HANDLER(MTIOCSETCONFIG32, mt_ioctl_trans),
2341
2342
2343
2344
2345
2346
2347
2348 IOCTL32_DEFAULT(AUTOFS_IOC_READY),
2349 IOCTL32_DEFAULT(AUTOFS_IOC_FAIL),
2350 IOCTL32_DEFAULT(AUTOFS_IOC_CATATONIC),
2351 IOCTL32_DEFAULT(AUTOFS_IOC_PROTOVER),
2352 IOCTL32_HANDLER(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout),
2353 IOCTL32_DEFAULT(AUTOFS_IOC_EXPIRE),
2354 IOCTL32_DEFAULT(AUTOFS_IOC_EXPIRE_MULTI),
2355 IOCTL32_DEFAULT(AUTOFS_IOC_PROTSUBVER),
2356 IOCTL32_DEFAULT(AUTOFS_IOC_ASKREGHOST),
2357 IOCTL32_DEFAULT(AUTOFS_IOC_TOGGLEREGHOST),
2358 IOCTL32_DEFAULT(AUTOFS_IOC_ASKUMOUNT),
2359
2360
2361 IOCTL32_DEFAULT(DEVFSDIOC_GET_PROTO_REV),
2362 IOCTL32_DEFAULT(DEVFSDIOC_SET_EVENT_MASK),
2363 IOCTL32_DEFAULT(DEVFSDIOC_RELEASE_EVENT_QUEUE),
2364 IOCTL32_DEFAULT(DEVFSDIOC_SET_DEBUG_MASK),
2365
2366
2367 IOCTL32_DEFAULT(RAW_SETBIND),
2368 IOCTL32_DEFAULT(RAW_GETBIND),
2369
2370#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
2371
2372 IOCTL32_DEFAULT(VG_SET_EXTENDABLE),
2373 IOCTL32_DEFAULT(VG_STATUS_GET_COUNT),
2374 IOCTL32_DEFAULT(VG_STATUS_GET_NAMELIST),
2375 IOCTL32_DEFAULT(VG_REMOVE),
2376 IOCTL32_DEFAULT(VG_RENAME),
2377 IOCTL32_DEFAULT(VG_REDUCE),
2378 IOCTL32_DEFAULT(PE_LOCK_UNLOCK),
2379 IOCTL32_DEFAULT(PV_FLUSH),
2380 IOCTL32_DEFAULT(LVM_LOCK_LVM),
2381 IOCTL32_DEFAULT(LVM_GET_IOP_VERSION),
2382#ifdef LVM_TOTAL_RESET
2383 IOCTL32_DEFAULT(LVM_RESET),
2384#endif
2385 IOCTL32_DEFAULT(LV_SET_ACCESS),
2386 IOCTL32_DEFAULT(LV_SET_STATUS),
2387 IOCTL32_DEFAULT(LV_SET_ALLOCATION),
2388 IOCTL32_DEFAULT(LE_REMAP),
2389 IOCTL32_DEFAULT(LV_BMAP),
2390 IOCTL32_DEFAULT(LV_SNAPSHOT_USE_RATE),
2391#endif
2392
2393
2394 IOCTL32_DEFAULT(_IOR('p', 20, int[7])),
2395 IOCTL32_DEFAULT(_IOW('p', 21, int[7])),
2396 IOCTL32_DEFAULT(RTC_AIE_ON),
2397 IOCTL32_DEFAULT(RTC_AIE_OFF),
2398 IOCTL32_DEFAULT(RTC_UIE_ON),
2399 IOCTL32_DEFAULT(RTC_UIE_OFF),
2400 IOCTL32_DEFAULT(RTC_PIE_ON),
2401 IOCTL32_DEFAULT(RTC_PIE_OFF),
2402 IOCTL32_DEFAULT(RTC_WIE_ON),
2403 IOCTL32_DEFAULT(RTC_WIE_OFF),
2404 IOCTL32_DEFAULT(RTC_ALM_SET),
2405 IOCTL32_DEFAULT(RTC_ALM_READ),
2406 IOCTL32_DEFAULT(RTC_RD_TIME),
2407 IOCTL32_DEFAULT(RTC_SET_TIME),
2408 IOCTL32_DEFAULT(RTC_WKALM_SET),
2409 IOCTL32_DEFAULT(RTC_WKALM_RD),
2410
2411#ifdef CONFIG_MTD_CHAR
2412
2413 IOCTL32_DEFAULT(MEMGETINFO),
2414 IOCTL32_DEFAULT(MEMERASE),
2415
2416
2417 IOCTL32_DEFAULT(MEMLOCK),
2418 IOCTL32_DEFAULT(MEMUNLOCK),
2419 IOCTL32_DEFAULT(MEMGETREGIONCOUNT),
2420 IOCTL32_DEFAULT(MEMGETREGIONINFO),
2421#endif
2422};
2423
2424#define NR_IOCTL32_HANDLERS (sizeof(ioctl32_handler_table) / \
2425 sizeof(ioctl32_handler_table[0]))
2426
2427static struct ioctl32_list *ioctl32_hash_table[1024];
2428
2429static inline int ioctl32_hash(unsigned int cmd)
2430{
2431 return ((cmd >> 6) ^ (cmd >> 4) ^ cmd) & 0x3ff;
2432}
2433
2434int sys32_ioctl(unsigned int fd, unsigned int cmd, unsigned int arg)
2435{
2436 int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
2437 struct file *filp;
2438 struct ioctl32_list *l;
2439 int error;
2440
2441 l = ioctl32_hash_table[ioctl32_hash(cmd)];
2442
2443 error = -EBADF;
2444
2445 filp = fget(fd);
2446 if (!filp)
2447 return error;
2448
2449 if (!filp->f_op || !filp->f_op->ioctl) {
2450 error = sys_ioctl (fd, cmd, arg);
2451 goto out;
2452 }
2453
2454 while (l && l->handler.cmd != cmd)
2455 l = l->next;
2456
2457 if (l) {
2458 handler = (void *)l->handler.function;
2459 error = handler(fd, cmd, arg, filp);
2460 } else {
2461 error = -EINVAL;
2462 printk("unknown ioctl: %08x\n", cmd);
2463 }
2464out:
2465 fput(filp);
2466 return error;
2467}
2468
2469static void ioctl32_insert(struct ioctl32_list *entry)
2470{
2471 int hash = ioctl32_hash(entry->handler.cmd);
2472 if (!ioctl32_hash_table[hash])
2473 ioctl32_hash_table[hash] = entry;
2474 else {
2475 struct ioctl32_list *l;
2476 l = ioctl32_hash_table[hash];
2477 while (l->next)
2478 l = l->next;
2479 l->next = entry;
2480 entry->next = 0;
2481 }
2482}
2483
2484static int __init init_ioctl32(void)
2485{
2486 int i;
2487 for (i = 0; i < NR_IOCTL32_HANDLERS; i++)
2488 ioctl32_insert(&ioctl32_handler_table[i]);
2489 return 0;
2490}
2491
2492__initcall(init_ioctl32);
2493
