开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ia32_ioctl.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：120k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ia32_ioctl.c：源码内容
  1. /* $Id: ia32_ioctl.c,v 1.24 2002/09/17 15:23:41 ak Exp $
  2.  * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
  3.  *
  4.  * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
  5.  * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
  6.  * Copyright (C) 2001,2002  Andi Kleen, SuSE Labs 
  7.  *
  8.  * These routines maintain argument size conversion between 32bit and 64bit
  9.  * ioctls.
  10.  */
  12. #include <linux/config.h>
  13. #include <linux/types.h>
  14. #include <linux/kernel.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.h>
  23. #include <linux/kd.h>
  24. #include <linux/dirent.h>
  25. #include <linux/route.h>
  26. #include <linux/in6.h>
  27. #include <linux/ipv6_route.h>
  28. #include <linux/skbuff.h>
  29. #include <linux/netlink.h>
  30. #include <linux/vt.h>
  31. #include <linux/fs.h>
  32. #include <linux/file.h>
  33. #include <linux/fd.h>
  34. #include <linux/ppp_defs.h>
  35. #include <linux/if_ppp.h>
  36. #include <linux/if_pppox.h>
  37. #include <linux/mtio.h>
  38. #include <linux/cdrom.h>
  39. #include <linux/loop.h>
  40. #include <linux/auto_fs.h>
  41. #include <linux/devfs_fs.h>
  42. #include <linux/tty.h>
  43. #include <linux/vt_kern.h>
  44. #include <linux/fb.h>
  45. #include <linux/ext2_fs.h>
  46. #include <linux/videodev.h>
  47. #include <linux/netdevice.h>
  48. #include <linux/raw.h>
  49. #include <linux/smb_fs.h>
  50. #include <linux/blkpg.h>
  51. #include <linux/blk.h>
  52. #include <linux/elevator.h>
  53. #include <linux/rtc.h>
  54. #include <linux/pci.h>
  55. #include <linux/rtc.h>
  56. #include <linux/module.h>
  57. #include <linux/serial.h>
  58. #include <linux/reiserfs_fs.h>
  59. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  60. /* Ugh. This header really is not clean */
  61. #define min min
  62. #define max max
  63. #include <linux/lvm.h>
  64. #endif /* LVM */
  66. #include <scsi/scsi.h>
  67. /* Ugly hack. */
  68. #undef __KERNEL__
  69. #include <scsi/scsi_ioctl.h>
  70. #define __KERNEL__
  71. #include <scsi/sg.h>
  73. #include <asm/types.h>
  74. #include <asm/ia32.h>
  75. #include <asm/uaccess.h>
  76. #include <linux/ethtool.h>
  77. #include <asm/module.h>
  78. #include <asm/ioctl32.h>
  79. #include <linux/soundcard.h>
  81. #include <linux/atm.h>
  82. #include <linux/atmarp.h>
  83. #include <linux/atmclip.h>
  84. #include <linux/atmdev.h>
  85. #include <linux/atmioc.h>
  86. #include <linux/atmlec.h>
  87. #include <linux/atmmpc.h>
  88. #include <linux/atmsvc.h>
  89. #include <linux/atm_tcp.h>
  90. #include <linux/sonet.h>
  91. #include <linux/atm_suni.h>
  93. #define A(__x) ((void *)(unsigned long)(__x))
  94. #define AA(__x) A(__x)
  96. /* Aiee. Someone does not find a difference between int and long */
  97. #define EXT2_IOC32_GETFLAGS               _IOR('f', 1, int)
  98. #define EXT2_IOC32_SETFLAGS               _IOW('f', 2, int)
  99. #define EXT2_IOC32_GETVERSION             _IOR('v', 1, int)
  100. #define EXT2_IOC32_SETVERSION             _IOW('v', 2, int)
  102. extern asmlinkage int sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
  104. static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
  105. {
  106. mm_segment_t old_fs = get_fs();
  107. int err;
  108. unsigned long val;
  110. set_fs (KERNEL_DS);
  111. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  112. set_fs (old_fs);
  113. if (!err && put_user(val, (u32 *)arg))
  114. return -EFAULT;
  115. return err;
  116. }
  117.  
  118. static int rw_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;
  124. if(get_user(val, (u32 *)arg))
  125. return -EFAULT;
  126. set_fs (KERNEL_DS);
  127. err = sys_ioctl(fd, cmd, (unsigned long)&val);
  128. set_fs (old_fs);
  129. if (!err && put_user(val, (u32 *)arg))
  130. return -EFAULT;
  131. return err;
  132. }
  134. static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  135. {
  136. /* These are just misnamed, they actually get/put from/to user an int */
  137. switch (cmd) {
  138. case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
  139. case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
  140. case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
  141. case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
  142. }
  143. return sys_ioctl(fd, cmd, arg);
  144. }
  145.  
  146. struct video_tuner32 {
  147. s32 tuner;
  148. u8 name[32];
  149. u32 rangelow, rangehigh;
  150. u32 flags;
  151. u16 mode, signal;
  152. };
  154. static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
  155. {
  156. int i;
  158. if(get_user(kp->tuner, &up->tuner))
  159. return -EFAULT;
  160. for(i = 0; i < 32; i++)
  161. __get_user(kp->name[i], &up->name[i]);
  162. __get_user(kp->rangelow, &up->rangelow);
  163. __get_user(kp->rangehigh, &up->rangehigh);
  164. __get_user(kp->flags, &up->flags);
  165. __get_user(kp->mode, &up->mode);
  166. __get_user(kp->signal, &up->signal);
  167. return 0;
  168. }
  170. static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
  171. {
  172. int i;
  174. if(put_user(kp->tuner, &up->tuner))
  175. return -EFAULT;
  176. for(i = 0; i < 32; i++)
  177. __put_user(kp->name[i], &up->name[i]);
  178. __put_user(kp->rangelow, &up->rangelow);
  179. __put_user(kp->rangehigh, &up->rangehigh);
  180. __put_user(kp->flags, &up->flags);
  181. __put_user(kp->mode, &up->mode);
  182. __put_user(kp->signal, &up->signal);
  183. return 0;
  184. }
  186. struct video_buffer32 {
  187. /* void * */ u32 base;
  188. s32 height, width, depth, bytesperline;
  189. };
  191. static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
  192. {
  193. u32 tmp;
  195. if(get_user(tmp, &up->base))
  196. return -EFAULT;
  197. kp->base = (void *) ((unsigned long)tmp);
  198. __get_user(kp->height, &up->height);
  199. __get_user(kp->width, &up->width);
  200. __get_user(kp->depth, &up->depth);
  201. __get_user(kp->bytesperline, &up->bytesperline);
  202. return 0;
  203. }
  205. static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
  206. {
  207. u32 tmp = (u32)((unsigned long)kp->base);
  209. if(put_user(tmp, &up->base))
  210. return -EFAULT;
  211. __put_user(kp->height, &up->height);
  212. __put_user(kp->width, &up->width);
  213. __put_user(kp->depth, &up->depth);
  214. __put_user(kp->bytesperline, &up->bytesperline);
  215. return 0;
  216. }
  218. struct video_clip32 {
  219. s32 x, y, width, height;
  220. /* struct video_clip32 * */ u32 next;
  221. };
  223. struct video_window32 {
  224. u32 x, y, width, height, chromakey, flags;
  225. /* struct video_clip32 * */ u32 clips;
  226. s32 clipcount;
  227. };
  229. static void free_kvideo_clips(struct video_window *kp)
  230. {
  231. struct video_clip *cp;
  233. cp = kp->clips;
  234. if(cp != NULL)
  235. kfree(cp);
  236. }
  238. static int get_video_window32(struct video_window *kp, struct video_window32 *up)
  239. {
  240. struct video_clip32 *ucp;
  241. struct video_clip *kcp;
  242. int nclips, err, i;
  243. u32 tmp;
  245. if(get_user(kp->x, &up->x))
  246. return -EFAULT;
  247. __get_user(kp->y, &up->y);
  248. __get_user(kp->width, &up->width);
  249. __get_user(kp->height, &up->height);
  250. __get_user(kp->chromakey, &up->chromakey);
  251. __get_user(kp->flags, &up->flags);
  252. __get_user(kp->clipcount, &up->clipcount);
  253. __get_user(tmp, &up->clips);
  254. ucp = (struct video_clip32 *)A(tmp);
  255. kp->clips = NULL;
  257. nclips = kp->clipcount;
  258. if(nclips == 0)
  259. return 0;
  261. if(ucp == 0)
  262. return -EINVAL;
  264. /* Peculiar interface... */
  265. if(nclips < 0)
  266. nclips = VIDEO_CLIPMAP_SIZE;
  268. kcp = kmalloc(nclips * sizeof(struct video_clip), GFP_KERNEL);
  269. err = -ENOMEM;
  270. if(kcp == NULL)
  271. goto cleanup_and_err;
  273. kp->clips = kcp;
  274. for(i = 0; i < nclips; i++) {
  275. __get_user(kcp[i].x, &ucp[i].x);
  276. __get_user(kcp[i].y, &ucp[i].y);
  277. __get_user(kcp[i].width, &ucp[i].width);
  278. __get_user(kcp[i].height, &ucp[i].height);
  279. kcp[nclips].next = NULL;
  280. }
  282. return 0;
  284. cleanup_and_err:
  285. free_kvideo_clips(kp);
  286. return err;
  287. }
  289. /* You get back everything except the clips... */
  290. static int put_video_window32(struct video_window *kp, struct video_window32 *up)
  291. {
  292. if(put_user(kp->x, &up->x))
  293. return -EFAULT;
  294. __put_user(kp->y, &up->y);
  295. __put_user(kp->width, &up->width);
  296. __put_user(kp->height, &up->height);
  297. __put_user(kp->chromakey, &up->chromakey);
  298. __put_user(kp->flags, &up->flags);
  299. __put_user(kp->clipcount, &up->clipcount);
  300. return 0;
  301. }
  303. #define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
  304. #define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
  305. #define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
  306. #define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
  307. #define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
  308. #define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
  309. #define VIDIOCGFREQ32 _IOR('v',14, u32)
  310. #define VIDIOCSFREQ32 _IOW('v',15, u32)
  312. static int do_video_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  313. {
  314. union {
  315. struct video_tuner vt;
  316. struct video_buffer vb;
  317. struct video_window vw;
  318. unsigned long vx;
  319. } karg;
  320. mm_segment_t old_fs = get_fs();
  321. void *up = (void *)arg;
  322. int err = 0;
  324. /* First, convert the command. */
  325. switch(cmd) {
  326. case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
  327. case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
  328. case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
  329. case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
  330. case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
  331. case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
  332. case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
  333. case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
  334. };
  336. switch(cmd) {
  337. case VIDIOCSTUNER:
  338. case VIDIOCGTUNER:
  339. err = get_video_tuner32(&karg.vt, up);
  340. break;
  342. case VIDIOCSWIN:
  343. err = get_video_window32(&karg.vw, up);
  344. break;
  346. case VIDIOCSFBUF:
  347. err = get_video_buffer32(&karg.vb, up);
  348. break;
  350. case VIDIOCSFREQ:
  351. err = get_user(karg.vx, (u32 *)up);
  352. break;
  353. };
  354. if(err)
  355. goto out;
  357. set_fs(KERNEL_DS);
  358. err = sys_ioctl(fd, cmd, (unsigned long)&karg);
  359. set_fs(old_fs);
  361. if(cmd == VIDIOCSWIN)
  362. free_kvideo_clips(&karg.vw);
  364. if(err == 0) {
  365. switch(cmd) {
  366. case VIDIOCGTUNER:
  367. err = put_video_tuner32(&karg.vt, up);
  368. break;
  370. case VIDIOCGWIN:
  371. err = put_video_window32(&karg.vw, up);
  372. break;
  374. case VIDIOCGFBUF:
  375. err = put_video_buffer32(&karg.vb, up);
  376. break;
  378. case VIDIOCGFREQ:
  379. err = put_user(((u32)karg.vx), (u32 *)up);
  380. break;
  381. };
  382. }
  383. out:
  384. return err;
  385. }
  387. struct timeval32 {
  388. int tv_sec;
  389. int tv_usec;
  390. };
  392. static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
  393. {
  394. struct timeval32 *up = (struct timeval32 *)arg;
  395. struct timeval ktv;
  396. mm_segment_t old_fs = get_fs();
  397. int err;
  399. set_fs(KERNEL_DS);
  400. err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
  401. set_fs(old_fs);
  402. if(!err) {
  403. err = put_user(ktv.tv_sec, &up->tv_sec);
  404. err |= __put_user(ktv.tv_usec, &up->tv_usec);
  405. }
  406. return err;
  407. }
  409. struct ifmap32 {
  410. u32 mem_start;
  411. u32 mem_end;
  412. unsigned short base_addr;
  413. unsigned char irq;
  414. unsigned char dma;
  415. unsigned char port;
  416. };
  418. struct ifreq32 {
  419. #define IFHWADDRLEN     6
  420. #define IFNAMSIZ        16
  421.         union {
  422.                 char    ifrn_name[IFNAMSIZ];            /* if name, e.g. "en0" */
  423.         } ifr_ifrn;
  424.         union {
  425.                 struct  sockaddr ifru_addr;
  426.                 struct  sockaddr ifru_dstaddr;
  427.                 struct  sockaddr ifru_broadaddr;
  428.                 struct  sockaddr ifru_netmask;
  429.                 struct  sockaddr ifru_hwaddr;
  430.                 short   ifru_flags;
  431.                 int     ifru_ivalue;
  432.                 int     ifru_mtu;
  433.                 struct  ifmap32 ifru_map;
  434.                 char    ifru_slave[IFNAMSIZ];   /* Just fits the size */
  435. char ifru_newname[IFNAMSIZ];
  436.                 __kernel_caddr_t32 ifru_data;
  437.         } ifr_ifru;
  438. };
  440. struct ifconf32 {
  441.         int     ifc_len;                        /* size of buffer       */
  442.         __kernel_caddr_t32  ifcbuf;
  443. };
  445. static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
  446. {
  447. struct net_device *dev;
  448. struct ifreq32 ifr32;
  449. int err;
  451. if (copy_from_user(&ifr32, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  452. return -EFAULT;
  454. dev = dev_get_by_index(ifr32.ifr_ifindex);
  455. if (!dev)
  456. return -ENODEV;
  458. strncpy(ifr32.ifr_name, dev->name, sizeof(ifr32.ifr_name)-1);
  459. ifr32.ifr_name[sizeof(ifr32.ifr_name)-1] = 0; 
  461. err = copy_to_user((struct ifreq32 *)arg, &ifr32, sizeof(struct ifreq32));
  462. return (err ? -EFAULT : 0);
  463. }
  465. static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
  466. {
  467. struct ifconf32 ifc32;
  468. struct ifconf ifc;
  469. struct ifreq32 *ifr32;
  470. struct ifreq *ifr;
  471. mm_segment_t old_fs;
  472. unsigned int i, j;
  473. int err;
  475. if (copy_from_user(&ifc32, (struct ifconf32 *)arg, sizeof(struct ifconf32)))
  476. return -EFAULT;
  478. if(ifc32.ifcbuf == 0) {
  479. ifc32.ifc_len = 0;
  480. ifc.ifc_len = 0;
  481. ifc.ifc_buf = NULL;
  482. } else {
  483. ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) *
  484. sizeof (struct ifreq);
  485. ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
  486. if (!ifc.ifc_buf)
  487. return -ENOMEM;
  488. }
  489. ifr = ifc.ifc_req;
  490. ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
  491. for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
  492. if (copy_from_user(ifr, ifr32, sizeof (struct ifreq32))) {
  493. kfree (ifc.ifc_buf);
  494. return -EFAULT;
  495. }
  496. ifr++;
  497. ifr32++; 
  498. }
  499. old_fs = get_fs(); set_fs (KERNEL_DS);
  500. err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
  501. set_fs (old_fs);
  502. if (!err) {
  503. ifr = ifc.ifc_req;
  504. ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
  505. for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
  506.      i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
  507. int k = copy_to_user(ifr32, ifr, sizeof (struct ifreq32));
  508. ifr32++;
  509. ifr++;
  510. if (k) {
  511. err = -EFAULT;
  512. break;
  513. }
  514.        
  515. }
  516. if (!err) {
  517. if (ifc32.ifcbuf == 0) {
  518. /* Translate from 64-bit structure multiple to
  519.  * a 32-bit one.
  520.  */
  521. i = ifc.ifc_len;
  522. i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
  523. ifc32.ifc_len = i;
  524. } else {
  525. if (i <= ifc32.ifc_len)
  526. ifc32.ifc_len = i;
  527. else
  528. ifc32.ifc_len = i - sizeof (struct ifreq32);
  529. }
  530. if (copy_to_user((struct ifconf32 *)arg, &ifc32, sizeof(struct ifconf32)))
  531. err = -EFAULT;
  532. }
  533. }
  534. if(ifc.ifc_buf != NULL)
  535. kfree (ifc.ifc_buf);
  536. return err;
  537. }
  539. static int ethtool_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  540. {
  541. struct ifreq ifr;
  542. mm_segment_t old_fs;
  543. int err, len;
  544. u32 data, ethcmd;
  546. if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  547. return -EFAULT;
  548. ifr.ifr_data = (__kernel_caddr_t)get_free_page(GFP_KERNEL);
  549. if (!ifr.ifr_data)
  550. return -EAGAIN;
  552. __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
  554. if (get_user(ethcmd, (u32 *)A(data))) {
  555. err = -EFAULT;
  556. goto out;
  557. }
  558. switch (ethcmd) {
  559. case ETHTOOL_GDRVINFO: len = sizeof(struct ethtool_drvinfo); break;
  560. case ETHTOOL_GSET:
  561. case ETHTOOL_SSET:
  562. default: len = sizeof(struct ethtool_cmd); break;
  563. }
  565. if (copy_from_user(ifr.ifr_data, (char *)A(data), len)) {
  566. err = -EFAULT;
  567. goto out;
  568. }
  570. old_fs = get_fs();
  571. set_fs (KERNEL_DS);
  572. err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
  573. set_fs (old_fs);
  574. if (!err) {
  575. u32 data;
  577. __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
  578. len = copy_to_user((char *)A(data), ifr.ifr_data, len);
  579. if (len)
  580. err = -EFAULT;
  581. }
  583. out:
  584. free_page((unsigned long)ifr.ifr_data);
  585. return err;
  586. }
  588. static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  589. {
  590. struct ifreq ifr;
  591. mm_segment_t old_fs;
  592. int err;
  594. switch (cmd) {
  595. case SIOCSIFMAP:
  596. err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
  597. err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
  598. err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
  599. err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
  600. err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
  601. err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
  602. err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
  603. if (err)
  604. return -EFAULT;
  605. break;
  606. case SIOCGPPPSTATS:
  607. case SIOCGPPPCSTATS:
  608. case SIOCGPPPVER:
  609. if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  610. return -EFAULT;
  611. ifr.ifr_data = (__kernel_caddr_t)get_free_page(GFP_KERNEL);
  612. if (!ifr.ifr_data)
  613. return -EAGAIN;
  614. break;
  615. default:
  616. if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
  617. return -EFAULT;
  618. break;
  619. }
  620. old_fs = get_fs();
  621. set_fs (KERNEL_DS);
  622. err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
  623. set_fs (old_fs);
  624. if (!err) {
  625. switch (cmd) {
  626. case SIOCGIFFLAGS:
  627. case SIOCGIFMETRIC:
  628. case SIOCGIFMTU:
  629. case SIOCGIFMEM:
  630. case SIOCGIFHWADDR:
  631. case SIOCGIFINDEX:
  632. case SIOCGIFADDR:
  633. case SIOCGIFBRDADDR:
  634. case SIOCGIFDSTADDR:
  635. case SIOCGIFNETMASK:
  636. case SIOCGIFTXQLEN:
  637. if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
  638. return -EFAULT;
  639. break;
  640. case SIOCGPPPSTATS:
  641. case SIOCGPPPCSTATS:
  642. case SIOCGPPPVER:
  643. {
  644. u32 data;
  645. int len;
  647. __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
  648. if(cmd == SIOCGPPPVER)
  649. len = strlen((char *)ifr.ifr_data) + 1;
  650. else if(cmd == SIOCGPPPCSTATS)
  651. len = sizeof(struct ppp_comp_stats);
  652. else
  653. len = sizeof(struct ppp_stats);
  655. len = copy_to_user((char *)A(data), ifr.ifr_data, len);
  656. free_page((unsigned long)ifr.ifr_data);
  657. if(len)
  658. return -EFAULT;
  659. break;
  660. }
  661. case SIOCGIFMAP:
  662. err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
  663. err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
  664. err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
  665. err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
  666. err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
  667. err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
  668. err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
  669. if (err)
  670. err = -EFAULT;
  671. break;
  672. }
  673. } else {
  674. switch (cmd) {
  675. case SIOCGPPPSTATS:
  676. case SIOCGPPPCSTATS:
  677. case SIOCGPPPVER:
  678. free_page((unsigned long)ifr.ifr_data);
  679. break;
  680. }
  681. }
  682. return err;
  683. }
  685. struct rtentry32 {
  686.         u32    rt_pad1;
  687.         struct sockaddr rt_dst;         /* target address               */
  688.         struct sockaddr rt_gateway;     /* gateway addr (RTF_GATEWAY)   */
  689.         struct sockaddr rt_genmask;     /* target network mask (IP)     */
  690.         unsigned short  rt_flags;
  691.         short           rt_pad2;
  692.         u32    rt_pad3;
  693.         unsigned char   rt_tos;
  694.         unsigned char   rt_class;
  695.         short           rt_pad4;
  696.         short           rt_metric;      /* +1 for binary compatibility! */
  697.         /* char * */ u32 rt_dev;        /* forcing the device at add    */
  698.         u32    rt_mtu;         /* per route MTU/Window         */
  699.         u32    rt_window;      /* Window clamping              */
  700.         unsigned short  rt_irtt;        /* Initial RTT                  */
  702. };
  704. struct in6_rtmsg32 {
  705. struct in6_addr rtmsg_dst;
  706. struct in6_addr rtmsg_src;
  707. struct in6_addr rtmsg_gateway;
  708. u32 rtmsg_type;
  709. u16 rtmsg_dst_len;
  710. u16 rtmsg_src_len;
  711. u32 rtmsg_metric;
  712. u32 rtmsg_info;
  713. u32 rtmsg_flags;
  714. s32 rtmsg_ifindex;
  715. };
  717. extern struct socket *sockfd_lookup(int fd, int *err);
  719. extern __inline__ void sockfd_put(struct socket *sock)
  720. {
  721. fput(sock->file);
  722. }
  724. static int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  725. {
  726. int ret;
  727. void *r = NULL;
  728. struct in6_rtmsg r6;
  729. struct rtentry r4;
  730. char devname[16];
  731. u32 rtdev;
  732. mm_segment_t old_fs = get_fs();
  734. struct socket *mysock = sockfd_lookup(fd, &ret);
  736. if (mysock && mysock->sk && mysock->sk->family == AF_INET6) { /* ipv6 */
  737. ret = copy_from_user (&r6.rtmsg_dst, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst),
  738. 3 * sizeof(struct in6_addr));
  739. ret |= __get_user (r6.rtmsg_type, &(((struct in6_rtmsg32 *)arg)->rtmsg_type));
  740. ret |= __get_user (r6.rtmsg_dst_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst_len));
  741. ret |= __get_user (r6.rtmsg_src_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_src_len));
  742. ret |= __get_user (r6.rtmsg_metric, &(((struct in6_rtmsg32 *)arg)->rtmsg_metric));
  743. ret |= __get_user (r6.rtmsg_info, &(((struct in6_rtmsg32 *)arg)->rtmsg_info));
  744. ret |= __get_user (r6.rtmsg_flags, &(((struct in6_rtmsg32 *)arg)->rtmsg_flags));
  745. ret |= __get_user (r6.rtmsg_ifindex, &(((struct in6_rtmsg32 *)arg)->rtmsg_ifindex));
  747. r = (void *) &r6;
  748. } else { /* ipv4 */
  749. ret = copy_from_user (&r4.rt_dst, &(((struct rtentry32 *)arg)->rt_dst), 3 * sizeof(struct sockaddr));
  750. ret |= __get_user (r4.rt_flags, &(((struct rtentry32 *)arg)->rt_flags));
  751. ret |= __get_user (r4.rt_metric, &(((struct rtentry32 *)arg)->rt_metric));
  752. ret |= __get_user (r4.rt_mtu, &(((struct rtentry32 *)arg)->rt_mtu));
  753. ret |= __get_user (r4.rt_window, &(((struct rtentry32 *)arg)->rt_window));
  754. ret |= __get_user (r4.rt_irtt, &(((struct rtentry32 *)arg)->rt_irtt));
  755. ret |= __get_user (rtdev, &(((struct rtentry32 *)arg)->rt_dev));
  756. if (rtdev) {
  757. ret |= copy_from_user (devname, (char *)A(rtdev), 15);
  758. r4.rt_dev = devname; devname[15] = 0;
  759. } else
  760. r4.rt_dev = 0;
  762. r = (void *) &r4;
  763. }
  765. if (ret)
  766. return -EFAULT;
  768. set_fs (KERNEL_DS);
  769. ret = sys_ioctl (fd, cmd, (long) r);
  770. set_fs (old_fs);
  772. if (mysock)
  773. sockfd_put(mysock);
  775. return ret;
  776. }
  778. struct hd_geometry32 {
  779. unsigned char heads;
  780. unsigned char sectors;
  781. unsigned short cylinders;
  782. u32 start;
  783. };
  784.                         
  785. static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
  786. {
  787. mm_segment_t old_fs = get_fs();
  788. struct hd_geometry geo;
  789. int err;
  791. set_fs (KERNEL_DS);
  792. err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
  793. set_fs (old_fs);
  794. if (!err) {
  795. err = copy_to_user ((struct hd_geometry32 *)arg, &geo, 4);
  796. err |= __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start));
  797. }
  798. return err ? -EFAULT : 0;
  799. }
  801. struct  fbcmap32 {
  802. int             index;          /* first element (0 origin) */
  803. int             count;
  804. u32 red;
  805. u32 green;
  806. u32 blue;
  807. };
  809. struct fb_fix_screeninfo32 {
  810. char id[16];
  811.         __kernel_caddr_t32 smem_start;
  812. __u32 smem_len;
  813. __u32 type;
  814. __u32 type_aux;
  815. __u32 visual;
  816. __u16 xpanstep;
  817. __u16 ypanstep;
  818. __u16 ywrapstep;
  819. __u32 line_length;
  820.         __kernel_caddr_t32 mmio_start;
  821. __u32 mmio_len;
  822. __u32 accel;
  823. __u16 reserved[3];
  824. };
  826. struct fb_cmap32 {
  827. __u32 start;
  828. __u32 len;
  829. __kernel_caddr_t32 red;
  830. __kernel_caddr_t32 green;
  831. __kernel_caddr_t32 blue;
  832. __kernel_caddr_t32 transp;
  833. };
  835. static int fb_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  836. {
  837. mm_segment_t old_fs = get_fs();
  838. u32 red = 0, green = 0, blue = 0, transp = 0;
  839. struct fb_fix_screeninfo fix;
  840. struct fb_cmap cmap;
  841. void *karg;
  842. int err = 0;
  844. memset(&cmap, 0, sizeof(cmap));
  845. switch (cmd) {
  846. case FBIOGET_FSCREENINFO:
  847. karg = &fix;
  848. break;
  849. case FBIOGETCMAP:
  850. case FBIOPUTCMAP:
  851. karg = &cmap;
  852. err = __get_user(cmap.start, &((struct fb_cmap32 *)arg)->start);
  853. err |= __get_user(cmap.len, &((struct fb_cmap32 *)arg)->len);
  854. err |= __get_user(red, &((struct fb_cmap32 *)arg)->red);
  855. err |= __get_user(green, &((struct fb_cmap32 *)arg)->green);
  856. err |= __get_user(blue, &((struct fb_cmap32 *)arg)->blue);
  857. err |= __get_user(transp, &((struct fb_cmap32 *)arg)->transp);
  858. if (err) {
  859. err = -EFAULT;
  860. goto out;
  861. }
  862. err = -ENOMEM;
  863. cmap.red = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  864. if (!cmap.red)
  865. goto out;
  866. cmap.green = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  867. if (!cmap.green)
  868. goto out;
  869. cmap.blue = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  870. if (!cmap.blue)
  871. goto out;
  872. if (transp) {
  873. cmap.transp = kmalloc(cmap.len * sizeof(__u16), GFP_KERNEL);
  874. if (!cmap.transp)
  875. goto out;
  876. }
  878. if (cmd == FBIOGETCMAP)
  879. break;
  881. err = __copy_from_user(cmap.red, (char *)A(red), cmap.len * sizeof(__u16));
  882. err |= __copy_from_user(cmap.green, (char *)A(green), cmap.len * sizeof(__u16));
  883. err |= __copy_from_user(cmap.blue, (char *)A(blue), cmap.len * sizeof(__u16));
  884. if (cmap.transp) err |= __copy_from_user(cmap.transp, (char *)A(transp), cmap.len * sizeof(__u16));
  885. if (err) {
  886. err = -EFAULT;
  887. goto out;
  888. }
  889. break;
  890. default:
  891. do {
  892. static int count = 0;
  893. if (++count <= 20)
  894. printk("%s: Unknown fb ioctl cmd fd(%d) "
  895.        "cmd(%08x) arg(%08lx)n",
  896.        __FUNCTION__, fd, cmd, arg);
  897. } while(0);
  898. return -ENOSYS;
  899. }
  900. set_fs(KERNEL_DS);
  901. err = sys_ioctl(fd, cmd, (unsigned long)karg);
  902. set_fs(old_fs);
  903. if (err)
  904. goto out;
  905. switch (cmd) {
  906. case FBIOGET_FSCREENINFO:
  907. err = __copy_to_user((char *)((struct fb_fix_screeninfo32 *)arg)->id, (char *)fix.id, sizeof(fix.id));
  908. err |= __put_user((__u32)(unsigned long)fix.smem_start, &((struct fb_fix_screeninfo32 *)arg)->smem_start);
  909. err |= __put_user(fix.smem_len, &((struct fb_fix_screeninfo32 *)arg)->smem_len);
  910. err |= __put_user(fix.type, &((struct fb_fix_screeninfo32 *)arg)->type);
  911. err |= __put_user(fix.type_aux, &((struct fb_fix_screeninfo32 *)arg)->type_aux);
  912. err |= __put_user(fix.visual, &((struct fb_fix_screeninfo32 *)arg)->visual);
  913. err |= __put_user(fix.xpanstep, &((struct fb_fix_screeninfo32 *)arg)->xpanstep);
  914. err |= __put_user(fix.ypanstep, &((struct fb_fix_screeninfo32 *)arg)->ypanstep);
  915. err |= __put_user(fix.ywrapstep, &((struct fb_fix_screeninfo32 *)arg)->ywrapstep);
  916. err |= __put_user(fix.line_length, &((struct fb_fix_screeninfo32 *)arg)->line_length);
  917. err |= __put_user((__u32)(unsigned long)fix.mmio_start, &((struct fb_fix_screeninfo32 *)arg)->mmio_start);
  918. err |= __put_user(fix.mmio_len, &((struct fb_fix_screeninfo32 *)arg)->mmio_len);
  919. err |= __put_user(fix.accel, &((struct fb_fix_screeninfo32 *)arg)->accel);
  920. err |= __copy_to_user((char *)((struct fb_fix_screeninfo32 *)arg)->reserved, (char *)fix.reserved, sizeof(fix.reserved));
  921. break;
  922. case FBIOGETCMAP:
  923. err = __copy_to_user((char *)A(red), cmap.red, cmap.len * sizeof(__u16));
  924. err |= __copy_to_user((char *)A(green), cmap.blue, cmap.len * sizeof(__u16));
  925. err |= __copy_to_user((char *)A(blue), cmap.blue, cmap.len * sizeof(__u16));
  926. if (cmap.transp)
  927. err |= __copy_to_user((char *)A(transp), cmap.transp, cmap.len * sizeof(__u16));
  928. break;
  929. case FBIOPUTCMAP:
  930. break;
  931. }
  932. if (err)
  933. err = -EFAULT;
  935. out: if (cmap.red) kfree(cmap.red);
  936. if (cmap.green) kfree(cmap.green);
  937. if (cmap.blue) kfree(cmap.blue);
  938. if (cmap.transp) kfree(cmap.transp);
  939. return err;
  940. }
  942. static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  943. {
  944. mm_segment_t old_fs = get_fs();
  945. unsigned long kval;
  946. unsigned int *uvp;
  947. int error;
  949. set_fs(KERNEL_DS);
  950. error = sys_ioctl(fd, cmd, (long)&kval);
  951. set_fs(old_fs);
  953. if(error == 0) {
  954. uvp = (unsigned int *)arg;
  955. if(put_user(kval, uvp))
  956. error = -EFAULT;
  957. }
  958. return error;
  959. }
  961. struct floppy_struct32 {
  962. unsigned int size;
  963. unsigned int sect;
  964. unsigned int head;
  965. unsigned int track;
  966. unsigned int stretch;
  967. unsigned char gap;
  968. unsigned char rate;
  969. unsigned char spec1;
  970. unsigned char fmt_gap;
  971. const __kernel_caddr_t32 name;
  972. };
  974. struct floppy_drive_params32 {
  975. char cmos;
  976. u32 max_dtr;
  977. u32 hlt;
  978. u32 hut;
  979. u32 srt;
  980. u32 spinup;
  981. u32 spindown;
  982. unsigned char spindown_offset;
  983. unsigned char select_delay;
  984. unsigned char rps;
  985. unsigned char tracks;
  986. u32 timeout;
  987. unsigned char interleave_sect;
  988. struct floppy_max_errors max_errors;
  989. char flags;
  990. char read_track;
  991. short autodetect[8];
  992. int checkfreq;
  993. int native_format;
  994. };
  996. struct floppy_drive_struct32 {
  997. signed char flags;
  998. u32 spinup_date;
  999. u32 select_date;
  1000. u32 first_read_date;
  1001. short probed_format;
  1002. short track;
  1003. short maxblock;
  1004. short maxtrack;
  1005. int generation;
  1006. int keep_data;
  1007. int fd_ref;
  1008. int fd_device;
  1009. int last_checked;
  1010. __kernel_caddr_t32 dmabuf;
  1011. int bufblocks;
  1012. };
  1014. struct floppy_fdc_state32 {
  1015. int spec1;
  1016. int spec2;
  1017. int dtr;
  1018. unsigned char version;
  1019. unsigned char dor;
  1020. u32 address;
  1021. unsigned int rawcmd:2;
  1022. unsigned int reset:1;
  1023. unsigned int need_configure:1;
  1024. unsigned int perp_mode:2;
  1025. unsigned int has_fifo:1;
  1026. unsigned int driver_version;
  1027. unsigned char track[4];
  1028. };
  1030. struct floppy_write_errors32 {
  1031. unsigned int write_errors;
  1032. u32 first_error_sector;
  1033. int first_error_generation;
  1034. u32 last_error_sector;
  1035. int last_error_generation;
  1036. unsigned int badness;
  1037. };
  1039. #define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
  1040. #define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
  1041. #define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
  1042. #define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
  1043. #define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
  1044. #define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
  1045. #define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
  1046. #define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
  1047. #define FDWERRORGET32  _IOR(2, 0x17, struct floppy_write_errors32)
  1049. static struct {
  1050. unsigned int cmd32;
  1051. unsigned int cmd;
  1052. } fd_ioctl_trans_table[] = {
  1053. { FDSETPRM32, FDSETPRM },
  1054. { FDDEFPRM32, FDDEFPRM },
  1055. { FDGETPRM32, FDGETPRM },
  1056. { FDSETDRVPRM32, FDSETDRVPRM },
  1057. { FDGETDRVPRM32, FDGETDRVPRM },
  1058. { FDGETDRVSTAT32, FDGETDRVSTAT },
  1059. { FDPOLLDRVSTAT32, FDPOLLDRVSTAT },
  1060. { FDGETFDCSTAT32, FDGETFDCSTAT },
  1061. { FDWERRORGET32, FDWERRORGET }
  1062. };
  1064. #define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
  1066. static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1067. {
  1068. mm_segment_t old_fs = get_fs();
  1069. void *karg = NULL;
  1070. unsigned int kcmd = 0;
  1071. int i, err;
  1073. for (i = 0; i < NR_FD_IOCTL_TRANS; i++)
  1074. if (cmd == fd_ioctl_trans_table[i].cmd32) {
  1075. kcmd = fd_ioctl_trans_table[i].cmd;
  1076. break;
  1077. }
  1078. if (!kcmd)
  1079. return -EINVAL;
  1081. switch (cmd) {
  1082. case FDSETPRM32:
  1083. case FDDEFPRM32:
  1084. case FDGETPRM32:
  1085. {
  1086. struct floppy_struct *f;
  1088. f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
  1089. if (!karg)
  1090. return -ENOMEM;
  1091. if (cmd == FDGETPRM32)
  1092. break;
  1093. err = __get_user(f->size, &((struct floppy_struct32 *)arg)->size);
  1094. err |= __get_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
  1095. err |= __get_user(f->head, &((struct floppy_struct32 *)arg)->head);
  1096. err |= __get_user(f->track, &((struct floppy_struct32 *)arg)->track);
  1097. err |= __get_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
  1098. err |= __get_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
  1099. err |= __get_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
  1100. err |= __get_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
  1101. err |= __get_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
  1102. err |= __get_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
  1103. if (err) {
  1104. err = -EFAULT;
  1105. goto out;
  1106. }
  1107. break;
  1108. }
  1109. case FDSETDRVPRM32:
  1110. case FDGETDRVPRM32:
  1111. {
  1112. struct floppy_drive_params *f;
  1114. f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
  1115. if (!karg)
  1116. return -ENOMEM;
  1117. if (cmd == FDGETDRVPRM32)
  1118. break;
  1119. err = __get_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
  1120. err |= __get_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
  1121. err |= __get_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
  1122. err |= __get_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
  1123. err |= __get_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
  1124. err |= __get_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
  1125. err |= __get_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
  1126. err |= __get_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
  1127. err |= __get_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
  1128. err |= __get_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
  1129. err |= __get_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
  1130. err |= __get_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
  1131. err |= __get_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
  1132. err |= __copy_from_user(&f->max_errors, &((struct floppy_drive_params32 *)arg)->max_errors, sizeof(f->max_errors));
  1133. err |= __get_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
  1134. err |= __get_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
  1135. err |= __copy_from_user(f->autodetect, ((struct floppy_drive_params32 *)arg)->autodetect, sizeof(f->autodetect));
  1136. err |= __get_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
  1137. err |= __get_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
  1138. if (err) {
  1139. err = -EFAULT;
  1140. goto out;
  1141. }
  1142. break;
  1143. }
  1144. case FDGETDRVSTAT32:
  1145. case FDPOLLDRVSTAT32:
  1146. karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
  1147. if (!karg)
  1148. return -ENOMEM;
  1149. break;
  1150. case FDGETFDCSTAT32:
  1151. karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
  1152. if (!karg)
  1153. return -ENOMEM;
  1154. break;
  1155. case FDWERRORGET32:
  1156. karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
  1157. if (!karg)
  1158. return -ENOMEM;
  1159. break;
  1160. default:
  1161. return -EINVAL;
  1162. }
  1163. set_fs (KERNEL_DS);
  1164. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  1165. set_fs (old_fs);
  1166. if (err)
  1167. goto out;
  1168. switch (cmd) {
  1169. case FDGETPRM32:
  1170. {
  1171. struct floppy_struct *f = karg;
  1173. err = __put_user(f->size, &((struct floppy_struct32 *)arg)->size);
  1174. err |= __put_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
  1175. err |= __put_user(f->head, &((struct floppy_struct32 *)arg)->head);
  1176. err |= __put_user(f->track, &((struct floppy_struct32 *)arg)->track);
  1177. err |= __put_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
  1178. err |= __put_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
  1179. err |= __put_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
  1180. err |= __put_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
  1181. err |= __put_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
  1182. err |= __put_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
  1183. break;
  1184. }
  1185. case FDGETDRVPRM32:
  1186. {
  1187. struct floppy_drive_params *f = karg;
  1189. err = __put_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
  1190. err |= __put_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
  1191. err |= __put_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
  1192. err |= __put_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
  1193. err |= __put_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
  1194. err |= __put_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
  1195. err |= __put_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
  1196. err |= __put_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
  1197. err |= __put_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
  1198. err |= __put_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
  1199. err |= __put_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
  1200. err |= __put_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
  1201. err |= __put_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
  1202. err |= __copy_to_user(&((struct floppy_drive_params32 *)arg)->max_errors, &f->max_errors, sizeof(f->max_errors));
  1203. err |= __put_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
  1204. err |= __put_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
  1205. err |= __copy_to_user(((struct floppy_drive_params32 *)arg)->autodetect, f->autodetect, sizeof(f->autodetect));
  1206. err |= __put_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
  1207. err |= __put_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
  1208. break;
  1209. }
  1210. case FDGETDRVSTAT32:
  1211. case FDPOLLDRVSTAT32:
  1212. {
  1213. struct floppy_drive_struct *f = karg;
  1215. err = __put_user(f->flags, &((struct floppy_drive_struct32 *)arg)->flags);
  1216. err |= __put_user(f->spinup_date, &((struct floppy_drive_struct32 *)arg)->spinup_date);
  1217. err |= __put_user(f->select_date, &((struct floppy_drive_struct32 *)arg)->select_date);
  1218. err |= __put_user(f->first_read_date, &((struct floppy_drive_struct32 *)arg)->first_read_date);
  1219. err |= __put_user(f->probed_format, &((struct floppy_drive_struct32 *)arg)->probed_format);
  1220. err |= __put_user(f->track, &((struct floppy_drive_struct32 *)arg)->track);
  1221. err |= __put_user(f->maxblock, &((struct floppy_drive_struct32 *)arg)->maxblock);
  1222. err |= __put_user(f->maxtrack, &((struct floppy_drive_struct32 *)arg)->maxtrack);
  1223. err |= __put_user(f->generation, &((struct floppy_drive_struct32 *)arg)->generation);
  1224. err |= __put_user(f->keep_data, &((struct floppy_drive_struct32 *)arg)->keep_data);
  1225. err |= __put_user(f->fd_ref, &((struct floppy_drive_struct32 *)arg)->fd_ref);
  1226. err |= __put_user(f->fd_device, &((struct floppy_drive_struct32 *)arg)->fd_device);
  1227. err |= __put_user(f->last_checked, &((struct floppy_drive_struct32 *)arg)->last_checked);
  1228. err |= __put_user((u64)f->dmabuf, &((struct floppy_drive_struct32 *)arg)->dmabuf);
  1229. err |= __put_user((u64)f->bufblocks, &((struct floppy_drive_struct32 *)arg)->bufblocks);
  1230. break;
  1231. }
  1232. case FDGETFDCSTAT32:
  1233. {
  1234. struct floppy_fdc_state *f = karg;
  1236. err = __put_user(f->spec1, &((struct floppy_fdc_state32 *)arg)->spec1);
  1237. err |= __put_user(f->spec2, &((struct floppy_fdc_state32 *)arg)->spec2);
  1238. err |= __put_user(f->dtr, &((struct floppy_fdc_state32 *)arg)->dtr);
  1239. err |= __put_user(f->version, &((struct floppy_fdc_state32 *)arg)->version);
  1240. err |= __put_user(f->dor, &((struct floppy_fdc_state32 *)arg)->dor);
  1241. err |= __put_user(f->address, &((struct floppy_fdc_state32 *)arg)->address);
  1242. err |= __copy_to_user((char *)&((struct floppy_fdc_state32 *)arg)->address
  1243.         + sizeof(((struct floppy_fdc_state32 *)arg)->address),
  1244.    (char *)&f->address + sizeof(f->address), sizeof(int));
  1245. err |= __put_user(f->driver_version, &((struct floppy_fdc_state32 *)arg)->driver_version);
  1246. err |= __copy_to_user(((struct floppy_fdc_state32 *)arg)->track, f->track, sizeof(f->track));
  1247. break;
  1248. }
  1249. case FDWERRORGET32:
  1250. {
  1251. struct floppy_write_errors *f = karg;
  1253. err = __put_user(f->write_errors, &((struct floppy_write_errors32 *)arg)->write_errors);
  1254. err |= __put_user(f->first_error_sector, &((struct floppy_write_errors32 *)arg)->first_error_sector);
  1255. err |= __put_user(f->first_error_generation, &((struct floppy_write_errors32 *)arg)->first_error_generation);
  1256. err |= __put_user(f->last_error_sector, &((struct floppy_write_errors32 *)arg)->last_error_sector);
  1257. err |= __put_user(f->last_error_generation, &((struct floppy_write_errors32 *)arg)->last_error_generation);
  1258. err |= __put_user(f->badness, &((struct floppy_write_errors32 *)arg)->badness);
  1259. break;
  1260. }
  1261. default:
  1262. break;
  1263. }
  1264. if (err)
  1265. err = -EFAULT;
  1267. out: if (karg) kfree(karg);
  1268. return err;
  1269. }
  1271. struct ppp_option_data32 {
  1272. __kernel_caddr_t32 ptr;
  1273. __u32 length;
  1274. int transmit;
  1275. };
  1276. #define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
  1278. struct ppp_idle32 {
  1279. __kernel_time_t32 xmit_idle;
  1280. __kernel_time_t32 recv_idle;
  1281. };
  1282. #define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
  1284. static int ppp_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1285. {
  1286. mm_segment_t old_fs = get_fs();
  1287. struct ppp_option_data32 data32;
  1288. struct ppp_option_data data;
  1289. struct ppp_idle32 idle32;
  1290. struct ppp_idle idle;
  1291. unsigned int kcmd;
  1292. void *karg;
  1293. int err = 0;
  1295. switch (cmd) {
  1296. case PPPIOCGIDLE32:
  1297. kcmd = PPPIOCGIDLE;
  1298. karg = &idle;
  1299. break;
  1300. case PPPIOCSCOMPRESS32:
  1301. if (copy_from_user(&data32, (struct ppp_option_data32 *)arg, sizeof(struct ppp_option_data32)))
  1302. return -EFAULT;
  1303. data.ptr = kmalloc (data32.length, GFP_KERNEL);
  1304. if (!data.ptr)
  1305. return -ENOMEM;
  1306. if (copy_from_user(data.ptr, (__u8 *)A(data32.ptr), data32.length)) {
  1307. kfree(data.ptr);
  1308. return -EFAULT;
  1309. }
  1310. data.length = data32.length;
  1311. data.transmit = data32.transmit;
  1312. kcmd = PPPIOCSCOMPRESS;
  1313. karg = &data;
  1314. break;
  1315. default:
  1316. do {
  1317. static int count = 0;
  1318. if (++count <= 20)
  1319. printk("ppp_ioctl: Unknown cmd fd(%d) "
  1320.        "cmd(%08x) arg(%08x)n",
  1321.        (int)fd, (unsigned int)cmd, (unsigned int)arg);
  1322. } while(0);
  1323. return -EINVAL;
  1324. }
  1325. set_fs (KERNEL_DS);
  1326. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  1327. set_fs (old_fs);
  1328. switch (cmd) {
  1329. case PPPIOCGIDLE32:
  1330. if (err)
  1331. return err;
  1332. idle32.xmit_idle = idle.xmit_idle;
  1333. idle32.recv_idle = idle.recv_idle;
  1334. if (copy_to_user((struct ppp_idle32 *)arg, &idle32, sizeof(struct ppp_idle32)))
  1335. return -EFAULT;
  1336. break;
  1337. case PPPIOCSCOMPRESS32:
  1338. kfree(data.ptr);
  1339. break;
  1340. default:
  1341. break;
  1342. }
  1343. return err;
  1344. }
  1347. struct mtget32 {
  1348. __u32 mt_type;
  1349. __u32 mt_resid;
  1350. __u32 mt_dsreg;
  1351. __u32 mt_gstat;
  1352. __u32 mt_erreg;
  1353. __kernel_daddr_t32 mt_fileno;
  1354. __kernel_daddr_t32 mt_blkno;
  1355. };
  1356. #define MTIOCGET32 _IOR('m', 2, struct mtget32)
  1358. struct mtpos32 {
  1359. __u32 mt_blkno;
  1360. };
  1361. #define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
  1363. struct mtconfiginfo32 {
  1364. __u32 mt_type;
  1365. __u32 ifc_type;
  1366. __u16 irqnr;
  1367. __u16 dmanr;
  1368. __u16 port;
  1369. __u32 debug;
  1370. __u32 have_dens:1;
  1371. __u32 have_bsf:1;
  1372. __u32 have_fsr:1;
  1373. __u32 have_bsr:1;
  1374. __u32 have_eod:1;
  1375. __u32 have_seek:1;
  1376. __u32 have_tell:1;
  1377. __u32 have_ras1:1;
  1378. __u32 have_ras2:1;
  1379. __u32 have_ras3:1;
  1380. __u32 have_qfa:1;
  1381. __u32 pad1:5;
  1382. char reserved[10];
  1383. };
  1384. #define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
  1385. #define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
  1387. static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1388. {
  1389. mm_segment_t old_fs = get_fs();
  1390. struct mtconfiginfo info;
  1391. struct mtget get;
  1392. struct mtpos pos;
  1393. unsigned long kcmd;
  1394. void *karg;
  1395. int err = 0;
  1397. switch(cmd) {
  1398. case MTIOCPOS32:
  1399. kcmd = MTIOCPOS;
  1400. karg = &pos;
  1401. break;
  1402. case MTIOCGET32:
  1403. kcmd = MTIOCGET;
  1404. karg = &get;
  1405. break;
  1406. case MTIOCGETCONFIG32:
  1407. kcmd = MTIOCGETCONFIG;
  1408. karg = &info;
  1409. break;
  1410. case MTIOCSETCONFIG32:
  1411. kcmd = MTIOCSETCONFIG;
  1412. karg = &info;
  1413. err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
  1414. err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
  1415. err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
  1416. err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
  1417. err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
  1418. err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
  1419. err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
  1420.      (char *)&((struct mtconfiginfo32 *)arg)->debug
  1421.      + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
  1422. if (err)
  1423. return -EFAULT;
  1424. break;
  1425. default:
  1426. do {
  1427. static int count = 0;
  1428. if (++count <= 20)
  1429. printk("mt_ioctl: Unknown cmd fd(%d) "
  1430.        "cmd(%08x) arg(%08x)n",
  1431.        (int)fd, (unsigned int)cmd, (unsigned int)arg);
  1432. } while(0);
  1433. return -EINVAL;
  1434. }
  1435. set_fs (KERNEL_DS);
  1436. err = sys_ioctl (fd, kcmd, (unsigned long)karg);
  1437. set_fs (old_fs);
  1438. if (err)
  1439. return err;
  1440. switch (cmd) {
  1441. case MTIOCPOS32:
  1442. err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
  1443. break;
  1444. case MTIOCGET32:
  1445. err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
  1446. err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
  1447. err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
  1448. err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
  1449. err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
  1450. err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
  1451. err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
  1452. break;
  1453. case MTIOCGETCONFIG32:
  1454. err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
  1455. err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
  1456. err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
  1457. err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
  1458. err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
  1459. err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
  1460. err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
  1461.         + sizeof(((struct mtconfiginfo32 *)arg)->debug),
  1462.    (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
  1463. break;
  1464. case MTIOCSETCONFIG32:
  1465. break;
  1466. }
  1467. return err ? -EFAULT: 0;
  1468. }
  1470. struct cdrom_read32 {
  1471. int cdread_lba;
  1472. __kernel_caddr_t32 cdread_bufaddr;
  1473. int cdread_buflen;
  1474. };
  1476. struct cdrom_read_audio32 {
  1477. union cdrom_addr addr;
  1478. u_char addr_format;
  1479. int nframes;
  1480. __kernel_caddr_t32 buf;
  1481. };
  1483. struct cdrom_generic_command32 {
  1484. unsigned char cmd[CDROM_PACKET_SIZE];
  1485. __kernel_caddr_t32 buffer;
  1486. unsigned int buflen;
  1487. int stat;
  1488. __kernel_caddr_t32 sense;
  1489. __kernel_caddr_t32 reserved[3];
  1490. };
  1492. static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
  1493. {
  1494. mm_segment_t old_fs = get_fs();
  1495. struct cdrom_read cdread;
  1496. struct cdrom_read_audio cdreadaudio;
  1497. struct cdrom_generic_command cgc;
  1498. __kernel_caddr_t32 addr;
  1499. char *data = 0;
  1500. void *karg;
  1501. int err = 0;
  1503. switch(cmd) {
  1504. case CDROMREADMODE2:
  1505. case CDROMREADMODE1:
  1506. case CDROMREADRAW:
  1507. case CDROMREADCOOKED:
  1508. karg = &cdread;
  1509. err = __get_user(cdread.cdread_lba, &((struct cdrom_read32 *)arg)->cdread_lba);
  1510. err |= __get_user(addr, &((struct cdrom_read32 *)arg)->cdread_bufaddr);
  1511. err |= __get_user(cdread.cdread_buflen, &((struct cdrom_read32 *)arg)->cdread_buflen);
  1512. if (err)
  1513. return -EFAULT;
  1514. data = kmalloc(cdread.cdread_buflen, GFP_KERNEL);
  1515. if (!data)
  1516. return -ENOMEM;
  1517. cdread.cdread_bufaddr = data;
  1518. break;
  1519. case CDROMREADAUDIO:
  1520. karg = &cdreadaudio;
  1521. err = copy_from_user(&cdreadaudio.addr, &((struct cdrom_read_audio32 *)arg)->addr, sizeof(cdreadaudio.addr));
  1522. err |= __get_user(cdreadaudio.addr_format, &((struct cdrom_read_audio32 *)arg)->addr_format);
  1523. err |= __get_user(cdreadaudio.nframes, &((struct cdrom_read_audio32 *)arg)->nframes); 
  1524. err |= __get_user(addr, &((struct cdrom_read_audio32 *)arg)->buf);
  1525. if (err)
  1526. return -EFAULT;
  1527. data = kmalloc(cdreadaudio.nframes * 2352, GFP_KERNEL);
  1528. if (!data)
  1529. return -ENOMEM;
  1530. cdreadaudio.buf = data;
  1531. break;
  1532. case CDROM_SEND_PACKET:
  1533. karg = &cgc;
  1534. err = copy_from_user(cgc.cmd, &((struct cdrom_generic_command32 *)arg)->cmd, sizeof(cgc.cmd));
  1535. err |= __get_user(addr, &((struct cdrom_generic_command32 *)arg)->buffer);
  1536. err |= __get_user(cgc.buflen, &((struct cdrom_generic_command32 *)arg)->buflen);
  1537. if (err)
  1538. return -EFAULT;
  1539. if ((data = kmalloc(cgc.buflen, GFP_KERNEL)) == NULL)
  1540. return -ENOMEM;
  1541. cgc.buffer = data;
  1542. break;
  1543. default:
  1544. do {
  1545. static int count = 0;
  1546. if (++count <= 20)
  1547. printk("cdrom_ioctl: Unknown cmd fd(%d) "
  1548.        "cmd(%08x) arg(%08x)n",
  1549.        (int)fd, (unsigned int)cmd, (unsigned int)arg);
  1550. } while(0);
  1551. return -EINVAL;
  1552. }
  1553. set_fs (KERNEL_DS);
  1554. err = sys_ioctl (fd, cmd, (unsigned long)karg);
  1555. set_fs (old_fs);
  1556. if (err)
  1557. goto out;
  1558. switch (cmd) {
  1559. case CDROMREADMODE2:
  1560. case CDROMREADMODE1:
  1561. case CDROMREADRAW:
  1562. case CDROMREADCOOKED:
  1563. err = copy_to_user((char *)A(addr), data, cdread.cdread_buflen);
  1564. break;
  1565. case CDROMREADAUDIO:
  1566. err = copy_to_user((char *)A(addr), data, cdreadaudio.nframes * 2352);
  1567. break;
  1568. case CDROM_SEND_PACKET:
  1569. err = copy_to_user((char *)A(addr), data, cgc.buflen);
  1570. break;
  1571. default:
  1572. break;
  1573. }
  1574. out: if (data)
  1575. kfree(data);
  1576. return err ? -EFAULT : 0;
  1577. }
  1579. struct loop_info32 {
  1580. int lo_number;      /* ioctl r/o */
  1581. __kernel_dev_t32 lo_device;      /* ioctl r/o */
  1582. unsigned int lo_inode;       /* ioctl r/o */
  1583. __kernel_dev_t32 lo_rdevice;     /* ioctl r/o */
  1584. int lo_offset;
  1585. int lo_encrypt_type;
  1586. int lo_encrypt_key_size;    /* ioctl w/o */
  1587. int lo_flags;       /* ioctl r/o */
  1588. char lo_name[LO_NAME_SIZE];
  1589. unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
  1590. unsigned int lo_init[2];
  1591. char reserved[4];
  1592. };
  1594. static int loop_status(unsigned int fd, unsigned int cmd, unsigned long arg)
  1595. {
  1596. mm_segment_t old_fs = get_fs();
  1597. struct loop_info l;
  1598. int err = -EINVAL;
  1600. switch(cmd) {
  1601. case LOOP_SET_STATUS:
  1602. err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
  1603. err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
  1604. err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
  1605. err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
  1606. err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,
  1607.    8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
  1608. if (err) {
  1609. err = -EFAULT;
  1610. } else {
  1611. set_fs (KERNEL_DS);
  1612. err = sys_ioctl (fd, cmd, (unsigned long)&l);
  1613. set_fs (old_fs);
  1614. }
  1615. break;
  1616. case LOOP_GET_STATUS:
  1617. set_fs (KERNEL_DS);
  1618. err = sys_ioctl (fd, cmd, (unsigned long)&l);
  1619. set_fs (old_fs);
  1620. if (!err) {
  1621. err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
  1622. err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
  1623. err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
  1624. err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
  1625. err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,
  1626.    (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
  1627. if (err)
  1628. err = -EFAULT;
  1629. }
  1630. break;
  1631. default: {
  1632. static int count = 0;
  1633. if (++count <= 20)
  1634. printk("%s: Unknown loop ioctl cmd, fd(%d) "
  1635.        "cmd(%08x) arg(%08lx)n",
  1636.        __FUNCTION__, fd, cmd, arg);
  1637. }
  1638. }
  1639. return err;
  1640. }
  1642. extern int tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg);
  1644. static int vt_check(struct file *file)
  1645. {
  1646. struct tty_struct *tty;
  1647. struct inode *inode = file->f_dentry->d_inode;
  1649. if (file->f_op->ioctl != tty_ioctl)
  1650. return -EINVAL;
  1651.                 
  1652. tty = (struct tty_struct *)file->private_data;
  1653. if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  1654. return -EINVAL;
  1655.                                                 
  1656. if (tty->driver.ioctl != vt_ioctl)
  1657. return -EINVAL;
  1659. /*
  1660.  * To have permissions to do most of the vt ioctls, we either have
  1661.  * to be the owner of the tty, or super-user.
  1662.  */
  1663. if (current->tty == tty || suser())
  1664. return 1;
  1665. return 0;                                                    
  1666. }
  1668. struct consolefontdesc32 {
  1669. unsigned short charcount;       /* characters in font (256 or 512) */
  1670. unsigned short charheight;      /* scan lines per character (1-32) */
  1671. u32 chardata; /* font data in expanded form */
  1672. };
  1674. static int do_fontx_ioctl(unsigned int fd, int cmd, struct consolefontdesc32 *user_cfd, struct file *file)
  1675. {
  1676. struct consolefontdesc cfdarg;
  1677. struct console_font_op op;
  1678. int i, perm;
  1680. perm = vt_check(file);
  1681. if (perm < 0) return perm;
  1683. if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc32)))
  1684. return -EFAULT;
  1686. cfdarg.chardata = (unsigned char *)A(((struct consolefontdesc32 *)&cfdarg)->chardata);
  1687.  
  1688. switch (cmd) {
  1689. case PIO_FONTX:
  1690. if (!perm)
  1691. return -EPERM;
  1692. op.op = KD_FONT_OP_SET;
  1693. op.flags = 0;
  1694. op.width = 8;
  1695. op.height = cfdarg.charheight;
  1696. op.charcount = cfdarg.charcount;
  1697. op.data = cfdarg.chardata;
  1698. return con_font_op(fg_console, &op);
  1699. case GIO_FONTX:
  1700. if (!cfdarg.chardata)
  1701. return 0;
  1702. op.op = KD_FONT_OP_GET;
  1703. op.flags = 0;
  1704. op.width = 8;
  1705. op.height = cfdarg.charheight;
  1706. op.charcount = cfdarg.charcount;
  1707. op.data = cfdarg.chardata;
  1708. i = con_font_op(fg_console, &op);
  1709. if (i)
  1710. return i;
  1711. cfdarg.charheight = op.height;
  1712. cfdarg.charcount = op.charcount;
  1713. ((struct consolefontdesc32 *)&cfdarg)->chardata = (unsigned long)cfdarg.chardata;
  1714. if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc32)))
  1715. return -EFAULT;
  1716. return 0;
  1717. }
  1718. return -EINVAL;
  1719. }
  1721. struct console_font_op32 {
  1722. unsigned int op;        /* operation code KD_FONT_OP_* */
  1723. unsigned int flags;     /* KD_FONT_FLAG_* */
  1724. unsigned int width, height;     /* font size */
  1725. unsigned int charcount;
  1726. u32 data;    /* font data with height fixed to 32 */
  1727. };
  1728.                                         
  1729. static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, struct console_font_op32 *fontop, struct file *file)
  1730. {
  1731. struct console_font_op op;
  1732. int perm = vt_check(file), i;
  1733. struct vt_struct *vt;
  1735. if (perm < 0) return perm;
  1737. if (copy_from_user(&op, (void *) fontop, sizeof(struct console_font_op32)))
  1738. return -EFAULT;
  1739. if (!perm && op.op != KD_FONT_OP_GET)
  1740. return -EPERM;
  1741. op.data = (unsigned char *)A(((struct console_font_op32 *)&op)->data);
  1742. op.flags |= KD_FONT_FLAG_OLD;
  1743. vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data;
  1744. i = con_font_op(vt->vc_num, &op);
  1745. if (i) return i;
  1746. ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
  1747. if (copy_to_user((void *) fontop, &op, sizeof(struct console_font_op32)))
  1748. return -EFAULT;
  1749. return 0;
  1750. }
  1752. struct unimapdesc32 {
  1753. unsigned short entry_ct;
  1754. u32 entries;
  1755. };
  1757. static int do_unimap_ioctl(unsigned int fd, unsigned int cmd, struct unimapdesc32 *user_ud, struct file *file)
  1758. {
  1759. struct unimapdesc32 tmp;
  1760. int perm = vt_check(file);
  1762. if (perm < 0) return perm;
  1763. if (copy_from_user(&tmp, user_ud, sizeof tmp))
  1764. return -EFAULT;
  1765. switch (cmd) {
  1766. case PIO_UNIMAP:
  1767. if (!perm) return -EPERM;
  1768. return con_set_unimap(fg_console, tmp.entry_ct, (struct unipair *)A(tmp.entries));
  1769. case GIO_UNIMAP:
  1770. return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), (struct unipair *)A(tmp.entries));
  1771. }
  1772. return 0;
  1773. }
  1775. static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long arg)
  1776. {
  1777. mm_segment_t old_fs = get_fs();
  1778. __kernel_uid_t kuid;
  1779. int err;
  1781. cmd = SMB_IOC_GETMOUNTUID;
  1783. set_fs(KERNEL_DS);
  1784. err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
  1785. set_fs(old_fs);
  1787. if (err >= 0)
  1788. err = put_user(kuid, (__kernel_uid_t32 *)arg);
  1790. return err;
  1791. }
  1793. struct atmif_sioc32 {
  1794.         int                number;
  1795.         int                length;
  1796.         __kernel_caddr_t32 arg;
  1797. };
  1799. struct atm_iobuf32 {
  1800. int                length;
  1801. __kernel_caddr_t32 buffer;
  1802. };
  1804. #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
  1805. #define ATM_GETNAMES32    _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
  1806. #define ATM_GETTYPE32     _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
  1807. #define ATM_GETESI32   _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
  1808. #define ATM_GETADDR32   _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
  1809. #define ATM_RSTADDR32   _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
  1810. #define ATM_ADDADDR32   _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
  1811. #define ATM_DELADDR32   _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
  1812. #define ATM_GETCIRANGE32  _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
  1813. #define ATM_SETCIRANGE32  _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
  1814. #define ATM_SETESI32      _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
  1815. #define ATM_SETESIF32     _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
  1816. #define ATM_GETSTAT32     _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
  1817. #define ATM_GETSTATZ32    _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
  1818. #define ATM_GETLOOP32   _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
  1819. #define ATM_SETLOOP32   _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
  1820. #define ATM_QUERYLOOP32   _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
  1822. static struct {
  1823.         unsigned int cmd32;
  1824.         unsigned int cmd;
  1825. } atm_ioctl_map[] = {
  1826.         { ATM_GETLINKRATE32, ATM_GETLINKRATE },
  1827. { ATM_GETNAMES32,    ATM_GETNAMES },
  1828.         { ATM_GETTYPE32,     ATM_GETTYPE },
  1829.         { ATM_GETESI32,      ATM_GETESI },
  1830.         { ATM_GETADDR32,     ATM_GETADDR },
  1831.         { ATM_RSTADDR32,     ATM_RSTADDR },
  1832.         { ATM_ADDADDR32,     ATM_ADDADDR },
  1833.         { ATM_DELADDR32,     ATM_DELADDR },
  1834.         { ATM_GETCIRANGE32,  ATM_GETCIRANGE },
  1835. { ATM_SETCIRANGE32,  ATM_SETCIRANGE },
  1836. { ATM_SETESI32,      ATM_SETESI },
  1837. { ATM_SETESIF32,     ATM_SETESIF },
  1838. { ATM_GETSTAT32,     ATM_GETSTAT },
  1839. { ATM_GETSTATZ32,    ATM_GETSTATZ },
  1840. { ATM_GETLOOP32,     ATM_GETLOOP },
  1841. { ATM_SETLOOP32,     ATM_SETLOOP },
  1842. { ATM_QUERYLOOP32,   ATM_QUERYLOOP }
  1843. };
  1845. #define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
  1848. static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
  1849. {
  1850. struct atm_iobuf32 iobuf32;
  1851. struct atm_iobuf   iobuf = { 0, NULL };
  1852. mm_segment_t old_fs;
  1853. int err;
  1855. err = copy_from_user(&iobuf32, (struct atm_iobuf32*)arg,
  1856.     sizeof(struct atm_iobuf32));
  1857. if (err)
  1858. return -EFAULT;
  1860. iobuf.length = iobuf32.length;
  1862. if (iobuf32.buffer == (__kernel_caddr_t32) NULL || iobuf32.length == 0) {
  1863. iobuf.buffer = (void*)(unsigned long)iobuf32.buffer;
  1864. } else {
  1865. iobuf.buffer = kmalloc(iobuf.length, GFP_KERNEL);
  1866. if (iobuf.buffer == NULL) {
  1867. err = -ENOMEM;
  1868. goto out;
  1869. }
  1871. err = copy_from_user(iobuf.buffer, A(iobuf32.buffer), iobuf.length);
  1872. if (err) {
  1873. err = -EFAULT;
  1874. goto out;
  1875. }
  1876. }
  1878. old_fs = get_fs(); set_fs (KERNEL_DS);
  1879. err = sys_ioctl (fd, cmd, (unsigned long)&iobuf);      
  1880. set_fs (old_fs);
  1881.         if(err)
  1882. goto out;
  1884.         if(iobuf.buffer && iobuf.length > 0) {
  1885. err = copy_to_user(A(iobuf32.buffer), iobuf.buffer, iobuf.length);
  1886. if (err) {
  1887. err = -EFAULT;
  1888. goto out;
  1889. }
  1890. }
  1891. err = __put_user(iobuf.length, &(((struct atm_iobuf32*)arg)->length));
  1893.  out:
  1894.         if(iobuf32.buffer && iobuf32.length > 0)
  1895. kfree(iobuf.buffer);
  1897. return err;
  1898. }
  1901. static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg)
  1902. {
  1903.         struct atmif_sioc32 sioc32;
  1904.         struct atmif_sioc   sioc = { 0, 0, NULL };
  1905.         mm_segment_t old_fs;
  1906.         int err;
  1907.         
  1908.         err = copy_from_user(&sioc32, (struct atmif_sioc32*)arg,
  1909.      sizeof(struct atmif_sioc32));
  1910.         if (err)
  1911.                 return -EFAULT;
  1913.         sioc.number = sioc32.number;
  1914.         sioc.length = sioc32.length;
  1915.         
  1916. if (sioc32.arg == (__kernel_caddr_t32) NULL || sioc32.length == 0) {
  1917. sioc.arg = (void*)(unsigned long)sioc32.arg;
  1918.         } else {
  1919.                 sioc.arg = kmalloc(sioc.length, GFP_KERNEL);
  1920.                 if (sioc.arg == NULL) {
  1921.                         err = -ENOMEM;
  1922. goto out;
  1923. }
  1924.                 
  1925.                 err = copy_from_user(sioc.arg, A(sioc32.arg), sioc32.length);
  1926.                 if (err) {
  1927.                         err = -EFAULT;
  1928.                         goto out;
  1929.                 }
  1930.         }
  1931.         
  1932.         old_fs = get_fs(); set_fs (KERNEL_DS);
  1933.         err = sys_ioctl (fd, cmd, (unsigned long)&sioc);
  1934.         set_fs (old_fs);
  1935.         if(err) {
  1936.                 goto out;
  1937. }
  1938.         
  1939.         if(sioc.arg && sioc.length > 0) {
  1940.                 err = copy_to_user(A(sioc32.arg), sioc.arg, sioc.length);
  1941.                 if (err) {
  1942.                         err = -EFAULT;
  1943.                         goto out;
  1944.                 }
  1945.         }
  1946.         err = __put_user(sioc.length, &(((struct atmif_sioc32*)arg)->length));
  1947.         
  1948.  out:
  1949.         if(sioc32.arg && sioc32.length > 0)
  1950. kfree(sioc.arg);
  1951.         
  1952. return err;
  1953. }
  1956. static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg)
  1957. {
  1958.         int i;
  1959.         unsigned int cmd = 0;
  1960.         
  1961. switch (cmd32) {
  1962. case SONET_GETSTAT:
  1963. case SONET_GETSTATZ:
  1964. case SONET_GETDIAG:
  1965. case SONET_SETDIAG:
  1966. case SONET_CLRDIAG:
  1967. case SONET_SETFRAMING:
  1968. case SONET_GETFRAMING:
  1969. case SONET_GETFRSENSE:
  1970. return do_atmif_sioc(fd, cmd32, arg);
  1971. }
  1973. for (i = 0; i < NR_ATM_IOCTL; i++) {
  1974. if (cmd32 == atm_ioctl_map[i].cmd32) {
  1975. cmd = atm_ioctl_map[i].cmd;
  1976. break;
  1977. }
  1978. }
  1979.         if (i == NR_ATM_IOCTL) {
  1980.         return -EINVAL;
  1981.         }
  1982.         
  1983.         switch (cmd) {
  1984. case ATM_GETNAMES:
  1985. return do_atm_iobuf(fd, cmd, arg);
  1986.     
  1987. case ATM_GETLINKRATE:
  1988.         case ATM_GETTYPE:
  1989.         case ATM_GETESI:
  1990.         case ATM_GETADDR:
  1991.         case ATM_RSTADDR:
  1992.         case ATM_ADDADDR:
  1993.         case ATM_DELADDR:
  1994.         case ATM_GETCIRANGE:
  1995. case ATM_SETCIRANGE:
  1996. case ATM_SETESI:
  1997. case ATM_SETESIF:
  1998. case ATM_GETSTAT:
  1999. case ATM_GETSTATZ:
  2000. case ATM_GETLOOP:
  2001. case ATM_SETLOOP:
  2002. case ATM_QUERYLOOP:
  2003.                 return do_atmif_sioc(fd, cmd, arg);
  2004.         }
  2006.         return -EINVAL;
  2007. }
  2009. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  2010. /* Ugh, LVM. Pitty it was not cleaned up before accepted :((. */
  2011. typedef struct {
  2012. uint8_t vg_name[NAME_LEN];
  2013. uint32_t vg_number;
  2014. uint32_t vg_access;
  2015. uint32_t vg_status;
  2016. uint32_t lv_max;
  2017. uint32_t lv_cur;
  2018. uint32_t lv_open;
  2019. uint32_t pv_max;
  2020. uint32_t pv_cur;
  2021. uint32_t pv_act;
  2022. uint32_t dummy;
  2023. uint32_t vgda;
  2024. uint32_t pe_size;
  2025. uint32_t pe_total;
  2026. uint32_t pe_allocated;
  2027. uint32_t pvg_total;
  2028. u32 proc;
  2029. u32 pv[ABS_MAX_PV + 1];
  2030. u32 lv[ABS_MAX_LV + 1];
  2031.      uint8_t vg_uuid[UUID_LEN+1]; /* volume group UUID */
  2032. uint8_t dummy1[200];
  2033. } vg32_t;
  2035. typedef struct {
  2036. uint8_t id[2];
  2037. uint16_t version;
  2038. lvm_disk_data_t pv_on_disk;
  2039. lvm_disk_data_t vg_on_disk;
  2040. lvm_disk_data_t pv_namelist_on_disk;
  2041. lvm_disk_data_t lv_on_disk;
  2042. lvm_disk_data_t pe_on_disk;
  2043. uint8_t pv_name[NAME_LEN];
  2044. uint8_t vg_name[NAME_LEN];
  2045. uint8_t system_id[NAME_LEN];
  2046. kdev_t pv_dev;
  2047. uint32_t pv_number;
  2048. uint32_t pv_status;
  2049. uint32_t pv_allocatable;
  2050. uint32_t pv_size;
  2051. uint32_t lv_cur;
  2052. uint32_t pe_size;
  2053. uint32_t pe_total;
  2054. uint32_t pe_allocated;
  2055. uint32_t pe_stale;
  2056. u32 pe;
  2057. u32 inode;
  2058. uint8_t pv_uuid[UUID_LEN+1];
  2059. } pv32_t;
  2061. typedef struct {
  2062. char lv_name[NAME_LEN];
  2063. u32 lv;
  2064. } lv_req32_t;
  2066. typedef struct {
  2067. u32 lv_index;
  2068. u32 lv;
  2069. /* Transfer size because user space and kernel space differ */
  2070. uint16_t size;
  2071. } lv_status_byindex_req32_t;
  2073. typedef struct {
  2074. __kernel_dev_t32 dev;
  2075. u32   lv;
  2076. } lv_status_bydev_req32_t;
  2078. typedef struct {
  2079. uint8_t lv_name[NAME_LEN];
  2080. kdev_t old_dev;
  2081. kdev_t new_dev;
  2082. u32 old_pe;
  2083. u32 new_pe;
  2084. } le_remap_req32_t;
  2086. typedef struct {
  2087. char pv_name[NAME_LEN];
  2088. u32 pv;
  2089. } pv_status_req32_t;
  2091. typedef struct {
  2092. uint8_t lv_name[NAME_LEN];
  2093. uint8_t vg_name[NAME_LEN];
  2094. uint32_t lv_access;
  2095. uint32_t lv_status;
  2096. uint32_t lv_open;
  2097. kdev_t lv_dev;
  2098. uint32_t lv_number;
  2099. uint32_t lv_mirror_copies;
  2100. uint32_t lv_recovery;
  2101. uint32_t lv_schedule;
  2102. uint32_t lv_size;
  2103. u32 lv_current_pe;
  2104. uint32_t lv_current_le;
  2105. uint32_t lv_allocated_le;
  2106. uint32_t lv_stripes;
  2107. uint32_t lv_stripesize;
  2108. uint32_t lv_badblock;
  2109. uint32_t lv_allocation;
  2110. uint32_t lv_io_timeout;
  2111. uint32_t lv_read_ahead;
  2112. /* delta to version 1 starts here */
  2113. u32 lv_snapshot_org;
  2114. u32 lv_snapshot_prev;
  2115. u32 lv_snapshot_next;
  2116. u32 lv_block_exception;
  2117. uint32_t lv_remap_ptr;
  2118. uint32_t lv_remap_end;
  2119. uint32_t lv_chunk_size;
  2120. uint32_t lv_snapshot_minor;
  2121. char dummy[200];
  2122. } lv32_t;
  2124. typedef struct {
  2125. u32 hash[2];
  2126. u32 rsector_org;
  2127. kdev_t rdev_org;
  2128. u32 rsector_new;
  2129. kdev_t rdev_new;
  2130. } lv_block_exception32_t;
  2132. static void put_lv_t(lv_t *l)
  2133. {
  2134. if (l->lv_current_pe) vfree(l->lv_current_pe);
  2135. if (l->lv_block_exception) vfree(l->lv_block_exception);
  2136. kfree(l);
  2137. }
  2139. static lv_t *get_lv_t(u32 p, int *errp)
  2140. {
  2141. int err, i;
  2142. u32 ptr1, ptr2;
  2143. size_t size;
  2144. lv_block_exception32_t *lbe32;
  2145. lv_block_exception_t *lbe;
  2146. lv32_t *ul = (lv32_t *)A(p);
  2147. lv_t *l = (lv_t *) kmalloc(sizeof(lv_t), GFP_KERNEL);
  2149. if (!l) {
  2150. *errp = -ENOMEM;
  2151. return NULL;
  2152. }
  2153. memset(l, 0, sizeof(lv_t));
  2154. err = copy_from_user(l, ul, (long)&((lv32_t *)0)->lv_current_pe);
  2155. err |= __copy_from_user(&l->lv_current_le, &ul->lv_current_le,
  2156. ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
  2157. err |= __copy_from_user(&l->lv_remap_ptr, &ul->lv_remap_ptr,
  2158. ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
  2159. err |= __get_user(ptr1, &ul->lv_current_pe);
  2160. err |= __get_user(ptr2, &ul->lv_block_exception);
  2161. if (err) {
  2162. kfree(l);
  2163. *errp = -EFAULT;
  2164. return NULL;
  2165. }
  2166. if (ptr1) {
  2167. size = l->lv_allocated_le * sizeof(pe_t);
  2168. l->lv_current_pe = vmalloc(size);
  2169. if (l->lv_current_pe)
  2170. err = copy_from_user(l->lv_current_pe, (void *)A(ptr1), size);
  2171. }
  2172. if (!err && ptr2) {
  2173. size = l->lv_remap_end * sizeof(lv_block_exception_t);
  2174. l->lv_block_exception = lbe = vmalloc(size);
  2175. if (l->lv_block_exception) {
  2176. lbe32 = (lv_block_exception32_t *)A(ptr2);
  2177. memset(lbe, 0, size);
  2178. for (i = 0; i < l->lv_remap_end; i++, lbe++, lbe32++) {
  2179. err |= get_user(lbe->rsector_org, &lbe32->rsector_org);
  2180. err |= __get_user(lbe->rdev_org, &lbe32->rdev_org);
  2181. err |= __get_user(lbe->rsector_new, &lbe32->rsector_new);
  2182. err |= __get_user(lbe->rdev_new, &lbe32->rdev_new);
  2183. }
  2184. }
  2185. }
  2186. if (err || (ptr1 && !l->lv_current_pe) || (ptr2 && !l->lv_block_exception)) {
  2187. if (!err)
  2188. *errp = -ENOMEM;
  2189. else
  2190. *errp = -EFAULT;
  2191. put_lv_t(l);
  2192. return NULL;
  2193. }
  2194. return l;
  2195. }
  2197. static int copy_lv_t(u32 ptr, lv_t *l)
  2198. {
  2199. int err;
  2200. lv32_t *ul = (lv32_t *)A(ptr);
  2201. u32 ptr1;
  2202. size_t size;
  2204. err = get_user(ptr1, &ul->lv_current_pe);
  2205. if (err)
  2206. return -EFAULT;
  2207. err = copy_to_user(ul, l, (long)&((lv32_t *)0)->lv_current_pe);
  2208. err |= __copy_to_user(&ul->lv_current_le, &l->lv_current_le,
  2209. ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
  2210. err |= __copy_to_user(&ul->lv_remap_ptr, &l->lv_remap_ptr,
  2211. ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
  2212. size = l->lv_allocated_le * sizeof(pe_t);
  2213. if (ptr1)
  2214. err |= __copy_to_user((void *)A(ptr1), l->lv_current_pe, size);
  2215. return err ? -EFAULT : 0;
  2216. }
  2218. static int do_lvm_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  2219. {
  2220. vg_t *v = NULL;
  2221. union {
  2222. lv_req_t lv_req;
  2223. le_remap_req_t le_remap;
  2224. lv_status_byindex_req_t lv_byindex;
  2225.         lv_status_bydev_req_t lv_bydev;
  2226. pv_status_req_t pv_status;
  2227. } u;
  2228. pv_t p;
  2229. int err;
  2230. u32 ptr = 0;
  2231. int i;
  2232. mm_segment_t old_fs;
  2233. void *karg = &u;
  2235. switch (cmd) {
  2236. case VG_STATUS:
  2237. v = kmalloc(sizeof(vg_t), GFP_KERNEL);
  2238. if (!v)
  2239. return -ENOMEM;
  2240. karg = v;
  2241. break;
  2243. case VG_CREATE_OLD:
  2244. case VG_CREATE:
  2245. v = kmalloc(sizeof(vg_t), GFP_KERNEL);
  2246. if (!v)
  2247. return -ENOMEM;
  2248. if (copy_from_user(v, (void *)arg, (long)&((vg32_t *)0)->proc)) {
  2249. kfree(v);
  2250. return -EFAULT;
  2251. }
  2252. /* 'proc' field is unused, just NULL it out. */
  2253. v->proc = NULL;
  2254. if (copy_from_user(v->vg_uuid, ((vg32_t *)arg)->vg_uuid, UUID_LEN+1)) {
  2255. kfree(v);
  2256. return -EFAULT;
  2257. }
  2258.     
  2259. karg = v;
  2260. memset(v->pv, 0, sizeof(v->pv) + sizeof(v->lv));
  2261. if (v->pv_max > ABS_MAX_PV || v->lv_max > ABS_MAX_LV)
  2262. return -EPERM;
  2263. for (i = 0; i < v->pv_max; i++) {
  2264. err = __get_user(ptr, &((vg32_t *)arg)->pv[i]);
  2265. if (err)
  2266. break;
  2267. if (ptr) {
  2268. v->pv[i] = kmalloc(sizeof(pv_t), GFP_KERNEL);
  2269. if (!v->pv[i]) {
  2270. err = -ENOMEM;
  2271. break;
  2272. }
  2273. err = copy_from_user(v->pv[i], (void *)A(ptr),
  2274.      sizeof(pv32_t) - 8 - UUID_LEN+1);
  2275. if (err) {
  2276. err = -EFAULT;
  2277. break;
  2278. }
  2279. err = copy_from_user(v->pv[i]->pv_uuid,
  2280.      ((pv32_t *)A(ptr))->pv_uuid,
  2281.      UUID_LEN+1);
  2282. if (err) {
  2283.         err = -EFAULT;
  2284. break;
  2285. }
  2287. v->pv[i]->pe = NULL;
  2288. v->pv[i]->bd = NULL;
  2289. }
  2290. }
  2291. if (!err) {
  2292. for (i = 0; i < v->lv_max; i++) {
  2293. err = __get_user(ptr, &((vg32_t *)arg)->lv[i]);
  2294. if (err)
  2295. break;
  2296. if (ptr) {
  2297. v->lv[i] = get_lv_t(ptr, &err);
  2298. if (err)
  2299. break;
  2300. }
  2301. }
  2302. }
  2303. break;
  2305. case LV_CREATE:
  2306. case LV_EXTEND:
  2307. case LV_REDUCE:
  2308. case LV_REMOVE:
  2309. case LV_RENAME:
  2310. case LV_STATUS_BYNAME:
  2311.         err = copy_from_user(&u.pv_status, (void*)arg, sizeof(u.pv_status.pv_name));
  2312. if (err)
  2313. return -EFAULT;
  2314. if (cmd != LV_REMOVE) {
  2315. err = __get_user(ptr, &((lv_req32_t *)arg)->lv);
  2316. if (err)
  2317. return err;
  2318. u.lv_req.lv = get_lv_t(ptr, &err);
  2319. } else
  2320. u.lv_req.lv = NULL;
  2321. break;
  2323. case LV_STATUS_BYINDEX:
  2324. err = get_user(u.lv_byindex.lv_index,
  2325.        &((lv_status_byindex_req32_t *)arg)->lv_index);
  2326. err |= __get_user(ptr, &((lv_status_byindex_req32_t *)arg)->lv);
  2327. if (err)
  2328. return err;
  2329. u.lv_byindex.lv = get_lv_t(ptr, &err);
  2330. break;
  2332. case LV_STATUS_BYDEV:
  2333.         err = get_user(u.lv_bydev.dev, &((lv_status_bydev_req32_t *)arg)->dev);
  2334. err |= __get_user(ptr, &((lv_status_bydev_req32_t *)arg)->lv);
  2335. if (err)
  2336. return err;
  2337. u.lv_bydev.lv = get_lv_t(ptr, &err);
  2338. break;
  2340. case VG_EXTEND:
  2341. err = copy_from_user(&p, (void *)arg, sizeof(pv32_t) - 8 - UUID_LEN+1);
  2342. if (err)
  2343. return -EFAULT;
  2344. err = copy_from_user(p.pv_uuid, ((pv32_t *)arg)->pv_uuid, UUID_LEN+1);
  2345. if (err)
  2346. return -EFAULT;
  2347. p.pe = NULL;
  2348. p.bd = NULL;
  2349. karg = &p;
  2350. break;
  2352. case PV_CHANGE:
  2353. case PV_STATUS:
  2354. err = copy_from_user(&u.pv_status, (void*)arg, sizeof(u.lv_req.lv_name));
  2355. if (err)
  2356. return -EFAULT;
  2357. err = __get_user(ptr, &((pv_status_req32_t *)arg)->pv);
  2358. if (err)
  2359. return err;
  2360. u.pv_status.pv = &p;
  2361. if (cmd == PV_CHANGE) {
  2362. err = copy_from_user(&p, (void *)A(ptr),
  2363.      sizeof(pv32_t) - 8 - UUID_LEN+1);
  2364. if (err)
  2365. return -EFAULT;
  2366. p.pe = NULL;
  2367. p.bd = NULL;
  2368. }
  2369. break;
  2370. };
  2372.         old_fs = get_fs(); set_fs (KERNEL_DS);
  2373.         err = sys_ioctl (fd, cmd, (unsigned long)karg);
  2374.         set_fs (old_fs);
  2376. switch (cmd) {
  2377. case VG_STATUS:
  2378. if (!err) {
  2379. if (copy_to_user((void *)arg, v, (long)&((vg32_t *)0)->proc) ||
  2380.     clear_user(&((vg32_t *)arg)->proc, sizeof(vg32_t) - (long)&((vg32_t *)0)->proc))
  2381. err = -EFAULT;
  2382. }
  2383. if (copy_to_user(((vg32_t *)arg)->vg_uuid, v->vg_uuid, UUID_LEN+1)) {
  2384.         err = -EFAULT;
  2385. }
  2386. kfree(v);
  2387. break;
  2389. case VG_CREATE_OLD:
  2390. case VG_CREATE:
  2391. for (i = 0; i < v->pv_max; i++) {
  2392. if (v->pv[i])
  2393. kfree(v->pv[i]);
  2394. }
  2395. for (i = 0; i < v->lv_max; i++) {
  2396. if (v->lv[i])
  2397. put_lv_t(v->lv[i]);
  2398. }
  2399. kfree(v);
  2400. break;
  2402. case LV_STATUS_BYNAME:
  2403. if (!err && u.lv_req.lv)
  2404. err = copy_lv_t(ptr, u.lv_req.lv);
  2405. /* Fall through */
  2407.         case LV_CREATE:
  2408. case LV_EXTEND:
  2409. case LV_REDUCE:
  2410. if (u.lv_req.lv)
  2411. put_lv_t(u.lv_req.lv);
  2412. break;
  2414. case LV_STATUS_BYINDEX:
  2415. if (u.lv_byindex.lv) {
  2416. if (!err)
  2417. err = copy_lv_t(ptr, u.lv_byindex.lv);
  2418. put_lv_t(u.lv_byindex.lv);
  2419. }
  2420. break;
  2422. case LV_STATUS_BYDEV:
  2423.         if (u.lv_bydev.lv) {
  2424. if (!err)
  2425. err = copy_lv_t(ptr, u.lv_bydev.lv);
  2426. put_lv_t(u.lv_byindex.lv);
  2427.         }
  2428.         break;
  2430. case PV_STATUS:
  2431. if (!err) {
  2432. err = copy_to_user((void *)A(ptr), &p, sizeof(pv32_t) - 8 - UUID_LEN+1);
  2433. if (err)
  2434. return -EFAULT;
  2435. err = copy_to_user(((pv_t *)A(ptr))->pv_uuid, p.pv_uuid, UUID_LEN + 1);
  2436. if (err)
  2437. return -EFAULT;
  2438. }
  2439. break;
  2440. };
  2442. return err;
  2443. }
  2444. #endif
  2446. #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
  2447. /* This really belongs in include/linux/drm.h -DaveM */
  2448. #include "../../../drivers/char/drm/drm.h"
  2450. typedef struct drm32_version {
  2451. int    version_major;   /* Major version     */
  2452. int    version_minor;   /* Minor version     */
  2453. int    version_patchlevel;/* Patch level     */
  2454. int    name_len;   /* Length of name buffer     */
  2455. u32    name;   /* Name of driver     */
  2456. int    date_len;   /* Length of date buffer     */
  2457. u32    date;   /* User-space buffer to hold date     */
  2458. int    desc_len;   /* Length of desc buffer     */
  2459. u32    desc;   /* User-space buffer to hold desc     */
  2460. } drm32_version_t;
  2461. #define DRM32_IOCTL_VERSION    DRM_IOWR(0x00, drm32_version_t)
  2463. static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
  2464. {
  2465. drm32_version_t *uversion = (drm32_version_t *)arg;
  2466. char *name_ptr, *date_ptr, *desc_ptr;
  2467. u32 tmp1, tmp2, tmp3;
  2468. drm_version_t kversion;
  2469. mm_segment_t old_fs;
  2470. int ret;
  2472. memset(&kversion, 0, sizeof(kversion));
  2473. if (get_user(kversion.name_len, &uversion->name_len) ||
  2474.     get_user(kversion.date_len, &uversion->date_len) ||
  2475.     get_user(kversion.desc_len, &uversion->desc_len) ||
  2476.     get_user(tmp1, &uversion->name) ||
  2477.     get_user(tmp2, &uversion->date) ||
  2478.     get_user(tmp3, &uversion->desc))
  2479. return -EFAULT;
  2481. name_ptr = (char *) A(tmp1);
  2482. date_ptr = (char *) A(tmp2);
  2483. desc_ptr = (char *) A(tmp3);
  2485. ret = -ENOMEM;
  2486. if (kversion.name_len && name_ptr) {
  2487. kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
  2488. if (!kversion.name)
  2489. goto out;
  2490. }
  2491. if (kversion.date_len && date_ptr) {
  2492. kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
  2493. if (!kversion.date)
  2494. goto out;
  2495. }
  2496. if (kversion.desc_len && desc_ptr) {
  2497. kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
  2498. if (!kversion.desc)
  2499. goto out;
  2500. }
  2502.         old_fs = get_fs();
  2503. set_fs(KERNEL_DS);
  2504.         ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
  2505.         set_fs(old_fs);
  2507. if (!ret) {
  2508. if ((kversion.name &&
  2509.      copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
  2510.     (kversion.date &&
  2511.      copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
  2512.     (kversion.desc &&
  2513.      copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
  2514. ret = -EFAULT;
  2515. if (put_user(kversion.version_major, &uversion->version_major) ||
  2516.     put_user(kversion.version_minor, &uversion->version_minor) ||
  2517.     put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
  2518.     put_user(kversion.name_len, &uversion->name_len) ||
  2519.     put_user(kversion.date_len, &uversion->date_len) ||
  2520.     put_user(kversion.desc_len, &uversion->desc_len))
  2521. ret = -EFAULT;
  2522. }
  2524. out:
  2525. if (kversion.name)
  2526. kfree(kversion.name);
  2527. if (kversion.date)
  2528. kfree(kversion.date);
  2529. if (kversion.desc)
  2530. kfree(kversion.desc);
  2531. return ret;
  2532. }
  2534. typedef struct drm32_unique {
  2535. int unique_len;   /* Length of unique     */
  2536. u32 unique;   /* Unique name for driver instantiation   */
  2537. } drm32_unique_t;
  2538. #define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
  2539. #define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
  2541. static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
  2542. {
  2543. drm32_unique_t *uarg = (drm32_unique_t *)arg;
  2544. drm_unique_t karg;
  2545. mm_segment_t old_fs;
  2546. char *uptr;
  2547. u32 tmp;
  2548. int ret;
  2550. if (get_user(karg.unique_len, &uarg->unique_len))
  2551. return -EFAULT;
  2552. karg.unique = NULL;
  2554. if (get_user(tmp, &uarg->unique))
  2555. return -EFAULT;
  2557. uptr = (char *) A(tmp);
  2559. if (uptr) {
  2560. karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
  2561. if (!karg.unique)
  2562. return -ENOMEM;
  2563. if (cmd == DRM32_IOCTL_SET_UNIQUE &&
  2564.     copy_from_user(karg.unique, uptr, karg.unique_len)) {
  2565. kfree(karg.unique);
  2566. return -EFAULT;
  2567. }
  2568. }
  2570. old_fs = get_fs();
  2571. set_fs(KERNEL_DS);
  2572. if (cmd == DRM32_IOCTL_GET_UNIQUE)
  2573. ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
  2574. else
  2575. ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
  2576.         set_fs(old_fs);
  2578. if (!ret) {
  2579. if (cmd == DRM32_IOCTL_GET_UNIQUE &&
  2580.     uptr != NULL &&
  2581.     copy_to_user(uptr, karg.unique, karg.unique_len))
  2582. ret = -EFAULT;
  2583. if (put_user(karg.unique_len, &uarg->unique_len))
  2584. ret = -EFAULT;
  2585. }
  2587. if (karg.unique != NULL)
  2588. kfree(karg.unique);
  2590. return ret;
  2591. }
  2593. typedef struct drm32_map {
  2594. u32 offset;  /* Requested physical address (0 for SAREA)*/
  2595. u32 size;  /* Requested physical size (bytes)     */
  2596. drm_map_type_t type;  /* Type of memory to map     */
  2597. drm_map_flags_t flags;  /* Flags     */
  2598. u32 handle;  /* User-space: "Handle" to pass to mmap    */
  2599.  /* Kernel-space: kernel-virtual address    */
  2600. int mtrr;  /* MTRR slot used     */
  2601.  /* Private data     */
  2602. } drm32_map_t;
  2603. #define DRM32_IOCTL_ADD_MAP    DRM_IOWR(0x15, drm32_map_t)
  2605. static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
  2606. {
  2607. drm32_map_t *uarg = (drm32_map_t *) arg;
  2608. drm_map_t karg;
  2609. mm_segment_t old_fs;
  2610. u32 tmp;
  2611. int ret;
  2613. ret  = get_user(karg.offset, &uarg->offset);
  2614. ret |= get_user(karg.size, &uarg->size);
  2615. ret |= get_user(karg.type, &uarg->type);
  2616. ret |= get_user(karg.flags, &uarg->flags);
  2617. ret |= get_user(tmp, &uarg->handle);
  2618. ret |= get_user(karg.mtrr, &uarg->mtrr);
  2619. if (ret)
  2620. return -EFAULT;
  2622. karg.handle = (void *) A(tmp);
  2624. old_fs = get_fs();
  2625. set_fs(KERNEL_DS);
  2626. ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
  2627. set_fs(old_fs);
  2629. if (!ret) {
  2630. ret  = put_user(karg.offset, &uarg->offset);
  2631. ret |= put_user(karg.size, &uarg->size);
  2632. ret |= put_user(karg.type, &uarg->type);
  2633. ret |= put_user(karg.flags, &uarg->flags);
  2634. tmp = (u32) (long)karg.handle;
  2635. ret |= put_user(tmp, &uarg->handle);
  2636. ret |= put_user(karg.mtrr, &uarg->mtrr);
  2637. if (ret)
  2638. ret = -EFAULT;
  2639. }
  2641. return ret;
  2642. }
  2644. typedef struct drm32_buf_info {
  2645. int        count; /* Entries in list      */
  2646. u32        list;    /* (drm_buf_desc_t *) */ 
  2647. } drm32_buf_info_t;
  2648. #define DRM32_IOCTL_INFO_BUFS  DRM_IOWR(0x18, drm32_buf_info_t)
  2650. static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
  2651. {
  2652. drm32_buf_info_t *uarg = (drm32_buf_info_t *)arg;
  2653. drm_buf_desc_t *ulist;
  2654. drm_buf_info_t karg;
  2655. mm_segment_t old_fs;
  2656. int orig_count, ret;
  2657. u32 tmp;
  2659. if (get_user(karg.count, &uarg->count) ||
  2660.     get_user(tmp, &uarg->list))
  2661. return -EFAULT;
  2663. ulist = (drm_buf_desc_t *) A(tmp);
  2665. orig_count = karg.count;
  2667. karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
  2668. if (!karg.list)
  2669. return -EFAULT;
  2671. old_fs = get_fs();
  2672. set_fs(KERNEL_DS);
  2673. ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
  2674. set_fs(old_fs);
  2676. if (!ret) {
  2677. if (karg.count <= orig_count &&
  2678.     (copy_to_user(ulist, karg.list,
  2679.   karg.count * sizeof(drm_buf_desc_t))))
  2680. ret = -EFAULT;
  2681. if (put_user(karg.count, &uarg->count))
  2682. ret = -EFAULT;
  2683. }
  2685. kfree(karg.list);
  2687. return ret;
  2688. }
  2690. typedef struct drm32_buf_free {
  2691. int        count;
  2692. u32        list; /* (int *) */
  2693. } drm32_buf_free_t;
  2694. #define DRM32_IOCTL_FREE_BUFS  DRM_IOW( 0x1a, drm32_buf_free_t)
  2696. static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
  2697. {
  2698. drm32_buf_free_t *uarg = (drm32_buf_free_t *)arg;
  2699. drm_buf_free_t karg;
  2700. mm_segment_t old_fs;
  2701. int *ulist;
  2702. int ret;
  2703. u32 tmp;
  2705. if (get_user(karg.count, &uarg->count) ||
  2706.     get_user(tmp, &uarg->list))
  2707. return -EFAULT;
  2709. ulist = (int *) A(tmp);
  2711. karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
  2712. if (!karg.list)
  2713. return -ENOMEM;
  2715. ret = -EFAULT;
  2716. if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
  2717. goto out;
  2719. old_fs = get_fs();
  2720. set_fs(KERNEL_DS);
  2721. ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
  2722. set_fs(old_fs);
  2724. out:
  2725. kfree(karg.list);
  2727. return ret;
  2728. }
  2730. typedef struct drm32_buf_pub {
  2731. int   idx;        /* Index into master buflist      */
  2732. int   total;       /* Buffer size      */
  2733. int   used;        /* Amount of buffer in use (for DMA)  */
  2734. u32   address;     /* Address of buffer (void *)      */
  2735. } drm32_buf_pub_t;
  2737. typedef struct drm32_buf_map {
  2738. int       count; /* Length of buflist     */
  2739. u32       virtual; /* Mmaped area in user-virtual (void *)     */
  2740. u32        list; /* Buffer information (drm_buf_pub_t *)     */
  2741. } drm32_buf_map_t;
  2742. #define DRM32_IOCTL_MAP_BUFS   DRM_IOWR(0x19, drm32_buf_map_t)
  2744. static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
  2745. {
  2746. drm32_buf_map_t *uarg = (drm32_buf_map_t *)arg;
  2747. drm32_buf_pub_t *ulist;
  2748. drm_buf_map_t karg;
  2749. mm_segment_t old_fs;
  2750. int orig_count, ret, i;
  2751. u32 tmp1, tmp2;
  2753. if (get_user(karg.count, &uarg->count) ||
  2754.     get_user(tmp1, &uarg->virtual) ||
  2755.     get_user(tmp2, &uarg->list))
  2756. return -EFAULT;
  2758. karg.virtual = (void *) A(tmp1);
  2759. ulist = (drm32_buf_pub_t *) A(tmp2);
  2761. orig_count = karg.count;
  2763. karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
  2764. if (!karg.list)
  2765. return -ENOMEM;
  2767. ret = -EFAULT;
  2768. for (i = 0; i < karg.count; i++) {
  2769. if (get_user(karg.list[i].idx, &ulist[i].idx) ||
  2770.     get_user(karg.list[i].total, &ulist[i].total) ||
  2771.     get_user(karg.list[i].used, &ulist[i].used) ||
  2772.     get_user(tmp1, &ulist[i].address))
  2773. goto out;
  2775. karg.list[i].address = (void *) A(tmp1);
  2776. }
  2778. old_fs = get_fs();
  2779. set_fs(KERNEL_DS);
  2780. ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
  2781. set_fs(old_fs);
  2783. if (!ret) {
  2784. for (i = 0; i < orig_count; i++) {
  2785. tmp1 = (u32) (long) karg.list[i].address;
  2786. if (put_user(karg.list[i].idx, &ulist[i].idx) ||
  2787.     put_user(karg.list[i].total, &ulist[i].total) ||
  2788.     put_user(karg.list[i].used, &ulist[i].used) ||
  2789.     put_user(tmp1, &ulist[i].address)) {
  2790. ret = -EFAULT;
  2791. goto out;
  2792. }
  2793. }
  2794. if (put_user(karg.count, &uarg->count))
  2795. ret = -EFAULT;
  2796. }
  2798. out:
  2799. kfree(karg.list);
  2800. return ret;
  2801. }
  2803. typedef struct drm32_dma {
  2804. /* Indices here refer to the offset into
  2805.    buflist in drm_buf_get_t.  */
  2806. int context;   /* Context handle     */
  2807. int send_count;   /* Number of buffers to send     */
  2808. u32 send_indices;   /* List of handles to buffers (int *) */
  2809. u32 send_sizes;   /* Lengths of data to send (int *) */
  2810. drm_dma_flags_t flags;   /* Flags     */
  2811. int request_count;   /* Number of buffers requested    */
  2812. int request_size;   /* Desired size for buffers     */
  2813. u32 request_indices;  /* Buffer information (int *)     */
  2814. u32 request_sizes;    /* (int *) */
  2815. int granted_count;   /* Number of buffers granted     */
  2816. } drm32_dma_t;
  2817. #define DRM32_IOCTL_DMA      DRM_IOWR(0x29, drm32_dma_t)
  2819. /* RED PEN The DRM layer blindly dereferences the send/request
  2820.  *  indice/size arrays even though they are userland
  2821.  *  pointers.  -DaveM
  2822.  */
  2823. static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
  2824. {
  2825. drm32_dma_t *uarg = (drm32_dma_t *) arg;
  2826. int *u_si, *u_ss, *u_ri, *u_rs;
  2827. drm_dma_t karg;
  2828. mm_segment_t old_fs;
  2829. int ret;
  2830. u32 tmp1, tmp2, tmp3, tmp4;
  2832. karg.send_indices = karg.send_sizes = NULL;
  2833. karg.request_indices = karg.request_sizes = NULL;
  2835. if (get_user(karg.context, &uarg->context) ||
  2836.     get_user(karg.send_count, &uarg->send_count) ||
  2837.     get_user(tmp1, &uarg->send_indices) ||
  2838.     get_user(tmp2, &uarg->send_sizes) ||
  2839.     get_user(karg.flags, &uarg->flags) ||
  2840.     get_user(karg.request_count, &uarg->request_count) ||
  2841.     get_user(karg.request_size, &uarg->request_size) ||
  2842.     get_user(tmp3, &uarg->request_indices) ||
  2843.     get_user(tmp4, &uarg->request_sizes) ||
  2844.     get_user(karg.granted_count, &uarg->granted_count))
  2845. return -EFAULT;
  2847. u_si = (int *) A(tmp1);
  2848. u_ss = (int *) A(tmp2);
  2849. u_ri = (int *) A(tmp3);
  2850. u_rs = (int *) A(tmp4);
  2852. if (karg.send_count) {
  2853. karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
  2854. karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
  2856. ret = -ENOMEM;
  2857. if (!karg.send_indices || !karg.send_sizes)
  2858. goto out;
  2860. ret = -EFAULT;
  2861. if (copy_from_user(karg.send_indices, u_si,
  2862.    (karg.send_count * sizeof(int))) ||
  2863.     copy_from_user(karg.send_sizes, u_ss,
  2864.    (karg.send_count * sizeof(int))))
  2865. goto out;
  2866. }
  2868. if (karg.request_count) {
  2869. karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
  2870. karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
  2872. ret = -ENOMEM;
  2873. if (!karg.request_indices || !karg.request_sizes)
  2874. goto out;
  2876. ret = -EFAULT;
  2877. if (copy_from_user(karg.request_indices, u_ri,
  2878.    (karg.request_count * sizeof(int))) ||
  2879.     copy_from_user(karg.request_sizes, u_rs,
  2880.    (karg.request_count * sizeof(int))))
  2881. goto out;
  2882. }
  2884. old_fs = get_fs();
  2885. set_fs(KERNEL_DS);
  2886. ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
  2887. set_fs(old_fs);
  2889. if (!ret) {
  2890. if (put_user(karg.context, &uarg->context) ||
  2891.     put_user(karg.send_count, &uarg->send_count) ||
  2892.     put_user(karg.flags, &uarg->flags) ||
  2893.     put_user(karg.request_count, &uarg->request_count) ||
  2894.     put_user(karg.request_size, &uarg->request_size) ||
  2895.     put_user(karg.granted_count, &uarg->granted_count))
  2896. ret = -EFAULT;
  2898. if (karg.send_count) {
  2899. if (copy_to_user(u_si, karg.send_indices,
  2900.  (karg.send_count * sizeof(int))) ||
  2901.     copy_to_user(u_ss, karg.send_sizes,
  2902.  (karg.send_count * sizeof(int))))
  2903. ret = -EFAULT;
  2904. }
  2905. if (karg.request_count) {
  2906. if (copy_to_user(u_ri, karg.request_indices,
  2907.  (karg.request_count * sizeof(int))) ||
  2908.     copy_to_user(u_rs, karg.request_sizes,
  2909.  (karg.request_count * sizeof(int))))
  2910. ret = -EFAULT;
  2911. }
  2912. }
  2914. out:
  2915. if (karg.send_indices)
  2916. kfree(karg.send_indices);
  2917. if (karg.send_sizes)
  2918. kfree(karg.send_sizes);
  2919. if (karg.request_indices)
  2920. kfree(karg.request_indices);
  2921. if (karg.request_sizes)
  2922. kfree(karg.request_sizes);
  2924. return ret;
  2925. }
  2927. typedef struct drm32_ctx_res {
  2928. int count;
  2929. u32 contexts; /* (drm_ctx_t *) */
  2930. } drm32_ctx_res_t;
  2931. #define DRM32_IOCTL_RES_CTX    DRM_IOWR(0x26, drm32_ctx_res_t)
  2933. static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
  2934. {
  2935. drm32_ctx_res_t *uarg = (drm32_ctx_res_t *) arg;
  2936. drm_ctx_t *ulist;
  2937. drm_ctx_res_t karg;
  2938. mm_segment_t old_fs;
  2939. int orig_count, ret;
  2940. u32 tmp;
  2942. karg.contexts = NULL;
  2943. if (get_user(karg.count, &uarg->count) ||
  2944.     get_user(tmp, &uarg->contexts))
  2945. return -EFAULT;
  2947. ulist = (drm_ctx_t *) A(tmp);
  2949. orig_count = karg.count;
  2950. if (karg.count && ulist) {
  2951. karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
  2952. if (!karg.contexts)
  2953. return -ENOMEM;
  2954. if (copy_from_user(karg.contexts, ulist,
  2955.    (karg.count * sizeof(drm_ctx_t)))) {
  2956. kfree(karg.contexts);
  2957. return -EFAULT;
  2958. }
  2959. }
  2961. old_fs = get_fs();
  2962. set_fs(KERNEL_DS);
  2963. ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
  2964. set_fs(old_fs);
  2966. if (!ret) {
  2967. if (orig_count) {
  2968. if (copy_to_user(ulist, karg.contexts,
  2969.  (orig_count * sizeof(drm_ctx_t))))
  2970. ret = -EFAULT;
  2971. }
  2972. if (put_user(karg.count, &uarg->count))
  2973. ret = -EFAULT;
  2974. }
  2976. if (karg.contexts)
  2977. kfree(karg.contexts);
  2979. return ret;
  2980. }
  2982. #endif
  2984. static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
  2985. {
  2986. return -EINVAL;
  2987. }
  2989. static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
  2990. {
  2991. /* The mkswap binary hard codes it to Intel value :-((( */
  2992. return w_long(fd, BLKGETSIZE, arg);
  2993. }
  2995. struct blkpg_ioctl_arg32 {
  2996. int op;
  2997. int flags;
  2998. int datalen;
  2999. u32 data;
  3000. };
  3001.                                 
  3002. static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd, struct blkpg_ioctl_arg32 *arg)
  3003. {
  3004. struct blkpg_ioctl_arg a;
  3005. struct blkpg_partition p;
  3006. int err;
  3007. mm_segment_t old_fs = get_fs();
  3009. err = get_user(a.op, &arg->op);
  3010. err |= __get_user(a.flags, &arg->flags);
  3011. err |= __get_user(a.datalen, &arg->datalen);
  3012. err |= __get_user((long)a.data, &arg->data);
  3013. if (err) return err;
  3014. switch (a.op) {
  3015. case BLKPG_ADD_PARTITION:
  3016. case BLKPG_DEL_PARTITION:
  3017. if (a.datalen < sizeof(struct blkpg_partition))
  3018. return -EINVAL;
  3019.                 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
  3020. return -EFAULT;
  3021. a.data = &p;
  3022. set_fs (KERNEL_DS);
  3023. err = sys_ioctl(fd, cmd, (unsigned long)&a);
  3024. set_fs (old_fs);
  3025. default:
  3026. return -EINVAL;
  3027. }                                        
  3028. return err;
  3029. }
  3031. static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
  3032. {
  3033. return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
  3034. }
  3036. /* SuSE extension */ 
  3037. #ifndef TIOCGDEV
  3038. #define TIOCGDEV       _IOR('T',0x32, unsigned int)
  3039. #endif
  3040. static int tiocgdev(unsigned fd, unsigned cmd,  unsigned int *ptr) 
  3041. { 
  3043. struct file *file = fget(fd);
  3044. struct tty_struct *real_tty;
  3046. if (!fd)
  3047. return -EBADF;
  3048. if (file->f_op->ioctl != tty_ioctl)
  3049. return -EINVAL; 
  3050. real_tty = (struct tty_struct *)file->private_data;
  3051. if (!real_tty) 
  3052. return -EINVAL; 
  3053. return put_user(kdev_t_to_nr(real_tty->device), ptr); 
  3054. } 
  3057. struct raw32_config_request 
  3058. {
  3059. int raw_minor;
  3060. __u64 block_major;
  3061. __u64 block_minor;
  3062. } __attribute__((packed));
  3064. static int raw_ioctl(unsigned fd, unsigned cmd,  void *ptr) 
  3065. { 
  3066. int ret;
  3067. switch (cmd) { 
  3068. case RAW_SETBIND:
  3069. case RAW_GETBIND: {
  3070. struct raw_config_request req; 
  3071. struct raw32_config_request *user_req = ptr;
  3072. mm_segment_t oldfs = get_fs(); 
  3074. if (get_user(req.raw_minor, &user_req->raw_minor) ||
  3075.     get_user(req.block_major, &user_req->block_major) ||
  3076.     get_user(req.block_minor, &user_req->block_minor))
  3077. return -EFAULT;
  3078. set_fs(KERNEL_DS); 
  3079. ret = sys_ioctl(fd,cmd,(unsigned long)&req); 
  3080. set_fs(oldfs); 
  3081. break;
  3082. }
  3083. default:
  3084. ret = sys_ioctl(fd,cmd,(unsigned long)ptr);
  3085. break;
  3086. } 
  3087. return ret; 
  3088. } 
  3090. struct serial_struct32 {
  3091. int type;
  3092. int line;
  3093. unsigned int port;
  3094. int irq;
  3095. int flags;
  3096. int xmit_fifo_size;
  3097. int custom_divisor;
  3098. int baud_base;
  3099. unsigned short close_delay;
  3100. char io_type;
  3101. char reserved_char[1];
  3102. int hub6;
  3103. unsigned short closing_wait; /* time to wait before closing */
  3104. unsigned short closing_wait2; /* no longer used... */
  3105. __u32 iomem_base;
  3106. unsigned short iomem_reg_shift;
  3107. unsigned int port_high;
  3108. int reserved[1];
  3109. };
  3111. static int serial_struct_ioctl(unsigned fd, unsigned cmd,  void *ptr) 
  3112. {
  3113. typedef struct serial_struct SS;
  3114. struct serial_struct32 *ss32 = ptr; 
  3115. int err = 0;
  3116. struct serial_struct ss; 
  3117. mm_segment_t oldseg = get_fs(); 
  3118. set_fs(KERNEL_DS);
  3119. if (cmd == TIOCSSERIAL) { 
  3120. err = -EFAULT;
  3121. if (copy_from_user(&ss, ss32, sizeof(struct serial_struct32)))
  3122. goto out;
  3123. memmove(&ss.iomem_reg_shift, ((char*)&ss.iomem_base)+4, 
  3124. sizeof(SS)-offsetof(SS,iomem_reg_shift)); 
  3125. ss.iomem_base = (void *)((unsigned long)ss.iomem_base & 0xffffffff);
  3126. }
  3127. if (!err)
  3128. err = sys_ioctl(fd,cmd,(unsigned long)(&ss)); 
  3129. if (cmd == TIOCGSERIAL && err >= 0) { 
  3130. __u32 base;
  3131. if (__copy_to_user(ss32,&ss,offsetof(SS,iomem_base)) ||
  3132.     __copy_to_user(&ss32->iomem_reg_shift,
  3133.    &ss.iomem_reg_shift,
  3134.    sizeof(SS) - offsetof(SS, iomem_reg_shift)))
  3135. err = -EFAULT;
  3136. if (ss.iomem_base > (unsigned char *)0xffffffff)
  3137. base = -1; 
  3138. else
  3139. base = (unsigned long)ss.iomem_base;
  3140. err |= __put_user(base, &ss32->iomem_base); 
  3141. } 
  3142.  out:
  3143. set_fs(oldseg);
  3144. return err;
  3145. }
  3148. #define REISERFS_IOC_UNPACK32               _IOW(0xCD,1,int)
  3150. static int reiserfs_ioctl32(unsigned fd, unsigned cmd, unsigned long ptr) 
  3151. { 
  3152. if (cmd == REISERFS_IOC_UNPACK32) 
  3153. cmd = REISERFS_IOC_UNPACK; 
  3154. return sys_ioctl(fd,cmd,ptr); 
  3155. } 
  3157. struct dirent32 {
  3158. unsigned int d_ino;
  3159. __kernel_off_t32 d_off;
  3160. unsigned short d_reclen;
  3161. char d_name[256]; /* We must not include limits.h! */
  3162. };
  3164. #define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct dirent32 [2])
  3165. #define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct dirent32 [2])
  3167. static int put_dirent32(struct dirent *src, struct dirent32 *dst)
  3168. { 
  3169. int ret;
  3170. ret = put_user(src->d_ino, &dst->d_ino); 
  3171. ret |= __put_user(src->d_off, &dst->d_off); 
  3172. ret |= __put_user(src->d_reclen, &dst->d_reclen); 
  3173. if (__copy_to_user(&dst->d_name, src->d_name, src->d_reclen))
  3174. ret |= -EFAULT;
  3175. return ret;
  3176. } 
  3178. static int vfat_ioctl32(unsigned fd, unsigned cmd,  void *ptr) 
  3179. {
  3180. int ret;
  3181. mm_segment_t oldfs = get_fs();
  3182. struct dirent d[2]; 
  3184. set_fs(KERNEL_DS); 
  3185. ret = sys_ioctl(fd,cmd,(unsigned long)&d); 
  3186. set_fs(oldfs); 
  3187. if (!ret) { 
  3188. ret |= put_dirent32(&d[0], (struct dirent32 *)ptr); 
  3189. ret |= put_dirent32(&d[1], ((struct dirent32 *)ptr) + 1); 
  3190. } 
  3191. return ret;
  3192. }
  3194. #define RTC_IRQP_READ32 _IOR('p', 0x0b, unsigned int)  /* Read IRQ rate   */
  3195. #define RTC_IRQP_SET32 _IOW('p', 0x0c, unsigned int)  /* Set IRQ rate    */
  3196. #define RTC_EPOCH_READ32 _IOR('p', 0x0d, unsigned)  /* Read epoch      */
  3197. #define RTC_EPOCH_SET32 _IOW('p', 0x0e, unsigned)  /* Set epoch       */
  3199. static int rtc32_ioctl(unsigned fd, unsigned cmd, unsigned long arg) 
  3200. {
  3201. unsigned long val;
  3202. mm_segment_t oldfs = get_fs(); 
  3203. int ret; 
  3205. switch (cmd) { 
  3206. case RTC_IRQP_READ32: 
  3207. set_fs(KERNEL_DS);
  3208. ret = sys_ioctl(fd, RTC_IRQP_READ, (unsigned long)&val); 
  3209. set_fs(oldfs); 
  3210. if (!ret)
  3211. ret = put_user(val, (unsigned int*) arg); 
  3212. return ret; 
  3214. case RTC_IRQP_SET32: 
  3215. cmd = RTC_EPOCH_SET; 
  3216. break; 
  3218. case RTC_EPOCH_READ32:
  3219. set_fs(KERNEL_DS); 
  3220. ret = sys_ioctl(fd, RTC_EPOCH_READ, (unsigned long) &val); 
  3221. set_fs(oldfs); 
  3222. if (!ret)
  3223. ret = put_user(val, (unsigned int*) arg); 
  3224. return ret; 
  3226. case RTC_EPOCH_SET32:
  3227. cmd = RTC_EPOCH_SET; 
  3228. break; 
  3229. } 
  3230. return sys_ioctl(fd,cmd,arg); 
  3231. } 
  3233. struct ioctl_trans {
  3234. unsigned long cmd;
  3235. int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
  3236. struct ioctl_trans *next;
  3237. };
  3239. #define REF_SYMBOL(handler) if (0) (void)handler;
  3240. #define HANDLE_IOCTL2(cmd,handler) REF_SYMBOL(handler);  asm volatile(".quad %c0, " #handler ",0"::"i" (cmd)); 
  3241. #define HANDLE_IOCTL(cmd,handler) HANDLE_IOCTL2(cmd,handler)
  3242. #define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd,sys_ioctl)
  3243. #define IOCTL_TABLE_START void ioctl_dummy(void) { asm volatile("nioctl_start:nt" );
  3244. #define IOCTL_TABLE_END  asm volatile("nioctl_end:"); }
  3246. IOCTL_TABLE_START
  3247. /* List here explicitly which ioctl's are known to have
  3248.  * compatable types passed or none at all...
  3249.  */
  3250. /* Big T */
  3251. COMPATIBLE_IOCTL(TCGETA)
  3252. COMPATIBLE_IOCTL(TCSETA)
  3253. COMPATIBLE_IOCTL(TCSETAW)
  3254. COMPATIBLE_IOCTL(TCSETAF)
  3255. COMPATIBLE_IOCTL(TCSBRK)
  3256. COMPATIBLE_IOCTL(TCXONC)
  3257. COMPATIBLE_IOCTL(TCFLSH)
  3258. COMPATIBLE_IOCTL(TCGETS)
  3259. COMPATIBLE_IOCTL(TCSETS)
  3260. COMPATIBLE_IOCTL(TCSETSW)
  3261. COMPATIBLE_IOCTL(TCSETSF)
  3262. COMPATIBLE_IOCTL(TIOCLINUX)
  3263. HANDLE_IOCTL(TIOCGDEV, tiocgdev)
  3264. /* Little t */
  3265. COMPATIBLE_IOCTL(TIOCGETD)
  3266. COMPATIBLE_IOCTL(TIOCSETD)
  3267. COMPATIBLE_IOCTL(TIOCEXCL)
  3268. COMPATIBLE_IOCTL(TIOCNXCL)
  3269. COMPATIBLE_IOCTL(TIOCCONS)
  3270. COMPATIBLE_IOCTL(TIOCGSOFTCAR)
  3271. COMPATIBLE_IOCTL(TIOCSSOFTCAR)
  3272. COMPATIBLE_IOCTL(TIOCSWINSZ)
  3273. COMPATIBLE_IOCTL(TIOCGWINSZ)
  3274. COMPATIBLE_IOCTL(TIOCMGET)
  3275. COMPATIBLE_IOCTL(TIOCMBIC)
  3276. COMPATIBLE_IOCTL(TIOCMBIS)
  3277. COMPATIBLE_IOCTL(TIOCMSET)
  3278. COMPATIBLE_IOCTL(TIOCPKT)
  3279. COMPATIBLE_IOCTL(TIOCNOTTY)
  3280. COMPATIBLE_IOCTL(TIOCSTI)
  3281. COMPATIBLE_IOCTL(TIOCOUTQ)
  3282. COMPATIBLE_IOCTL(TIOCSPGRP)
  3283. COMPATIBLE_IOCTL(TIOCGPGRP)
  3284. COMPATIBLE_IOCTL(TIOCSCTTY)
  3285. COMPATIBLE_IOCTL(TIOCGPTN)
  3286. COMPATIBLE_IOCTL(TIOCSPTLCK)
  3287. COMPATIBLE_IOCTL(TIOCSERGETLSR)
  3288. COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO)
  3289. COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO)
  3290. COMPATIBLE_IOCTL(FBIOPAN_DISPLAY)
  3291. COMPATIBLE_IOCTL(FBIOGET_FCURSORINFO)
  3292. COMPATIBLE_IOCTL(FBIOGET_VCURSORINFO)
  3293. COMPATIBLE_IOCTL(FBIOPUT_VCURSORINFO)
  3294. COMPATIBLE_IOCTL(FBIOGET_CURSORSTATE)
  3295. COMPATIBLE_IOCTL(FBIOPUT_CURSORSTATE)
  3296. COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP)
  3297. COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP)
  3298. /* Little f */
  3299. COMPATIBLE_IOCTL(FIOCLEX)
  3300. COMPATIBLE_IOCTL(FIONCLEX)
  3301. COMPATIBLE_IOCTL(FIOASYNC)
  3302. COMPATIBLE_IOCTL(FIONBIO)
  3303. COMPATIBLE_IOCTL(FIONREAD)  /* This is also TIOCINQ */
  3304. /* 0x00 */
  3305. COMPATIBLE_IOCTL(FIBMAP)
  3306. COMPATIBLE_IOCTL(FIGETBSZ)
  3307. /* 0x03 -- HD/IDE ioctl's used by hdparm and friends.
  3308.  *         Some need translations, these do not.
  3309.  */
  3310. COMPATIBLE_IOCTL(HDIO_GET_IDENTITY)
  3311. COMPATIBLE_IOCTL(HDIO_SET_DMA)
  3312. COMPATIBLE_IOCTL(HDIO_SET_KEEPSETTINGS)
  3313. COMPATIBLE_IOCTL(HDIO_SET_UNMASKINTR)
  3314. COMPATIBLE_IOCTL(HDIO_SET_NOWERR)
  3315. COMPATIBLE_IOCTL(HDIO_SET_32BIT)
  3316. COMPATIBLE_IOCTL(HDIO_SET_MULTCOUNT)
  3317. COMPATIBLE_IOCTL(HDIO_DRIVE_CMD)
  3318. COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE)
  3319. COMPATIBLE_IOCTL(HDIO_SCAN_HWIF)
  3320. COMPATIBLE_IOCTL(HDIO_SET_NICE)
  3321. /* 0x02 -- Floppy ioctls */
  3322. COMPATIBLE_IOCTL(FDMSGON)
  3323. COMPATIBLE_IOCTL(FDMSGOFF)
  3324. COMPATIBLE_IOCTL(FDSETEMSGTRESH)
  3325. COMPATIBLE_IOCTL(FDFLUSH)
  3326. COMPATIBLE_IOCTL(FDWERRORCLR)
  3327. COMPATIBLE_IOCTL(FDSETMAXERRS)
  3328. COMPATIBLE_IOCTL(FDGETMAXERRS)
  3329. COMPATIBLE_IOCTL(FDGETDRVTYP)
  3330. COMPATIBLE_IOCTL(FDEJECT)
  3331. COMPATIBLE_IOCTL(FDCLRPRM)
  3332. COMPATIBLE_IOCTL(FDFMTBEG)
  3333. COMPATIBLE_IOCTL(FDFMTEND)
  3334. COMPATIBLE_IOCTL(FDRESET)
  3335. COMPATIBLE_IOCTL(FDTWADDLE)
  3336. COMPATIBLE_IOCTL(FDFMTTRK)
  3337. COMPATIBLE_IOCTL(FDRAWCMD)
  3338. /* 0x12 */
  3339. COMPATIBLE_IOCTL(BLKROSET)
  3340. COMPATIBLE_IOCTL(BLKROGET)
  3341. COMPATIBLE_IOCTL(BLKRRPART)
  3342. COMPATIBLE_IOCTL(BLKFLSBUF)
  3343. COMPATIBLE_IOCTL(BLKRASET)
  3344. COMPATIBLE_IOCTL(BLKFRASET)
  3345. COMPATIBLE_IOCTL(BLKSECTSET)
  3346. COMPATIBLE_IOCTL(BLKSSZGET)
  3348. /* RAID */
  3349. COMPATIBLE_IOCTL(RAID_VERSION)
  3350. COMPATIBLE_IOCTL(GET_ARRAY_INFO)
  3351. COMPATIBLE_IOCTL(GET_DISK_INFO)
  3352. COMPATIBLE_IOCTL(PRINT_RAID_DEBUG)
  3353. COMPATIBLE_IOCTL(CLEAR_ARRAY)
  3354. COMPATIBLE_IOCTL(ADD_NEW_DISK)
  3355. COMPATIBLE_IOCTL(HOT_REMOVE_DISK)
  3356. COMPATIBLE_IOCTL(SET_ARRAY_INFO)
  3357. COMPATIBLE_IOCTL(SET_DISK_INFO)
  3358. COMPATIBLE_IOCTL(WRITE_RAID_INFO)
  3359. COMPATIBLE_IOCTL(UNPROTECT_ARRAY)
  3360. COMPATIBLE_IOCTL(PROTECT_ARRAY)
  3361. COMPATIBLE_IOCTL(HOT_ADD_DISK)
  3362. COMPATIBLE_IOCTL(SET_DISK_FAULTY)
  3363. COMPATIBLE_IOCTL(RUN_ARRAY)
  3364. COMPATIBLE_IOCTL(START_ARRAY)
  3365. COMPATIBLE_IOCTL(STOP_ARRAY)
  3366. COMPATIBLE_IOCTL(STOP_ARRAY_RO)
  3367. COMPATIBLE_IOCTL(RESTART_ARRAY_RW)
  3369. /* Big K */
  3370. COMPATIBLE_IOCTL(PIO_FONT)
  3371. COMPATIBLE_IOCTL(GIO_FONT)
  3372. COMPATIBLE_IOCTL(KDSIGACCEPT)
  3373. COMPATIBLE_IOCTL(KDGETKEYCODE)
  3374. COMPATIBLE_IOCTL(KDSETKEYCODE)
  3375. COMPATIBLE_IOCTL(KIOCSOUND)
  3376. COMPATIBLE_IOCTL(KDMKTONE)
  3377. COMPATIBLE_IOCTL(KDGKBTYPE)
  3378. COMPATIBLE_IOCTL(KDSETMODE)
  3379. COMPATIBLE_IOCTL(KDGETMODE)
  3380. COMPATIBLE_IOCTL(KDSKBMODE)
  3381. COMPATIBLE_IOCTL(KDGKBMODE)
  3382. COMPATIBLE_IOCTL(KDSKBMETA)
  3383. COMPATIBLE_IOCTL(KDGKBMETA)
  3384. COMPATIBLE_IOCTL(KDGKBENT)
  3385. COMPATIBLE_IOCTL(KDSKBENT)
  3386. COMPATIBLE_IOCTL(KDGKBSENT)
  3387. COMPATIBLE_IOCTL(KDSKBSENT)
  3388. COMPATIBLE_IOCTL(KDGKBDIACR)
  3389. COMPATIBLE_IOCTL(KDSKBDIACR)
  3390. COMPATIBLE_IOCTL(KDGKBLED)
  3391. COMPATIBLE_IOCTL(KDSKBLED)
  3392. COMPATIBLE_IOCTL(KDGETLED)
  3393. COMPATIBLE_IOCTL(KDSETLED)
  3394. COMPATIBLE_IOCTL(GIO_SCRNMAP)
  3395. COMPATIBLE_IOCTL(PIO_SCRNMAP)
  3396. COMPATIBLE_IOCTL(GIO_UNISCRNMAP)
  3397. COMPATIBLE_IOCTL(PIO_UNISCRNMAP)
  3398. COMPATIBLE_IOCTL(PIO_FONTRESET)
  3399. COMPATIBLE_IOCTL(PIO_UNIMAPCLR)
  3400. /* Big S */
  3401. COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN)
  3402. COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK)
  3403. COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK)
  3404. COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY)
  3405. COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_ENABLE)
  3406. COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_DISABLE)
  3407. COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER)
  3408. COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND)
  3409. /* Big V */
  3410. COMPATIBLE_IOCTL(VT_SETMODE)
  3411. COMPATIBLE_IOCTL(VT_GETMODE)
  3412. COMPATIBLE_IOCTL(VT_GETSTATE)
  3413. COMPATIBLE_IOCTL(VT_OPENQRY)
  3414. COMPATIBLE_IOCTL(VT_ACTIVATE)
  3415. COMPATIBLE_IOCTL(VT_WAITACTIVE)
  3416. COMPATIBLE_IOCTL(VT_RELDISP)
  3417. COMPATIBLE_IOCTL(VT_DISALLOCATE)
  3418. COMPATIBLE_IOCTL(VT_RESIZE)
  3419. COMPATIBLE_IOCTL(VT_RESIZEX)
  3420. COMPATIBLE_IOCTL(VT_LOCKSWITCH)
  3421. COMPATIBLE_IOCTL(VT_UNLOCKSWITCH)
  3422. /* Little v, the video4linux ioctls */
  3423. COMPATIBLE_IOCTL(VIDIOCGCAP)
  3424. COMPATIBLE_IOCTL(VIDIOCGCHAN)
  3425. COMPATIBLE_IOCTL(VIDIOCSCHAN)
  3426. COMPATIBLE_IOCTL(VIDIOCGPICT)
  3427. COMPATIBLE_IOCTL(VIDIOCSPICT)
  3428. COMPATIBLE_IOCTL(VIDIOCCAPTURE)
  3429. COMPATIBLE_IOCTL(VIDIOCKEY)
  3430. COMPATIBLE_IOCTL(VIDIOCGAUDIO)
  3431. COMPATIBLE_IOCTL(VIDIOCSAUDIO)
  3432. COMPATIBLE_IOCTL(VIDIOCSYNC)
  3433. COMPATIBLE_IOCTL(VIDIOCMCAPTURE)
  3434. COMPATIBLE_IOCTL(VIDIOCGMBUF)
  3435. COMPATIBLE_IOCTL(VIDIOCGUNIT)
  3436. COMPATIBLE_IOCTL(VIDIOCGCAPTURE)
  3437. COMPATIBLE_IOCTL(VIDIOCSCAPTURE)
  3438. /* BTTV specific... */
  3439. COMPATIBLE_IOCTL(_IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]))
  3440. COMPATIBLE_IOCTL(_IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]))
  3441. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int))
  3442. COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])) /* struct bttv_pll_info */
  3443. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int))
  3444. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int))
  3445. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int))
  3446. COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int))
  3447. /* Little p (/dev/rtc, /dev/envctrl, etc.) */
  3448. COMPATIBLE_IOCTL(RTC_AIE_ON)
  3449. COMPATIBLE_IOCTL(RTC_AIE_OFF)
  3450. COMPATIBLE_IOCTL(RTC_UIE_ON)
  3451. COMPATIBLE_IOCTL(RTC_UIE_OFF)
  3452. COMPATIBLE_IOCTL(RTC_PIE_ON)
  3453. COMPATIBLE_IOCTL(RTC_PIE_OFF)
  3454. COMPATIBLE_IOCTL(RTC_WIE_ON)
  3455. COMPATIBLE_IOCTL(RTC_WIE_OFF)
  3456. COMPATIBLE_IOCTL(RTC_ALM_SET)
  3457. COMPATIBLE_IOCTL(RTC_ALM_READ)
  3458. COMPATIBLE_IOCTL(RTC_RD_TIME)
  3459. COMPATIBLE_IOCTL(RTC_SET_TIME)
  3460. COMPATIBLE_IOCTL(RTC_WKALM_SET)
  3461. COMPATIBLE_IOCTL(RTC_WKALM_RD)
  3462. HANDLE_IOCTL(RTC_IRQP_READ,  rtc32_ioctl)
  3463. HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl)
  3464. HANDLE_IOCTL(RTC_IRQP_SET32, rtc32_ioctl)
  3465. HANDLE_IOCTL(RTC_EPOCH_READ32, rtc32_ioctl)
  3466. HANDLE_IOCTL(RTC_EPOCH_SET32, rtc32_ioctl)
  3467. /* Little m */
  3468. COMPATIBLE_IOCTL(MTIOCTOP)
  3469. /* Socket level stuff */
  3470. COMPATIBLE_IOCTL(FIOSETOWN)
  3471. COMPATIBLE_IOCTL(SIOCSPGRP)
  3472. COMPATIBLE_IOCTL(FIOGETOWN)
  3473. COMPATIBLE_IOCTL(SIOCGPGRP)
  3474. COMPATIBLE_IOCTL(SIOCATMARK)
  3475. COMPATIBLE_IOCTL(SIOCSIFLINK)
  3476. COMPATIBLE_IOCTL(SIOCSIFENCAP)
  3477. COMPATIBLE_IOCTL(SIOCGIFENCAP)
  3478. COMPATIBLE_IOCTL(SIOCSIFBR)
  3479. COMPATIBLE_IOCTL(SIOCGIFBR)
  3480. COMPATIBLE_IOCTL(SIOCSARP)
  3481. COMPATIBLE_IOCTL(SIOCGARP)
  3482. COMPATIBLE_IOCTL(SIOCDARP)
  3483. COMPATIBLE_IOCTL(SIOCSRARP)
  3484. COMPATIBLE_IOCTL(SIOCGRARP)
  3485. COMPATIBLE_IOCTL(SIOCDRARP)
  3486. COMPATIBLE_IOCTL(SIOCADDDLCI)
  3487. COMPATIBLE_IOCTL(SIOCDELDLCI)
  3488. /* SG stuff */
  3489. COMPATIBLE_IOCTL(SG_SET_TIMEOUT)
  3490. COMPATIBLE_IOCTL(SG_GET_TIMEOUT)
  3491. COMPATIBLE_IOCTL(SG_EMULATED_HOST)
  3492. COMPATIBLE_IOCTL(SG_SET_TRANSFORM)
  3493. COMPATIBLE_IOCTL(SG_GET_TRANSFORM)
  3494. COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE)
  3495. COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE)
  3496. COMPATIBLE_IOCTL(SG_GET_SCSI_ID)
  3497. COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA)
  3498. COMPATIBLE_IOCTL(SG_GET_LOW_DMA)
  3499. COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID)
  3500. COMPATIBLE_IOCTL(SG_GET_PACK_ID)
  3501. COMPATIBLE_IOCTL(SG_GET_NUM_WAITING)
  3502. COMPATIBLE_IOCTL(SG_SET_DEBUG)
  3503. COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE)
  3504. COMPATIBLE_IOCTL(SG_GET_COMMAND_Q)
  3505. COMPATIBLE_IOCTL(SG_SET_COMMAND_Q)
  3506. COMPATIBLE_IOCTL(SG_GET_VERSION_NUM)
  3507. COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN)
  3508. COMPATIBLE_IOCTL(SG_SCSI_RESET)
  3509. COMPATIBLE_IOCTL(SG_IO)
  3510. COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE)
  3511. COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN)
  3512. COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN)
  3513. /* PPP stuff */
  3514. COMPATIBLE_IOCTL(PPPIOCGFLAGS)
  3515. COMPATIBLE_IOCTL(PPPIOCSFLAGS)
  3516. COMPATIBLE_IOCTL(PPPIOCGASYNCMAP)
  3517. COMPATIBLE_IOCTL(PPPIOCSASYNCMAP)
  3518. COMPATIBLE_IOCTL(PPPIOCGUNIT)
  3519. COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP)
  3520. COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP)
  3521. COMPATIBLE_IOCTL(PPPIOCGMRU)
  3522. COMPATIBLE_IOCTL(PPPIOCSMRU)
  3523. COMPATIBLE_IOCTL(PPPIOCSMAXCID)
  3524. COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP)
  3525. COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP)
  3526. COMPATIBLE_IOCTL(PPPIOCXFERUNIT)
  3527. COMPATIBLE_IOCTL(PPPIOCGNPMODE)
  3528. COMPATIBLE_IOCTL(PPPIOCSNPMODE)
  3529. COMPATIBLE_IOCTL(PPPIOCGDEBUG)
  3530. COMPATIBLE_IOCTL(PPPIOCSDEBUG)
  3531. COMPATIBLE_IOCTL(PPPIOCNEWUNIT)
  3532. COMPATIBLE_IOCTL(PPPIOCATTACH)
  3533. COMPATIBLE_IOCTL(PPPIOCDETACH)
  3534. COMPATIBLE_IOCTL(PPPIOCSMRRU)
  3535. COMPATIBLE_IOCTL(PPPIOCCONNECT)
  3536. COMPATIBLE_IOCTL(PPPIOCDISCONN)
  3537. COMPATIBLE_IOCTL(PPPIOCATTCHAN)
  3538. COMPATIBLE_IOCTL(PPPIOCGCHAN)
  3539. /* PPPOX */
  3540. COMPATIBLE_IOCTL(PPPOEIOCSFWD);
  3541. COMPATIBLE_IOCTL(PPPOEIOCDFWD);
  3542. /* CDROM stuff */
  3543. COMPATIBLE_IOCTL(CDROMPAUSE)
  3544. COMPATIBLE_IOCTL(CDROMRESUME)
  3545. COMPATIBLE_IOCTL(CDROMPLAYMSF)
  3546. COMPATIBLE_IOCTL(CDROMPLAYTRKIND)
  3547. COMPATIBLE_IOCTL(CDROMREADTOCHDR)
  3548. COMPATIBLE_IOCTL(CDROMREADTOCENTRY)
  3549. COMPATIBLE_IOCTL(CDROMSTOP)
  3550. COMPATIBLE_IOCTL(CDROMSTART)
  3551. COMPATIBLE_IOCTL(CDROMEJECT)
  3552. COMPATIBLE_IOCTL(CDROMVOLCTRL)
  3553. COMPATIBLE_IOCTL(CDROMSUBCHNL)
  3554. COMPATIBLE_IOCTL(CDROMEJECT_SW)
  3555. COMPATIBLE_IOCTL(CDROMMULTISESSION)
  3556. COMPATIBLE_IOCTL(CDROM_GET_MCN)
  3557. COMPATIBLE_IOCTL(CDROMRESET)
  3558. COMPATIBLE_IOCTL(CDROMVOLREAD)
  3559. COMPATIBLE_IOCTL(CDROMSEEK)
  3560. COMPATIBLE_IOCTL(CDROMPLAYBLK)
  3561. COMPATIBLE_IOCTL(CDROMCLOSETRAY)
  3562. COMPATIBLE_IOCTL(CDROM_SET_OPTIONS)
  3563. COMPATIBLE_IOCTL(CDROM_CLEAR_OPTIONS)
  3564. COMPATIBLE_IOCTL(CDROM_SELECT_SPEED)
  3565. COMPATIBLE_IOCTL(CDROM_SELECT_DISC)
  3566. COMPATIBLE_IOCTL(CDROM_MEDIA_CHANGED)
  3567. COMPATIBLE_IOCTL(CDROM_DRIVE_STATUS)
  3568. COMPATIBLE_IOCTL(CDROM_DISC_STATUS)
  3569. COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS)
  3570. COMPATIBLE_IOCTL(CDROM_LOCKDOOR)
  3571. COMPATIBLE_IOCTL(CDROM_DEBUG)
  3572. COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY)
  3573. /* Big L */
  3574. COMPATIBLE_IOCTL(LOOP_SET_FD)
  3575. COMPATIBLE_IOCTL(LOOP_CLR_FD)
  3576. /* Big Q for sound/OSS */
  3577. COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET)
  3578. COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC)
  3579. COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO)
  3580. COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE)
  3581. COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT)
  3582. COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT)
  3583. COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE)
  3584. COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR)
  3585. COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI)
  3586. COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES)
  3587. COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS)
  3588. COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS)
  3589. COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO)
  3590. COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD)
  3591. COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL)
  3592. COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE)
  3593. COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC)
  3594. COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND)
  3595. COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME)
  3596. COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID)
  3597. COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL)
  3598. COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE)
  3599. /* Big T for sound/OSS */
  3600. COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE)
  3601. COMPATIBLE_IOCTL(SNDCTL_TMR_START)
  3602. COMPATIBLE_IOCTL(SNDCTL_TMR_STOP)
  3603. COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE)
  3604. COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO)
  3605. COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE)
  3606. COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME)
  3607. COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT)
  3608. /* Little m for sound/OSS */
  3609. COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME)
  3610. COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE)
  3611. COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD)
  3612. /* Big P for sound/OSS */
  3613. COMPATIBLE_IOCTL(SNDCTL_DSP_RESET)
  3614. COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC)
  3615. COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED)
  3616. COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO)
  3617. COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE)
  3618. COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS)
  3619. COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER)
  3620. COMPATIBLE_IOCTL(SNDCTL_DSP_POST)
  3621. COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE)
  3622. COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT)
  3623. COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS)
  3624. COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT)
  3625. COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE)
  3626. COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE)
  3627. COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK)
  3628. COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS)
  3629. COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER)
  3630. COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER)
  3631. COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR)
  3632. COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR)
  3633. /* SNDCTL_DSP_MAPINBUF,  XXX needs translation */
  3634. /* SNDCTL_DSP_MAPOUTBUF,  XXX needs translation */
  3635. COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO)
  3636. COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX)
  3637. COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY)
  3638. COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE)
  3639. COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE)
  3640. COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS)
  3641. COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS)
  3642. COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER)
  3643. /* Big C for sound/OSS */
  3644. COMPATIBLE_IOCTL(SNDCTL_COPR_RESET)
  3645. COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD)
  3646. COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA)
  3647. COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE)
  3648. COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA)
  3649. COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE)
  3650. COMPATIBLE_IOCTL(SNDCTL_COPR_RUN)
  3651. COMPATIBLE_IOCTL(SNDCTL_COPR_HALT)
  3652. COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG)
  3653. COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG)
  3654. /* Big M for sound/OSS */
  3655. COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME)
  3656. COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS)
  3657. COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE)
  3658. COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH)
  3659. COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM)
  3660. COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER)
  3661. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE)
  3662. COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC)
  3663. COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD)
  3664. COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX)
  3665. COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM)
  3666. COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV)
  3667. COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN)
  3668. COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN)
  3669. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1)
  3670. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2)
  3671. COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3)
  3672. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1))
  3673. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2))
  3674. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3))
  3675. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN))
  3676. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT))
  3677. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO))
  3678. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO))
  3679. COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR))
  3680. COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE)
  3681. /* SOUND_MIXER_READ_ENHANCE,  same value as READ_MUTE */
  3682. /* SOUND_MIXER_READ_LOUD,  same value as READ_MUTE */
  3683. COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC)
  3684. COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK)
  3685. COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK)
  3686. COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS)
  3687. COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS)
  3688. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME)
  3689. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS)
  3690. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE)
  3691. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH)
  3692. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM)
  3693. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER)
  3694. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE)
  3695. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC)
  3696. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD)
  3697. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX)
  3698. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM)
  3699. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV)
  3700. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN)
  3701. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN)
  3702. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1)
  3703. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2)
  3704. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3)
  3705. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1))
  3706. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2))
  3707. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3))
  3708. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN))
  3709. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT))
  3710. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO))
  3711. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO))
  3712. COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR))
  3713. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE)
  3714. /* SOUND_MIXER_WRITE_ENHANCE,  same value as WRITE_MUTE */
  3715. /* SOUND_MIXER_WRITE_LOUD,  same value as WRITE_MUTE */
  3716. COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC)
  3717. COMPATIBLE_IOCTL(SOUND_MIXER_INFO)
  3718. COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO)
  3719. COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS)
  3720. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1)
  3721. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2)
  3722. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3)
  3723. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4)
  3724. COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5)
  3725. COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS)
  3726. COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS)
  3727. COMPATIBLE_IOCTL(OSS_GETVERSION)
  3728. /* AUTOFS */
  3729. COMPATIBLE_IOCTL(AUTOFS_IOC_READY)
  3730. COMPATIBLE_IOCTL(AUTOFS_IOC_FAIL)
  3731. COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC)
  3732. COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER)
  3733. COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE)
  3734. /* DEVFS */
  3735. COMPATIBLE_IOCTL(DEVFSDIOC_GET_PROTO_REV)
  3736. COMPATIBLE_IOCTL(DEVFSDIOC_SET_EVENT_MASK)
  3737. COMPATIBLE_IOCTL(DEVFSDIOC_RELEASE_EVENT_QUEUE)
  3738. COMPATIBLE_IOCTL(DEVFSDIOC_SET_DEBUG_MASK)
  3739. /* SMB ioctls which do not need any translations */
  3740. COMPATIBLE_IOCTL(SMB_IOC_NEWCONN)
  3741. /* Little a */
  3742. COMPATIBLE_IOCTL(ATMSIGD_CTRL)
  3743. COMPATIBLE_IOCTL(ATMARPD_CTRL)
  3744. COMPATIBLE_IOCTL(ATMLEC_CTRL)
  3745. COMPATIBLE_IOCTL(ATMLEC_MCAST)
  3746. COMPATIBLE_IOCTL(ATMLEC_DATA)
  3747. COMPATIBLE_IOCTL(ATM_SETSC)
  3748. COMPATIBLE_IOCTL(SIOCSIFATMTCP)
  3749. COMPATIBLE_IOCTL(SIOCMKCLIP)
  3750. COMPATIBLE_IOCTL(ATMARP_MKIP)
  3751. COMPATIBLE_IOCTL(ATMARP_SETENTRY)
  3752. COMPATIBLE_IOCTL(ATMARP_ENCAP)
  3753. COMPATIBLE_IOCTL(ATMTCP_CREATE)
  3754. COMPATIBLE_IOCTL(ATMTCP_REMOVE)
  3755. COMPATIBLE_IOCTL(ATMMPC_CTRL)
  3756. COMPATIBLE_IOCTL(ATMMPC_DATA)
  3757. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  3758. /* 0xfe - lvm */
  3759. COMPATIBLE_IOCTL(VG_SET_EXTENDABLE)
  3760. COMPATIBLE_IOCTL(VG_STATUS_GET_COUNT)
  3761. COMPATIBLE_IOCTL(VG_STATUS_GET_NAMELIST)
  3762. COMPATIBLE_IOCTL(VG_REMOVE)
  3763. COMPATIBLE_IOCTL(VG_RENAME)
  3764. COMPATIBLE_IOCTL(VG_REDUCE)
  3765. COMPATIBLE_IOCTL(PE_LOCK_UNLOCK)
  3766. COMPATIBLE_IOCTL(PV_FLUSH)
  3767. COMPATIBLE_IOCTL(LVM_LOCK_LVM)
  3768. COMPATIBLE_IOCTL(LVM_GET_IOP_VERSION)
  3769. #ifdef LVM_TOTAL_RESET
  3770. COMPATIBLE_IOCTL(LVM_RESET)
  3771. #endif
  3772. COMPATIBLE_IOCTL(LV_SET_ACCESS)
  3773. COMPATIBLE_IOCTL(LV_SET_STATUS)
  3774. COMPATIBLE_IOCTL(LV_SET_ALLOCATION)
  3775. COMPATIBLE_IOCTL(LE_REMAP)
  3776. COMPATIBLE_IOCTL(LV_BMAP)
  3777. COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
  3778. #endif /* LVM */
  3779. #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
  3780. COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
  3781. COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)
  3782. COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC)
  3783. COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK)
  3784. COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK)
  3785. COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL)
  3786. COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS)
  3787. COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS)
  3788. COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX)
  3789. COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX)
  3790. COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX)
  3791. COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX)
  3792. COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX)
  3793. COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX)
  3794. COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW)
  3795. COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW)
  3796. COMPATIBLE_IOCTL(DRM_IOCTL_LOCK)
  3797. COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK)
  3798. COMPATIBLE_IOCTL(DRM_IOCTL_FINISH)
  3799. #endif /* DRM */
  3800. #ifdef CONFIG_AUTOFS_FS
  3801. COMPATIBLE_IOCTL(AUTOFS_IOC_READY);
  3802. COMPATIBLE_IOCTL(AUTOFS_IOC_FAIL);
  3803. COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC);
  3804. COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER);
  3805. COMPATIBLE_IOCTL(AUTOFS_IOC_SETTIMEOUT);
  3806. COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE);
  3807. #endif
  3808. #ifdef CONFIG_RTC
  3809. COMPATIBLE_IOCTL(RTC_AIE_ON);
  3810. COMPATIBLE_IOCTL(RTC_AIE_OFF);
  3811. COMPATIBLE_IOCTL(RTC_UIE_ON);
  3812. COMPATIBLE_IOCTL(RTC_UIE_OFF);
  3813. COMPATIBLE_IOCTL(RTC_PIE_ON);
  3814. COMPATIBLE_IOCTL(RTC_PIE_OFF);
  3815. COMPATIBLE_IOCTL(RTC_WIE_ON);
  3816. COMPATIBLE_IOCTL(RTC_WIE_OFF);
  3817. COMPATIBLE_IOCTL(RTC_ALM_SET);
  3818. COMPATIBLE_IOCTL(RTC_ALM_READ);
  3819. COMPATIBLE_IOCTL(RTC_RD_TIME);
  3820. COMPATIBLE_IOCTL(RTC_SET_TIME);
  3821. COMPATIBLE_IOCTL(RTC_IRQP_READ);
  3822. COMPATIBLE_IOCTL(RTC_IRQP_SET);
  3823. COMPATIBLE_IOCTL(RTC_EPOCH_READ);
  3824. COMPATIBLE_IOCTL(RTC_EPOCH_SET);
  3825. COMPATIBLE_IOCTL(RTC_WKALM_SET);
  3826. COMPATIBLE_IOCTL(RTC_WKALM_RD);
  3827. #endif
  3828. HANDLE_IOCTL(REISERFS_IOC_UNPACK32, reiserfs_ioctl32);
  3829. HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32, vfat_ioctl32);
  3830. HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32, vfat_ioctl32);
  3831. /* serial driver */ 
  3832. HANDLE_IOCTL(TIOCGSERIAL, serial_struct_ioctl);
  3833. HANDLE_IOCTL(TIOCSSERIAL, serial_struct_ioctl);
  3834. /* elevator */
  3835. COMPATIBLE_IOCTL(BLKELVGET)
  3836. COMPATIBLE_IOCTL(BLKELVSET)
  3837. /* Misc. */
  3838. COMPATIBLE_IOCTL(0x41545900) /* ATYIO_CLKR */
  3839. COMPATIBLE_IOCTL(0x41545901) /* ATYIO_CLKW */
  3840. COMPATIBLE_IOCTL(PCIIOC_CONTROLLER)
  3841. COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO)
  3842. COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM)
  3843. COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE)
  3844. /* And these ioctls need translation */
  3845. HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32)
  3846. HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf)
  3847. HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc)
  3848. HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc)
  3849. HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc)
  3850. HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc)
  3851. HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc)
  3852. HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc)
  3853. HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc)
  3854. HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc)
  3855. HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc)
  3856. HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc)
  3857. HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc)
  3858. HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc)
  3859. HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc)
  3860. HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc)
  3861. HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc)
  3862. HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc)
  3863. HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc)
  3864. HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc)
  3865. HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc)
  3866. HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc)
  3867. HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc)
  3868. HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc)
  3869. HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc)
  3870. HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc)
  3871. HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc)
  3872. HANDLE_IOCTL(SIOCGPPPSTATS, dev_ifsioc)
  3873. HANDLE_IOCTL(SIOCGPPPCSTATS, dev_ifsioc)
  3874. HANDLE_IOCTL(SIOCGPPPVER, dev_ifsioc)
  3875. HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc)
  3876. HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc)
  3877. HANDLE_IOCTL(SIOCETHTOOL, ethtool_ioctl)
  3878. HANDLE_IOCTL(SIOCADDRT, routing_ioctl)
  3879. HANDLE_IOCTL(SIOCDELRT, routing_ioctl)
  3880. /* Raw devices */
  3881. HANDLE_IOCTL(RAW_SETBIND, raw_ioctl)
  3882. /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
  3883. HANDLE_IOCTL(SIOCRTMSG, ret_einval)
  3884. HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp)
  3885. HANDLE_IOCTL(HDIO_GETGEO, hdio_getgeo)
  3886. HANDLE_IOCTL(BLKRAGET, w_long)
  3887. HANDLE_IOCTL(BLKGETSIZE, w_long)
  3888. HANDLE_IOCTL(0x1260, broken_blkgetsize)
  3889. HANDLE_IOCTL(BLKFRAGET, w_long)
  3890. HANDLE_IOCTL(BLKSECTGET, w_long)
  3891. HANDLE_IOCTL(BLKPG, blkpg_ioctl_trans)
  3892. HANDLE_IOCTL(FBIOGETCMAP, fb_ioctl_trans)
  3893. HANDLE_IOCTL(FBIOPUTCMAP, fb_ioctl_trans)
  3894. HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans)
  3895. HANDLE_IOCTL(HDIO_GET_UNMASKINTR, hdio_ioctl_trans)
  3896. HANDLE_IOCTL(HDIO_GET_DMA, hdio_ioctl_trans)
  3897. HANDLE_IOCTL(HDIO_GET_32BIT, hdio_ioctl_trans)
  3898. HANDLE_IOCTL(HDIO_GET_MULTCOUNT, hdio_ioctl_trans)
  3899. HANDLE_IOCTL(HDIO_GET_NOWERR, hdio_ioctl_trans)
  3900. HANDLE_IOCTL(HDIO_GET_NICE, hdio_ioctl_trans)
  3901. HANDLE_IOCTL(FDSETPRM32, fd_ioctl_trans)
  3902. HANDLE_IOCTL(FDDEFPRM32, fd_ioctl_trans)
  3903. HANDLE_IOCTL(FDGETPRM32, fd_ioctl_trans)
  3904. HANDLE_IOCTL(FDSETDRVPRM32, fd_ioctl_trans)
  3905. HANDLE_IOCTL(FDGETDRVPRM32, fd_ioctl_trans)
  3906. HANDLE_IOCTL(FDGETDRVSTAT32, fd_ioctl_trans)
  3907. HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans)
  3908. HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans)
  3909. HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans)
  3910. HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans)
  3911. HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans)
  3912. HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans)
  3913. HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans)
  3914. HANDLE_IOCTL(MTIOCGETCONFIG32, mt_ioctl_trans)
  3915. HANDLE_IOCTL(MTIOCSETCONFIG32, mt_ioctl_trans)
  3916. HANDLE_IOCTL(CDROMREADMODE2, cdrom_ioctl_trans)
  3917. HANDLE_IOCTL(CDROMREADMODE1, cdrom_ioctl_trans)
  3918. HANDLE_IOCTL(CDROMREADRAW, cdrom_ioctl_trans)
  3919. HANDLE_IOCTL(CDROMREADCOOKED, cdrom_ioctl_trans)
  3920. HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans)
  3921. HANDLE_IOCTL(CDROMREADALL, cdrom_ioctl_trans)
  3922. HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans)
  3923. HANDLE_IOCTL(LOOP_SET_STATUS, loop_status)
  3924. HANDLE_IOCTL(LOOP_GET_STATUS, loop_status)
  3925. #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
  3926. HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout)
  3927. HANDLE_IOCTL(PIO_FONTX, do_fontx_ioctl)
  3928. HANDLE_IOCTL(GIO_FONTX, do_fontx_ioctl)
  3929. HANDLE_IOCTL(PIO_UNIMAP, do_unimap_ioctl)
  3930. HANDLE_IOCTL(GIO_UNIMAP, do_unimap_ioctl)
  3931. HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl)
  3932. HANDLE_IOCTL(EXT2_IOC32_GETFLAGS, do_ext2_ioctl)
  3933. HANDLE_IOCTL(EXT2_IOC32_SETFLAGS, do_ext2_ioctl)
  3934. HANDLE_IOCTL(EXT2_IOC32_GETVERSION, do_ext2_ioctl)
  3935. HANDLE_IOCTL(EXT2_IOC32_SETVERSION, do_ext2_ioctl)
  3936. HANDLE_IOCTL(VIDIOCGTUNER32, do_video_ioctl)
  3937. HANDLE_IOCTL(VIDIOCSTUNER32, do_video_ioctl)
  3938. HANDLE_IOCTL(VIDIOCGWIN32, do_video_ioctl)
  3939. HANDLE_IOCTL(VIDIOCSWIN32, do_video_ioctl)
  3940. HANDLE_IOCTL(VIDIOCGFBUF32, do_video_ioctl)
  3941. HANDLE_IOCTL(VIDIOCSFBUF32, do_video_ioctl)
  3942. HANDLE_IOCTL(VIDIOCGFREQ32, do_video_ioctl)
  3943. HANDLE_IOCTL(VIDIOCSFREQ32, do_video_ioctl)
  3944. /* One SMB ioctl needs translations. */
  3945. #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, __kernel_uid_t32)
  3946. HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid)
  3947. HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl)
  3948. HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl)
  3949. HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl)
  3950. HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl)
  3951. HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl)
  3952. HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl)
  3953. HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl)
  3954. HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl)
  3955. HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl)
  3956. HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl)
  3957. HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl)
  3958. HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl)
  3959. HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl)
  3960. HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl)
  3961. HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl)
  3962. HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl)
  3963. HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl)
  3964. HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl)
  3965. HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl)
  3966. HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl)
  3967. HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl)
  3968. HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl)
  3969. HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl)
  3970. HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl)
  3971. HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl)
  3972. #if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
  3973. HANDLE_IOCTL(VG_STATUS, do_lvm_ioctl)
  3974. HANDLE_IOCTL(VG_CREATE, do_lvm_ioctl)
  3975. HANDLE_IOCTL(VG_EXTEND, do_lvm_ioctl)
  3976. HANDLE_IOCTL(LV_CREATE, do_lvm_ioctl)
  3977. HANDLE_IOCTL(LV_REMOVE, do_lvm_ioctl)
  3978. HANDLE_IOCTL(LV_EXTEND, do_lvm_ioctl)
  3979. HANDLE_IOCTL(LV_REDUCE, do_lvm_ioctl)
  3980. HANDLE_IOCTL(LV_RENAME, do_lvm_ioctl)
  3981. HANDLE_IOCTL(LV_STATUS_BYNAME, do_lvm_ioctl)
  3982. HANDLE_IOCTL(LV_STATUS_BYINDEX, do_lvm_ioctl)
  3983. HANDLE_IOCTL(PV_CHANGE, do_lvm_ioctl)
  3984. HANDLE_IOCTL(PV_STATUS, do_lvm_ioctl)
  3985. #endif /* LVM */
  3986. #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
  3987. HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version);
  3988. HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique);
  3989. HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique);
  3990. HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap);
  3991. HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs);
  3992. HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs);
  3993. HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs);
  3994. HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma);
  3995. HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx);
  3996. #endif /* DRM */
  3997. HANDLE_IOCTL(VFAT_IOCTL_READDIR_BOTH32, vfat_ioctl32);
  3998. HANDLE_IOCTL(VFAT_IOCTL_READDIR_SHORT32, vfat_ioctl32);
  3999. IOCTL_TABLE_END
  4001. #define IOCTL_HASHSIZE 256
  4002. struct ioctl_trans *ioctl32_hash_table[IOCTL_HASHSIZE];
  4004. extern struct ioctl_trans ioctl_start[], ioctl_end[]; 
  4006. static inline unsigned long ioctl32_hash(unsigned long cmd)
  4007. {
  4008. return (((cmd >> 6) ^ (cmd >> 4) ^ cmd)) % IOCTL_HASHSIZE;
  4009. }
  4011. static void ioctl32_insert_translation(struct ioctl_trans *trans)
  4012. {
  4013. unsigned long hash;
  4014. struct ioctl_trans *t;
  4016. hash = ioctl32_hash (trans->cmd);
  4017. if (!ioctl32_hash_table[hash])
  4018. ioctl32_hash_table[hash] = trans;
  4019. else {
  4020. t = ioctl32_hash_table[hash];
  4021. while (t->next)
  4022. t = t->next;
  4023. trans->next = 0;
  4024. t->next = trans;
  4025. }
  4026. }
  4028. static int __init init_sys32_ioctl(void)
  4029. {
  4030. int i;
  4032. for (i = 0; &ioctl_start[i] < &ioctl_end[0]; i++) {
  4033. if (ioctl_start[i].next != 0) { 
  4034. printk("ioctl translation %d badn",i); 
  4035. return -1;
  4036. }
  4038. ioctl32_insert_translation(&ioctl_start[i]);
  4039. }
  4040. return 0;
  4041. }
  4043. __initcall(init_sys32_ioctl);
  4045. static struct ioctl_trans *ioctl_free_list;
  4047. /* Never free them really. This avoids SMP races. With a Read-Copy-Update
  4048.    enabled kernel we could just use the RCU infrastructure for this. */
  4049. static void free_ioctl(struct ioctl_trans *t) 
  4050. { 
  4051. t->cmd = 0; 
  4052. mb();
  4053. t->next = ioctl_free_list;
  4054. ioctl_free_list = t;
  4055. } 
  4057. int register_ioctl32_conversion(unsigned int cmd, int (*handler)(unsigned int, unsigned int, unsigned long, struct file *))
  4058. {
  4059. struct ioctl_trans *t;
  4060. unsigned long hash = ioctl32_hash(cmd);
  4062. lock_kernel(); 
  4063. for (t = (struct ioctl_trans *)ioctl32_hash_table[hash];
  4064.      t;
  4065.      t = t->next) { 
  4066. if (t->cmd == cmd) {
  4067. printk("Trying to register duplicated ioctl32 handler %xn", cmd);
  4068. unlock_kernel();
  4069. return -EINVAL;
  4070. }
  4071. }
  4073. if (ioctl_free_list) { 
  4074. t = ioctl_free_list; 
  4075. ioctl_free_list = t->next; 
  4076. } else { 
  4077. t = kmalloc(sizeof(struct ioctl_trans), GFP_KERNEL); 
  4078. if (!t) { 
  4079. unlock_kernel();
  4080. return -ENOMEM;
  4081. }
  4082. }
  4084. t->next = NULL;
  4085. t->cmd = cmd;
  4086. t->handler = handler; 
  4087. ioctl32_insert_translation(t);
  4089. unlock_kernel();
  4090. return 0;
  4091. }
  4093. static inline int builtin_ioctl(struct ioctl_trans *t)
  4094. { 
  4095. return t >= (struct ioctl_trans *)ioctl_start &&
  4096.        t < (struct ioctl_trans *)ioctl_end; 
  4097. } 
  4099. /* Problem: 
  4100.    This function cannot unregister duplicate ioctls, because they are not
  4101.    unique.
  4102.    When they happen we need to extend the prototype to pass handler too. */
  4104. int unregister_ioctl32_conversion(unsigned int cmd)
  4105. {
  4106. unsigned long hash = ioctl32_hash(cmd);
  4107. struct ioctl_trans *t, *t1;
  4109. lock_kernel(); 
  4111. t = (struct ioctl_trans *)ioctl32_hash_table[hash];
  4112. if (!t) { 
  4113. unlock_kernel();
  4114. return -EINVAL;
  4115. } 
  4117. if (t->cmd == cmd) { 
  4118. if (builtin_ioctl(t)) {
  4119. printk("%p tried to unregister builtin ioctl %xn",
  4120.        __builtin_return_address(0), cmd);
  4121. } else { 
  4122. ioctl32_hash_table[hash] = t->next;
  4123. free_ioctl(t); 
  4124. unlock_kernel();
  4125. return 0;
  4126. }
  4127. } 
  4128. while (t->next) {
  4129. t1 = (struct ioctl_trans *)(long)t->next;
  4130. if (t1->cmd == cmd) { 
  4131. if (builtin_ioctl(t1)) {
  4132. printk("%p tried to unregister builtin ioctl %xn",
  4133.        __builtin_return_address(0), cmd);
  4134. goto out;
  4135. } else { 
  4136. t->next = t1->next;
  4137. free_ioctl(t1); 
  4138. unlock_kernel();
  4139. return 0;
  4140. }
  4141. }
  4142. t = t1;
  4143. }
  4144. printk(KERN_ERR "Trying to free unknown 32bit ioctl handler %xn", cmd);
  4145.  out:
  4146. unlock_kernel();
  4147. return -EINVAL;
  4148. }
  4150. EXPORT_SYMBOL(register_ioctl32_conversion); 
  4151. EXPORT_SYMBOL(unregister_ioctl32_conversion); 
  4153. asmlinkage int sys32_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  4154. {
  4155. struct file * filp;
  4156. int error = -EBADF;
  4157. int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
  4158. struct ioctl_trans *t;
  4160. filp = fget(fd);
  4161. if(!filp)
  4162. goto out2;
  4164. if (!filp->f_op || !filp->f_op->ioctl) {
  4165. error = sys_ioctl (fd, cmd, arg);
  4166. goto out;
  4167. }
  4169. t = (struct ioctl_trans *)ioctl32_hash_table [ioctl32_hash (cmd)];
  4171. while (t && t->cmd != cmd)
  4172. t = (struct ioctl_trans *)t->next;
  4173. if (t) {
  4174. handler = t->handler;
  4175. error = handler(fd, cmd, arg, filp);
  4176. } else {
  4177. static int count = 0;
  4178. if (++count <= 50)
  4179. printk("sys32_ioctl(%s:%d): Unknown cmd fd(%d) "
  4180.        "cmd(%08x) arg(%08x)n",
  4181.        current->comm, current->pid,
  4182.        (int)fd, (unsigned int)cmd, (unsigned int)arg);
  4183. error = -EINVAL;
  4184. }
  4185. out:
  4186. fput(filp);
  4187. out2:
  4188. return error;
  4189. }
  4191. extern unsigned long ia32_sys_call_table[];
  4192. EXPORT_SYMBOL(ia32_sys_call_table);